@hkdigital/lib-core 0.4.56 → 0.4.57

package/dist/util/checksum/README.md

@@ -0,0 +1,267 @@
+# CRC32 Checksum Utilities
+
+Fast, modular CRC32 implementation with support for strings, buffers, and 
+large file processing.
+
+## Features
+
+- **Standard CRC32**: IEEE 802.3 compatible (ZIP, PNG, Ethernet)
+- **CRC32C variant**: Castagnoli polynomial for improved performance
+- **Buffer support**: ArrayBuffer, DataView, Uint8Array
+- **Block processing**: Custom format for large files
+- **Zero dependencies**: Pure JavaScript implementation
+- **TypeScript ready**: Full JSDoc type annotations
+
+## Quick Start
+
+```javascript
+import { stringToCrc32 } from './stringCrc32.js';
+import { bufferToCrc32 } from './bufferCrc32.js';
+import { bufferToBlockCrc32 } from './blockCrc32.js';
+import { CRC32, CRC32C } from './crcTables.js';
+
+// String checksums (IEEE 802.3 standard)
+const crc = stringToCrc32('hello world');
+console.log(crc); // 222957957 (0xd4a1185)
+
+// Standard test vector verification
+console.log(stringToCrc32('123456789')); // 3421780262 (0xcbf43926)
+console.log(stringToCrc32('123456789', CRC32C)); // 3808858755 (0xe3069283)
+
+// Buffer checksums (standard)
+const buffer = new TextEncoder().encode('hello world');
+const bufferCrc = bufferToCrc32(buffer);
+console.log(bufferCrc); // 222957957 (same as string)
+
+// Large file processing (custom format)
+const result = bufferToBlockCrc32(buffer, 1024);
+console.log(result.checksumList); // [222957957]
+console.log(result.toBase58()); // Base58-encoded result
+```
+
+## Module Overview
+
+### `crcTables.js`
+Shared CRC table generation and constants.
+
+```javascript
+import { getCrcTable, CRC32, CRC32C } from './crcTables.js';
+
+const table = getCrcTable(CRC32); // Get lookup table
+```
+
+### `stringCrc32.js`
+String to CRC32 conversion.
+
+```javascript
+import { stringToCrc32, CRC32, CRC32C } from './stringCrc32.js';
+
+const crc = stringToCrc32('text', CRC32);  // Standard CRC32
+const crcC = stringToCrc32('text', CRC32C); // CRC32C variant
+```
+
+### `bufferCrc32.js`
+Standard buffer CRC32 - compatible with external tools.
+
+```javascript
+import { bufferToCrc32 } from './bufferCrc32.js';
+
+// Works with all buffer types
+const arrayBuffer = new ArrayBuffer(100);
+const uint8Array = new Uint8Array(100);
+const dataView = new DataView(arrayBuffer);
+
+const crc1 = bufferToCrc32(arrayBuffer);
+const crc2 = bufferToCrc32(uint8Array, 10, 50); // Offset & length
+const crc3 = bufferToCrc32(dataView);
+```
+
+### `blockCrc32.js`
+Custom block-based processing for large files.
+
+```javascript
+import { 
+  bufferToBlockCrc32, 
+  blockCrc32Iterator,
+  bufferChecksumEquals,
+  optimalBlockSize 
+} from './blockCrc32.js';
+
+// Process large buffer in blocks
+const result = bufferToBlockCrc32(largeBuffer);
+console.log(result.checksumList);  // Array of CRC32 values
+console.log(result.toBase58());    // Concatenated Base58 string
+
+// Stream processing
+for (const block of blockCrc32Iterator(buffer, 1024)) {
+  console.log(`Block at ${block.offset}: ${block.toBase58()}`);
+}
+
+// Verification
+const isValid = bufferChecksumEquals(buffer, expectedChecksum);
+```
+
+## CRC32 Variants
+
+### CRC32 (IEEE 802.3)
+- **Use case**: General purpose, file integrity
+- **Compatible with**: ZIP files, PNG images, Ethernet frames
+- **Polynomial**: `0xEDB88320` (reversed)
+- **Standard test**: `"123456789"` → `0xcbf43926` ✅
+
+### CRC32C (Castagnoli)
+- **Use case**: High-performance applications
+- **Compatible with**: iSCSI, SCTP, certain databases
+- **Polynomial**: `0x82f63b78` (reversed)
+- **Standard test**: `"123456789"` → `0xe3069283` ✅
+
+```javascript
+import { CRC32, CRC32C } from './crcTables.js';
+
+// All functions accept variant parameter
+stringToCrc32('data', CRC32);   // Default
+stringToCrc32('data', CRC32C);  // Castagnoli
+
+// Verify against standard test vectors
+console.assert(stringToCrc32('123456789', CRC32) === 0xcbf43926);
+console.assert(stringToCrc32('123456789', CRC32C) === 0xe3069283);
+```
+
+## Block Processing Details
+
+### Standard vs Block Format
+
+**Standard CRC32** (compatible):
+```
+Input:  [large file data]
+Output: 222957957 (single 32-bit value)
+```
+
+**Block CRC32** (proprietary):
+```
+Input:  [large file data split into blocks]
+Block 1: 222957957 → Base58 encoded
+Block 2: 891347246 → Base58 encoded
+Block 3: 234567890 → Base58 encoded
+Output:  [concatenated Base58 string]
+```
+
+### Block Size Selection
+
+```javascript
+// Automatic sizing
+const blockSize = optimalBlockSize(buffer);
+
+// Manual sizing
+const result = bufferToBlockCrc32(buffer, 65536); // 64KB blocks
+```
+
+**Size Guidelines:**
+- **Small files** (< 100KB): Single block
+- **Medium files** (100KB - 2MB): 100KB blocks
+- **Large files** (> 2MB): Adaptive sizing (max 20 blocks)
+
+### Use Cases
+
+**Standard CRC32:**
+- File integrity verification
+- Compatibility with external tools
+- Single checksum for entire data
+
+**Block CRC32:**
+- Large file streaming
+- Partial corruption detection
+- Progress tracking during transfer
+- Resume capability for interrupted uploads
+
+## Error Handling
+
+```javascript
+// Invalid CRC variant
+getCrcTable('invalid'); // throws "Invalid variant [invalid]"
+
+// Unsupported buffer type
+bufferToCrc32('string'); // throws "Unsupported buffer type"
+
+// All functions validate inputs and provide clear error messages
+```
+
+## Standards Compliance
+
+✅ **Verified Implementation**: Both CRC32 and CRC32C pass standard test vectors
+- CRC32 IEEE 802.3: `"123456789"` → `0xcbf43926`
+- CRC32C Castagnoli: `"123456789"` → `0xe3069283`
+
+✅ **Full Compatibility**: 
+- ZIP/PNG/Ethernet frames (CRC32)
+- iSCSI/SCTP protocols (CRC32C)
+
+## Performance Notes
+
+- **Table caching**: CRC tables generated once per variant
+- **Memory efficient**: Block processing doesn't load entire files
+- **Browser compatible**: Works in all modern browsers
+- **Standards compliant**: Verified against authoritative test vectors
+- **No dependencies**: Pure JavaScript implementation
+
+## Testing
+
+Run tests for all modules:
+
+```bash
+pnpm test:file src/lib/util/checksum/
+```
+
+Run specific test files:
+
+```bash
+pnpm test:file src/lib/util/checksum/stringCrc32.test.js
+pnpm test:file src/lib/util/checksum/bufferCrc32.test.js
+pnpm test:file src/lib/util/checksum/blockCrc32.test.js
+```
+
+## TypeScript Support
+
+All modules include comprehensive JSDoc type annotations:
+
+```javascript
+/**
+ * @param {string} str - String to calculate checksum for
+ * @param {import('./crcTables.js').CrcVariant} [variant=CRC32] - CRC variant
+ * @returns {number} Unsigned 32-bit CRC32 value
+ */
+```
+
+## Migration Guide
+
+### From Original Implementation
+
+**Old:**
+```javascript
+import { stringToCrc32 } from './crc32.js';
+```
+
+**New:**
+```javascript
+import { stringToCrc32 } from './stringCrc32.js';
+// Same API, no changes needed
+```
+
+### Adding Block Processing
+
+**Before:**
+```javascript
+// Single CRC32 for entire file
+const crc = bufferToCrc32(largeFile);
+```
+
+**After:**
+```javascript
+// Block-based processing
+const result = bufferToBlockCrc32(largeFile);
+const checksum = result.toBase58(); // Custom format
+```
+
+## License
+
+Part of HKdigital library core utilities.

