crc-32 1.2.2: buf

audit=false

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify crc-32.buf in pkg:npm/crc-32@1.2.2
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/crc-32@1.2.2
Demonstrate these symbols/APIs:
  - crc-32.buf

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:2d40a0cde437cda05e361b8da586a2aba85939ba1abbf94ddf5107308e5845f2","contract":["CRC32.buf calculates the signed 32-bit CRC-32 checksum for a Buffer","CRC32.buf calculates identical checksums for Uint8Array and Array of byte values","CRC32.buf returns 0 for an empty buffer when seed is omitted","CRC32.buf supports incremental hashing using a starting seed across partitioned buffers","CRC32.buf accurately computes checksums for buffers shorter than 16 bytes and larger than 16 bytes","computeCrc32Hex formats signed checksum as an unsigned 32-bit hexadecimal string"],"goal":"verify crc-32.buf in pkg:npm/crc-32@1.2.2","kind":"HOW","packages":["pkg:npm/crc-32@1.2.2"],"schemaVersion":1,"symbols":["crc-32.buf"]},"contractCommand":["node","test/contract.mjs"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"npm","language":"javascript","libc":"glibc","libcVersion":"2.39","moduleSystem":"esm","os":"linux","osVersionBucket":"24","packageManager":"npm","packageManagerVersion":"10.9.8","runtime":"node","runtimeVersion":"22.23.2","schemaVersion":1},"license":"MIT-0","packages":["pkg:npm/crc-32@1.2.2"],"schemaVersion":1,"subject":"pkg:npm/crc-32@1.2.2","symbols":["crc-32.buf"],"verifierAdapter":"node-typescript@1"}

{
  "name": "sample-crc-32-buf",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-crc-32-buf",
      "version": "1.0.0",
      "license": "MIT-0",
      "dependencies": {
        "crc-32": "1.2.2"
      }
    },
    "node_modules/crc-32": {
      "version": "1.2.2",
      "resolved": "https://registry.npmjs.org/crc-32/-/crc-32-1.2.2.tgz",
      "integrity": "sha512-ROmzCKrTnOwybPcJApAA6WBWij23HVfGVNKqqrZpuyZOHqK2CwHSvpGuyt/UNNvaIjEd8X5IFGp4Mh+Ie1IHJQ==",
      "license": "Apache-2.0",
      "bin": {
        "crc32": "bin/crc32.njs"
      },
      "engines": {
        "node": ">=0.8"
      }
    }
  }
}

{
  "name": "sample-crc-32-buf",
  "version": "1.0.0",
  "type": "module",
  "private": true,
  "license": "MIT-0",
  "scripts": {
    "test": "node test/contract.mjs"
  },
  "dependencies": {
    "crc-32": "1.2.2"
  }
}

{
  "schemaVersion": 1,
  "goal": "verify crc-32.buf in pkg:npm/crc-32@1.2.2",
  "kind": "HOW",
  "packages": [
    "pkg:npm/crc-32@1.2.2"
  ],
  "symbols": [
    "crc-32.buf"
  ]
}

import CRC32 from 'crc-32';

/**
 * Calculates signed 32-bit CRC-32 checksum of a Buffer, Uint8Array, or byte array.
 *
 * @param {Buffer | Uint8Array | number[]} data - Binary data or byte array
 * @param {number} [seed=0] - Optional seed for incremental hashing
 * @returns {number} Signed 32-bit integer checksum
 */
export function calculateCrc32(data, seed = 0) {
  return CRC32.buf(data, seed);
}

/**
 * Calculates unsigned 32-bit CRC-32 checksum of a Buffer, Uint8Array, or byte array.
 *
 * @param {Buffer | Uint8Array | number[]} data - Binary data or byte array
 * @param {number} [seed=0] - Optional seed for incremental hashing
 * @returns {number} Unsigned 32-bit integer checksum (0 to 4294967295)
 */
export function calculateCrc32Unsigned(data, seed = 0) {
  return CRC32.buf(data, seed) >>> 0;
}

/**
 * Computes CRC-32 checksum formatted as an 8-character zero-padded lowercase hexadecimal string.
 *
 * @param {Buffer | Uint8Array | number[]} data - Binary data or byte array
 * @param {number} [seed=0] - Optional seed for incremental hashing
 * @returns {string} 8-character hexadecimal string
 */
export function computeCrc32Hex(data, seed = 0) {
  const unsigned = calculateCrc32Unsigned(data, seed);
  return unsigned.toString(16).padStart(8, '0');
}

/**
 * Calculates CRC-32 across a sequence of binary chunks incrementally.
 *
 * @param {Iterable<Buffer | Uint8Array | number[]>} chunks - Sequence of binary chunks
 * @param {number} [seed=0] - Initial seed
 * @returns {number} Final signed 32-bit integer checksum
 */
