32-Bit CRC Algorithms

import { crc32, crc32mpeg2, crcjam } from "crc";
import crc32 from "crc/crc32";
import crc32mpeg2 from "crc/crc32mpeg2";
import crcjam from "crc/crcjam";

// Raw calculators
import crc32Calculator from "crc/calculators/crc32";
import crc32mpeg2Calculator from "crc/calculators/crc32mpeg2";
import crcjamCalculator from "crc/calculators/crcjam";

const { crc32, crc32mpeg2, crcjam } = require("crc");
const crc32 = require("crc/crc32");
const crc32mpeg2 = require("crc/crc32mpeg2");
const crcjam = require("crc/crcjam");

// Raw calculators
const crc32Calculator = require("crc/calculators/crc32");
const crc32mpeg2Calculator = require("crc/calculators/crc32mpeg2");
const crcjamCalculator = require("crc/calculators/crcjam");

/**
 * Calculate standard CRC32 checksum (most commonly used CRC algorithm)
 * @param value - Input data as string, ArrayBuffer, or Buffer
 * @param previous - Previous CRC value for incremental calculation (optional)
 * @returns CRC32 checksum as unsigned 32-bit number
 */
function crc32(value: BufferInput, previous?: number): number;

/**
 * CRC32 function with additional properties
 */
interface CRC32Module extends CRCModule {
  /** Returns signed CRC32 value */
  signed: (value: BufferInput, previous?: number) => number;
  /** Returns unsigned CRC32 value (same as main function) */
  unsigned: (value: BufferInput, previous?: number) => number;
  /** CRC model identifier: "crc-32" */
  model: "crc-32";
}

/**
 * Calculate CRC32 MPEG-2 checksum (used in MPEG-2 standard)
 * @param value - Input data as string, ArrayBuffer, or Buffer
 * @param previous - Previous CRC value for incremental calculation (optional)
 * @returns CRC32 MPEG-2 checksum as unsigned 32-bit number
 */
function crc32mpeg2(value: BufferInput, previous?: number): number;

/**
 * CRC32 MPEG-2 function with additional properties
 */
interface CRC32MPEG2Module extends CRCModule {
  /** Returns signed CRC32 MPEG-2 value */
  signed: (value: BufferInput, previous?: number) => number;
  /** Returns unsigned CRC32 MPEG-2 value (same as main function) */
  unsigned: (value: BufferInput, previous?: number) => number;
  /** CRC model identifier: "crc-32-mpeg" */
  model: "crc-32-mpeg";
}

/**
 * Calculate CRCJAM checksum (JAM CRC algorithm)
 * @param value - Input data as string, ArrayBuffer, or Buffer
 * @param previous - Previous CRC value for incremental calculation (optional)
 * @returns CRCJAM checksum as unsigned 32-bit number
 */
function crcjam(value: BufferInput, previous?: number): number;

/**
 * CRCJAM function with additional properties
 */
interface CRCJAMModule extends CRCModule {
  /** Returns signed CRCJAM value */
  signed: (value: BufferInput, previous?: number) => number;
  /** Returns unsigned CRCJAM value (same as main function) */
  unsigned: (value: BufferInput, previous?: number) => number;
  /** CRC model identifier: "jam" */
  model: "jam";
}

/**
 * Raw CRC32 calculator function for Uint8Array input
 * @param current - Input data as Uint8Array
 * @param previous - Previous CRC value for incremental calculation (optional, defaults to 0)
 * @returns CRC32 checksum as number
 */
function crc32Calculator(current: Uint8Array, previous?: number): number;

/**
 * Raw CRC32 MPEG-2 calculator function for Uint8Array input
 * @param current - Input data as Uint8Array
 * @param previous - Previous CRC value for incremental calculation (optional, defaults to 0)
 * @returns CRC32 MPEG-2 checksum as number
 */
function crc32mpeg2Calculator(current: Uint8Array, previous?: number): number;

/**
 * Raw CRCJAM calculator function for Uint8Array input
 * @param current - Input data as Uint8Array
 * @param previous - Previous CRC value for incremental calculation (optional, defaults to 0)
 * @returns CRCJAM checksum as number
 */
function crcjamCalculator(current: Uint8Array, previous?: number): number;

import { crc32, crc32mpeg2, crcjam } from "crc";

const data = "hello world";

// Calculate different CRC32 variants
const standardCrc32 = crc32(data);
const mpeg2Crc32 = crc32mpeg2(data);
const jamCrc = crcjam(data);

console.log("CRC32:", standardCrc32.toString(16));
console.log("CRC32 MPEG-2:", mpeg2Crc32.toString(16));
console.log("CRCJAM:", jamCrc.toString(16));

import crc32 from "crc/crc32";
import fs from "fs";

// Calculate CRC32 of a file (common use case)
const fileContent = fs.readFileSync("document.pdf");
const fileCrc = crc32(fileContent);
console.log("File CRC32:", fileCrc.toString(16));