package/dist/util/checksum/blockCrc32.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Calculate block-based CRC32 for buffer
+ *
+ * @param {ArrayBuffer|DataView|Uint8Array} buffer - Buffer to process
+ * @param {number} [blockSize] - Block size (auto-calculated if not provided)
+ * @param {import('./crcTables.js').CrcVariant} [variant=CRC32] - CRC variant
+ *
+ * @returns {object} Block checksum result
+ */
+export function bufferToBlockCrc32(buffer: ArrayBuffer | DataView | Uint8Array, blockSize?: number, variant?: import("./crcTables.js").CrcVariant): object;
+/**
+ * Iterate over buffer blocks and yield CRC32 for each
+ *
+ * @param {ArrayBuffer|DataView|Uint8Array} buffer - Buffer to process
+ * @param {number} [blockSize] - Block size
+ * @param {import('./crcTables.js').CrcVariant} [variant=CRC32] - CRC variant
+ *
+ * @yields {object} Block checksum with value and encoding methods
+ */
+export function blockCrc32Iterator(buffer: ArrayBuffer | DataView | Uint8Array, blockSize?: number, variant?: import("./crcTables.js").CrcVariant): Generator<{
+    value: number;
+    offset: number;
+    size: number;
+    toBase58: () => string;
+}, void, unknown>;
+/**
+ * Check if buffer checksum matches expected value
+ *
+ * @param {ArrayBuffer|DataView|Uint8Array} buffer - Buffer to verify
+ * @param {string} expectedChecksum - Expected Base58 checksum string
+ * @param {number} [blockSize] - Block size
+ * @param {import('./crcTables.js').CrcVariant} [variant=CRC32] - CRC variant
+ *
+ * @returns {boolean} True if checksums match
+ */
+export function bufferChecksumEquals(buffer: ArrayBuffer | DataView | Uint8Array, expectedChecksum: string, blockSize?: number, variant?: import("./crcTables.js").CrcVariant): boolean;
+/**
+ * Calculate optimal block size for buffer
+ *
+ * @param {ArrayBuffer|DataView|Uint8Array} buffer - Buffer to analyze
+ *
+ * @returns {number} Optimal block size
+ */
+export function optimalBlockSize(buffer: ArrayBuffer | DataView | Uint8Array): number;