export function calculateCrc32Stream(chunks, seed = 0) {
  let currentCrc = seed;
  for (const chunk of chunks) {
    currentCrc = CRC32.buf(chunk, currentCrc);
  }
  return currentCrc;
}

export { CRC32 };
export default calculateCrc32;

import assert from 'node:assert/strict';
import {
  CRC32,
  calculateCrc32,
  calculateCrc32Unsigned,
  computeCrc32Hex,
  calculateCrc32Stream
} from '../src/index.mjs';

// 1. CRC32.buf calculates the signed 32-bit CRC-32 checksum for a Buffer
{
  const buf = Buffer.from('SheetJS');
  const directCrc = CRC32.buf(buf);
  const helperCrc = calculateCrc32(buf);

  assert.strictEqual(typeof directCrc, 'number');
  assert.strictEqual(directCrc, -1647298270);
  assert.strictEqual(helperCrc, -1647298270);

  const testVector = Buffer.from('123456789');
  const testVectorCrc = CRC32.buf(testVector);
  assert.strictEqual(testVectorCrc, -873187034);
}

// 2. CRC32.buf calculates identical checksums for Uint8Array and Array of byte values
{
  const expectedCrc = -1647298270;
  const rawBytes = [83, 104, 101, 101, 116, 74, 83];
  const uint8Arr = new Uint8Array(rawBytes);

  const arrayCrc = CRC32.buf(rawBytes);
  const uint8Crc = CRC32.buf(uint8Arr);

  assert.strictEqual(arrayCrc, expectedCrc);
  assert.strictEqual(uint8Crc, expectedCrc);
  assert.strictEqual(calculateCrc32(uint8Arr), expectedCrc);
  assert.strictEqual(calculateCrc32(rawBytes), expectedCrc);
}

// 3. CRC32.buf returns 0 for an empty buffer when seed is omitted
{
  const emptyBuf = Buffer.alloc(0);
  const emptyUint8 = new Uint8Array([]);
  const emptyArr = [];

  assert.strictEqual(CRC32.buf(emptyBuf), 0);
  assert.strictEqual(CRC32.buf(emptyUint8), 0);
  assert.strictEqual(CRC32.buf(emptyArr), 0);
  assert.strictEqual(calculateCrc32(emptyBuf), 0);
}

// 4. CRC32.buf supports incremental hashing using a starting seed across partitioned buffers
{
  const part1 = Buffer.from('Sheet');
  const part2 = Buffer.from('JS');
  const combined = Buffer.from('SheetJS');

  const crc1 = CRC32.buf(part1, 0);
  const crc2 = CRC32.buf(part2, crc1);

  assert.strictEqual(crc2, CRC32.buf(combined));
  assert.strictEqual(calculateCrc32Stream([part1, part2]), CRC32.buf(combined));

  const partA = Buffer.from('Hello, ');
  const partB = Buffer.from('World!');
  const full = Buffer.from('Hello, World!');
  const streamResult = calculateCrc32Stream([partA, partB]);
  assert.strictEqual(streamResult, CRC32.buf(full));
}

// 5. CRC32.buf accurately computes checksums for buffers shorter than 16 bytes and larger than 16 bytes
{
  // Shorter than 16 bytes (< 16 tests byte loop)
  const shortBuf = Buffer.from('abc');
  const shortCrc = CRC32.buf(shortBuf);
  assert.strictEqual(typeof shortCrc, 'number');

  // Larger than 16 bytes (tests slice-by-16 loop)
  const longBuf = Buffer.from('The quick brown fox jumps over the lazy dog and runs away fast!!');
  assert.ok(longBuf.length > 16);
  const fullCrc = CRC32.buf(longBuf);
  assert.strictEqual(typeof fullCrc, 'number');

  const head = longBuf.subarray(0, 20);
  const tail = longBuf.subarray(20);
  const splitCrc = CRC32.buf(tail, CRC32.buf(head));
  assert.strictEqual(splitCrc, fullCrc);
}

// 6. computeCrc32Hex formats signed checksum as an unsigned 32-bit hexadecimal string
{
  const sheetjsBuf = Buffer.from('SheetJS');
  const unsignedVal = calculateCrc32Unsigned(sheetjsBuf);
  assert.strictEqual(unsignedVal, 2647669026);
  assert.ok(unsignedVal >= 0 && unsignedVal <= 0xffffffff);

  const hexVal = computeCrc32Hex(sheetjsBuf);
  assert.strictEqual(hexVal, '9dd03922');
  assert.strictEqual(hexVal.length, 8);

  const emptyHex = computeCrc32Hex(Buffer.alloc(0));
  assert.strictEqual(emptyHex, '00000000');
}

console.log('All pkg:npm/crc-32@1.2.2 contracts passed successfully.');