// ZIP file CRC verification
const zipEntryData = fs.readFileSync("archive-entry.txt");
const zipCrc = crc32(zipEntryData);
console.log("ZIP entry CRC32:", zipCrc.toString(16));

import crc32 from "crc/crc32";

// Ethernet frame CRC calculation
const ethernetFrame = Buffer.from([
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // Destination MAC
  0x00, 0x11, 0x22, 0x33, 0x44, 0x55, // Source MAC
  0x08, 0x00, // EtherType
  // ... payload data
]);

const ethernetCrc = crc32(ethernetFrame);
console.log("Ethernet CRC32:", ethernetCrc.toString(16));

import crc32mpeg2 from "crc/crc32mpeg2";

// MPEG-2 transport stream packet CRC
const mpeg2Packet = Buffer.from([
  0x47, // Sync byte
  0x40, 0x00, // PID and flags
  0x10, // Continuity counter
  // ... payload data
]);

const mpeg2Crc = crc32mpeg2(mpeg2Packet);
console.log("MPEG-2 CRC32:", mpeg2Crc.toString(16));

import crc32 from "crc/crc32";
import fs from "fs";

// Process large file in chunks
const filename = "large-file.bin";
const fileSize = fs.statSync(filename).size;
const chunkSize = 64 * 1024; // 64KB chunks
const fd = fs.openSync(filename, "r");

let crcValue = 0;
let bytesRead = 0;

while (bytesRead < fileSize) {
  const buffer = Buffer.alloc(Math.min(chunkSize, fileSize - bytesRead));
  const readBytes = fs.readSync(fd, buffer, 0, buffer.length, bytesRead);
  
  crcValue = crc32(buffer.slice(0, readBytes), crcValue);
  bytesRead += readBytes;
  
  console.log(`Processed: ${((bytesRead / fileSize) * 100).toFixed(1)}%`);
}

fs.closeSync(fd);
console.log("Final CRC32:", crcValue.toString(16));

import crc32Calculator from "crc/calculators/crc32";

// Use raw calculator for maximum performance
const encoder = new TextEncoder();
const data = encoder.encode("high-performance data processing");

console.time("CRC32 calculation");
const result = crc32Calculator(data);
console.timeEnd("CRC32 calculation");

console.log("CRC32 result:", result.toString(16));

import crc32 from "crc/crc32";

class CRC32Stream {
  private crcValue: number = 0;
  private totalBytes: number = 0;

  update(chunk: Buffer | string): void {
    this.crcValue = crc32(chunk, this.crcValue);
    this.totalBytes += Buffer.isBuffer(chunk) ? chunk.length : Buffer.byteLength(chunk);
  }

  digest(): { crc: number; bytes: number } {
    return {
      crc: this.crcValue,
      bytes: this.totalBytes
    };
  }

  verify(expectedCrc: number): boolean {
    return this.crcValue === expectedCrc;
  }

  reset(): void {
    this.crcValue = 0;
    this.totalBytes = 0;
  }
}

// Usage
const stream = new CRC32Stream();
stream.update("Hello, ");
stream.update("world!");
stream.update(Buffer.from(" Binary data", "utf8"));

const result = stream.digest();
console.log(`Processed ${result.bytes} bytes, CRC32: ${result.crc.toString(16)}`);

import crc32 from "crc/crc32";

const data = "test data";

// Different result formats
const unsigned = crc32(data);           // 0 to 4294967295 range
const signed = crc32.signed(data);      // -2147483648 to 2147483647 range
const alsoUnsigned = crc32.unsigned(data); // Same as main function

console.log("Unsigned:", unsigned);
console.log("Signed:", signed);
console.log("Hex format:", unsigned.toString(16));
console.log("Model:", crc32.model); // "crc-32"

// Convert between signed and unsigned
const convertedUnsigned = signed >>> 0; // Convert signed to unsigned
console.log("Converted:", convertedUnsigned === unsigned);

import { crc32, crc32mpeg2, crcjam } from "crc";

const testData = "Comparison test data";

// Compare all 32-bit algorithms
const results = {
  crc32: crc32(testData),
  crc32mpeg2: crc32mpeg2(testData),
  crcjam: crcjam(testData)
};

console.log("CRC Algorithm Comparison:");
Object.entries(results).forEach(([algorithm, value]) => {
  console.log(`${algorithm}: ${value.toString(16).padStart(8, '0')}`);
});

import crc32 from "crc/crc32";

// Process binary data
const binaryData = new ArrayBuffer(256);
const view = new Uint8Array(binaryData);

// Fill with test pattern
for (let i = 0; i < view.length; i++) {
  view[i] = i % 256;
}

const binaryCrc = crc32(binaryData);
console.log("Binary data CRC32:", binaryCrc.toString(16));

// Also works with typed arrays directly
const typedArray = new Uint8Array([0x48, 0x65, 0x6C, 0x6C, 0x6F]); // "Hello"
const typedArrayCrc = crc32(typedArray.buffer);
console.log("Typed array CRC32:", typedArrayCrc.toString(16));