package/dist/util/checksum/blockCrc32.js

@@ -0,0 +1,174 @@
+/**
+ * Custom block-based CRC32 calculation
+ *
+ * Splits large buffers into blocks and concatenates individual CRC32 values.
+ * Creates proprietary checksum format for efficient large file processing.
+ */
+
+import { base58fromNumber } from '../bases.js';
+
+import { bufferToCrc32 } from './bufferCrc32.js';
+import { CRC32 } from './crcTables.js';
+
+/* ---------------------------------------------------------------- Constants */
+
+/** @type {number} */
+const MIN_BUFFER_BLOCK_SIZE = 100000;
+
+/** @type {number} */
+const MAX_BUFFER_BLOCKS = 20;
+
+/** @type {number} */
+const OPTIMAL_BLOCK_SIZE_FACTOR = 0.95;
+
+/* ---------------------------------------------------------------- Functions */
+
+/**
+ * Calculate block-based CRC32 for buffer
+ *
+ * @param {ArrayBuffer|DataView|Uint8Array} buffer - Buffer to process
+ * @param {number} [blockSize] - Block size (auto-calculated if not provided)
+ * @param {import('./crcTables.js').CrcVariant} [variant=CRC32] - CRC variant
+ *
+ * @returns {object} Block checksum result
+ */
+export function bufferToBlockCrc32(buffer, blockSize, variant = CRC32) {
+  if (!blockSize) {
+    blockSize = optimalBlockSize(buffer);
+  }
+
+  /** @type {number[]} */
+  const checksumList = [];
+
+  for (const block of blockCrc32Iterator(buffer, blockSize, variant)) {
+    checksumList.push(block.value);
+  }
+
+  return {
+    checksumList,
+    blockSize,
+    toBase58: () => checksumsToBase58(checksumList)
+  };
+}
+
+/**
+ * Iterate over buffer blocks and yield CRC32 for each
+ *
+ * @param {ArrayBuffer|DataView|Uint8Array} buffer - Buffer to process
+ * @param {number} [blockSize] - Block size
+ * @param {import('./crcTables.js').CrcVariant} [variant=CRC32] - CRC variant
+ *
+ * @yields {object} Block checksum with value and encoding methods
+ */
+export function* blockCrc32Iterator(buffer, blockSize, variant = CRC32) {
+  if (!blockSize) {
+    blockSize = optimalBlockSize(buffer);
+  }
+
+  const bufferLength = getBufferLength(buffer);
+
+  for (let offset = 0; offset < bufferLength; offset += blockSize) {
+    const currentBlockSize = Math.min(blockSize, bufferLength - offset);
+    
+    /** @type {number} */
+    const value = bufferToCrc32(buffer, offset, currentBlockSize, variant);
+
+    yield {
+      value,
+      offset,
+      size: currentBlockSize,
+      toBase58: () => base58fromNumber(value)
+    };
+  }
+}
+
+/**
+ * Check if buffer checksum matches expected value
+ *
+ * @param {ArrayBuffer|DataView|Uint8Array} buffer - Buffer to verify
+ * @param {string} expectedChecksum - Expected Base58 checksum string
+ * @param {number} [blockSize] - Block size
+ * @param {import('./crcTables.js').CrcVariant} [variant=CRC32] - CRC variant
+ *
+ * @returns {boolean} True if checksums match
+ */
+export function bufferChecksumEquals(
+  buffer, 
+  expectedChecksum, 
+  blockSize, 
+  variant = CRC32
+) {
+  if (!blockSize) {
+    blockSize = optimalBlockSize(buffer);
+  }
+
+  /** @type {string} */
+  let remaining = expectedChecksum;
+
+  for (const block of blockCrc32Iterator(buffer, blockSize, variant)) {
+    const blockChecksum = block.toBase58();
+
+    if (!remaining.startsWith(blockChecksum)) {
+      return false;
+    }
+
+    remaining = remaining.slice(blockChecksum.length);
+  }
+
+  return remaining.length === 0;
+}
+
+/**
+ * Calculate optimal block size for buffer
+ *
+ * @param {ArrayBuffer|DataView|Uint8Array} buffer - Buffer to analyze
+ *
+ * @returns {number} Optimal block size
+ */
+export function optimalBlockSize(buffer) {
+  /** @type {number} */
+  const bufferByteLength = getBufferLength(buffer);
+
+  if (bufferByteLength < MIN_BUFFER_BLOCK_SIZE) {
+    return bufferByteLength;
+  }
+
+  /** @type {number} */
+  let blockSize = bufferByteLength / MAX_BUFFER_BLOCKS;
+
+  if (blockSize < MIN_BUFFER_BLOCK_SIZE) {
+    return MIN_BUFFER_BLOCK_SIZE;
+  }
+
+  return Math.ceil(
+    blockSize * OPTIMAL_BLOCK_SIZE_FACTOR + 
+    MIN_BUFFER_BLOCK_SIZE * (1 - OPTIMAL_BLOCK_SIZE_FACTOR)
+  );
+}
+
+/* ------------------------------------------------------- Internal functions */
+
+/**
+ * Get buffer length safely for different buffer types
+ *
+ * @param {ArrayBuffer|DataView|Uint8Array} buffer - Buffer to measure
+ *
+ * @returns {number} Buffer length in bytes
+ */
+function getBufferLength(buffer) {
+  if (buffer instanceof ArrayBuffer || buffer instanceof DataView) {
+    return buffer.byteLength;
+  }
+  return buffer.length;
+}
+
+/**
+ * Convert checksum array to concatenated Base58 string
+ *
+ * @param {number[]} checksumList - Array of CRC32 values
+ *
+ * @returns {string} Concatenated Base58 string
+ */
+function checksumsToBase58(checksumList) {
+  return checksumList.map(crc => base58fromNumber(crc)).join('');
+}

package/dist/util/checksum/bufferCrc32.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Calculate standard CRC32 for buffer
+ *
+ * @param {ArrayBuffer|DataView|Uint8Array} buffer - Buffer to checksum
+ * @param {number} [byteOffset=0] - Start offset in buffer
+ * @param {number} [byteLength] - Number of bytes to process
+ * @param {import('./crcTables.js').CrcVariant} [variant=CRC32] - CRC variant
+ *
+ * @returns {number} Unsigned 32-bit CRC32 value
+ */
+export function bufferToCrc32(buffer: ArrayBuffer | DataView | Uint8Array, byteOffset?: number, byteLength?: number, variant?: import("./crcTables.js").CrcVariant): number;

package/dist/util/checksum/bufferCrc32.js

@@ -0,0 +1,69 @@
+/**
+ * Standard buffer CRC32 calculation
+ *
+ * Implements IEEE 802.3 CRC32 over entire buffer.
+ * Compatible with ZIP, PNG, and other standard formats.
+ */
+
+import { getCrcTable, CRC32 } from './crcTables.js';
+
+/**
+ * Calculate standard CRC32 for buffer
+ *
+ * @param {ArrayBuffer|DataView|Uint8Array} buffer - Buffer to checksum
+ * @param {number} [byteOffset=0] - Start offset in buffer
+ * @param {number} [byteLength] - Number of bytes to process
+ * @param {import('./crcTables.js').CrcVariant} [variant=CRC32] - CRC variant
+ *
+ * @returns {number} Unsigned 32-bit CRC32 value
+ */
+export function bufferToCrc32(buffer, byteOffset = 0, byteLength, variant = CRC32) {
+  const table = getCrcTable(variant);
+  
+  /** @type {DataView} */
+  const dataView = createDataView(buffer, byteOffset, byteLength);
+
+  /** @type {number} */
+  let crc = 0 ^ (-1);
+
+  for (let j = 0; j < dataView.byteLength; j = j + 1) {
+    crc = (crc >>> 8) ^ table[(crc ^ dataView.getUint8(j)) & 0xFF];
+  }
+
+  return (crc ^ (-1)) >>> 0;
+}
+
+/* ------------------------------------------------------- Internal functions */
+
+/**
+ * Create DataView from various buffer types
+ *
+ * @param {ArrayBuffer|DataView|Uint8Array} buffer - Input buffer
+ * @param {number} [byteOffset=0] - Start offset
+ * @param {number} [byteLength] - Length to use
+ *
+ * @returns {DataView} DataView for the buffer
+ */
+function createDataView(buffer, byteOffset = 0, byteLength) {
+  if (buffer instanceof DataView) {
+    return new DataView(
+      buffer.buffer, 
+      buffer.byteOffset + byteOffset,
+      byteLength ?? (buffer.byteLength - byteOffset)
+    );
+  }
+
+  if (buffer instanceof ArrayBuffer) {
+    return new DataView(buffer, byteOffset, byteLength);
+  }
+
+  if (buffer instanceof Uint8Array) {
+    return new DataView(
+      buffer.buffer,
+      buffer.byteOffset + byteOffset,
+      byteLength ?? (buffer.byteLength - byteOffset)
+    );
+  }
+
+  throw new Error('Unsupported buffer type');
+}

package/dist/util/checksum/crcTables.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Get CRC lookup table for specified variant
+ *
+ * @param {CrcVariant} [variant=CRC32] - CRC variant
+ *
+ * @returns {CrcTable} The CRC lookup table
+ */
+export function getCrcTable(variant?: CrcVariant): CrcTable;
+/**
+ * Shared CRC table generation and constants
+ */
+/**
+ * @typedef {import('./typedef').CrcVariant} CrcVariant
+ * Valid CRC32 variant types
+ */
+/**
+ * @typedef {import('./typedef').CrcTable} CrcTable
+ * Lookup table for CRC calculations - array of 256 numbers
+ */
+/** @type {CrcVariant} */
+export const CRC32: CrcVariant;
+/** @type {CrcVariant} */
+export const CRC32C: CrcVariant;
+/**
+ * Valid CRC32 variant types
+ */
+export type CrcVariant = import("./typedef").CrcVariant;
+/**
+ * Lookup table for CRC calculations - array of 256 numbers
+ */
+export type CrcTable = import("./typedef").CrcTable;

package/dist/util/checksum/crcTables.js

@@ -0,0 +1,79 @@
+/**
+ * Shared CRC table generation and constants
+ */
+
+/**
+ * @typedef {import('./typedef').CrcVariant} CrcVariant
+ * Valid CRC32 variant types
+ */
+
+/**
+ * @typedef {import('./typedef').CrcTable} CrcTable
+ * Lookup table for CRC calculations - array of 256 numbers
+ */
+
+/* ---------------------------------------------------------------- Constants */
+
+/** @type {CrcVariant} */
+export const CRC32 = 'crc32';
+
+/** @type {CrcVariant} */
+export const CRC32C = 'crc32c';
+
+/** @type {Record<CrcVariant, number>} */
+const START_POLYNOMIALS = {
+  [CRC32]: 0xEDB88320,
+  [CRC32C]: 0x82f63b78
+};
+
+/** @type {Record<CrcVariant, CrcTable>} */
+// @ts-ignore
+const crcTables = {};
+
+/* ---------------------------------------------------------------- Functions */
+
+/**
+ * Get CRC lookup table for specified variant
+ *
+ * @param {CrcVariant} [variant=CRC32] - CRC variant
+ *
+ * @returns {CrcTable} The CRC lookup table
+ */
+export function getCrcTable(variant = CRC32) {
+  return crcTables[variant] || (crcTables[variant] = makeCRCTable(variant));
+}
+
+/* ---------------------------------------------------------------- Internals */
+
+/**
+ * Create CRC lookup table for specified variant
+ *
+ * @param {CrcVariant} variant - CRC variant to create table for
+ *
+ * @returns {CrcTable} The generated CRC lookup table
+ */
+function makeCRCTable(variant) {
+  /** @type {number} */
+  let c;
+  
+  /** @type {CrcTable} */
+  const crcTable = [];
+
+  /** @type {number} */
+  const startPolynomial = START_POLYNOMIALS[variant];
+
+  if (!startPolynomial) {
+    throw new Error(`Invalid variant [${variant}]`);
+  }
+
+  for (let n = 0; n < 256; n = n + 1) {
+    c = n;
+
+    for (let k = 0; k < 8; k = k + 1) {
+      c = ((c & 1) ? (startPolynomial ^ (c >>> 1)) : (c >>> 1));
+    }
+    crcTable[n] = c;
+  }
+
+  return crcTable;
+}

package/dist/util/checksum/stringCrc32.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Calculate CRC32 hash for string input
+ *
+ * @param {string} str - String to calculate checksum for
+ * @param {import('./crcTables.js').CrcVariant} [variant=CRC32] - CRC variant
+ *
+ * @returns {number} Unsigned 32-bit CRC32 value
+ */
+export function stringToCrc32(str: string, variant?: import("./crcTables.js").CrcVariant): number;
+import { CRC32 } from './crcTables.js';
+import { CRC32C } from './crcTables.js';
+export { CRC32, CRC32C };

package/dist/util/checksum/stringCrc32.js

@@ -0,0 +1,33 @@
+/**
+ * String CRC32 calculation utility
+ *
+ * Calculates CRC32 checksums for strings using standard IEEE 802.3 algorithm.
+ * CRC32 is fast but not cryptographically secure.
+ */
+
+import { getCrcTable, CRC32, CRC32C } from './crcTables.js';
+
+/* ------------------------------------------------------------------ Exports */
+
+export { CRC32, CRC32C };
+
+/**
+ * Calculate CRC32 hash for string input
+ *
+ * @param {string} str - String to calculate checksum for
+ * @param {import('./crcTables.js').CrcVariant} [variant=CRC32] - CRC variant
+ *
+ * @returns {number} Unsigned 32-bit CRC32 value
+ */
+export function stringToCrc32(str, variant = CRC32) {
+  const table = getCrcTable(variant);
+
+  /** @type {number} */
+  let crc = 0 ^ (-1);
+
+  for (let j = 0; j < str.length; j = j + 1) {
+    crc = (crc >>> 8) ^ table[(crc ^ str.charCodeAt(j)) & 0xFF];
+  }
+
+  return (crc ^ (-1)) >>> 0;
+}

package/dist/util/checksum/typedef.d.ts

@@ -0,0 +1,10 @@
+declare const _default: {};
+export default _default;
+/**
+ * Valid CRC32 variant types
+ */
+export type CrcVariant = "crc32" | "crc32c";
+/**
+ * Lookup table for CRC calculations - array of 256 numbers
+ */
+export type CrcTable = number[];

package/dist/util/checksum/typedef.js

@@ -0,0 +1,11 @@
+/**
+ * @typedef {'crc32'|'crc32c'} CrcVariant
+ * Valid CRC32 variant types
+ */
+
+/**
+ * @typedef {number[]} CrcTable
+ * Lookup table for CRC calculations - array of 256 numbers
+ */
+
+export default {};

package/dist/util/checksum.d.ts

@@ -0,0 +1,4 @@
+export { bufferToCrc32 } from "./checksum/bufferCrc32.js";
+export { getCrcTable } from "./checksum/crcTables.js";
+export { stringToCrc32, CRC32, CRC32C } from "./checksum/stringCrc32.js";
+export { bufferToBlockCrc32, blockCrc32Iterator, bufferChecksumEquals, optimalBlockSize } from "./checksum/blockCrc32.js";

package/dist/util/checksum.js

@@ -0,0 +1,23 @@
+/**
+ * Checksum utilities - CRC32 calculations
+ *
+ * Exports the main public-facing functions from the checksum module.
+ * Provides both standard IEEE 802.3 CRC32 and custom block-based processing.
+ */
+
+// String CRC32 calculations
+export { stringToCrc32, CRC32, CRC32C } from './checksum/stringCrc32.js';
+
+// Standard buffer CRC32 (IEEE 802.3 compatible)
+export { bufferToCrc32 } from './checksum/bufferCrc32.js';
+
+// Custom block-based CRC32 for large files
+export {
+  bufferToBlockCrc32,
+  blockCrc32Iterator,
+  bufferChecksumEquals,
+  optimalBlockSize
+} from './checksum/blockCrc32.js';
+
+// CRC table utilities (for advanced use)
+export { getCrcTable } from './checksum/crcTables.js';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@hkdigital/lib-core",
-	"version": "0.4.56",
+	"version": "0.4.57",
 	"author": {
 		"name": "HKdigital",
 		"url": "https://hkdigital.nl"