@cj-tech-master/excelts 3.0.1-canary.20251230173853.c3c79fa → 3.1.0-canary.20260102041828.82ed571

package/dist/cjs/index.js

@@ -17,53 +17,51 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CsvFormatterStream = exports.CsvParserStream = exports.ModelContainer = exports.WorksheetReader = exports.WorksheetWriter = exports.WorkbookReader = exports.WorkbookWriter = exports.DataValidations = exports.Table = exports.Image = exports.Range = exports.Cell = exports.Column = exports.Row = exports.Worksheet = exports.Workbook = void 0;
-var workbook_1 = require("./doc/workbook");
+exports.CsvFormatterStream = exports.CsvParserStream = exports.WorksheetReader = exports.WorksheetWriter = exports.WorkbookReader = exports.WorkbookWriter = exports.DataValidations = exports.Table = exports.Image = exports.Range = exports.Cell = exports.Column = exports.Row = exports.Worksheet = exports.Workbook = void 0;
+var workbook_1 = require("@excel/workbook");
 Object.defineProperty(exports, "Workbook", { enumerable: true, get: function () { return workbook_1.Workbook; } });
-var worksheet_1 = require("./doc/worksheet");
+var worksheet_1 = require("@excel/worksheet");
 Object.defineProperty(exports, "Worksheet", { enumerable: true, get: function () { return worksheet_1.Worksheet; } });
-var row_1 = require("./doc/row");
+var row_1 = require("@excel/row");
 Object.defineProperty(exports, "Row", { enumerable: true, get: function () { return row_1.Row; } });
-var column_1 = require("./doc/column");
+var column_1 = require("@excel/column");
 Object.defineProperty(exports, "Column", { enumerable: true, get: function () { return column_1.Column; } });
-var cell_1 = require("./doc/cell");
+var cell_1 = require("@excel/cell");
 Object.defineProperty(exports, "Cell", { enumerable: true, get: function () { return cell_1.Cell; } });
-var range_1 = require("./doc/range");
+var range_1 = require("@excel/range");
 Object.defineProperty(exports, "Range", { enumerable: true, get: function () { return range_1.Range; } });
-var image_1 = require("./doc/image");
+var image_1 = require("@excel/image");
 Object.defineProperty(exports, "Image", { enumerable: true, get: function () { return image_1.Image; } });
-__exportStar(require("./doc/anchor"), exports);
-var table_1 = require("./doc/table");
+__exportStar(require("@excel/anchor"), exports);
+var table_1 = require("@excel/table");
 Object.defineProperty(exports, "Table", { enumerable: true, get: function () { return table_1.Table; } });
-var data_validations_1 = require("./doc/data-validations");
+var data_validations_1 = require("@excel/data-validations");
 Object.defineProperty(exports, "DataValidations", { enumerable: true, get: function () { return data_validations_1.DataValidations; } });
 // =============================================================================
 // Node.js Only: Streaming Classes
 // These can also be accessed via Workbook.createStreamWriter/createStreamReader
 // =============================================================================
-var workbook_writer_1 = require("./stream/xlsx/workbook-writer");
+var workbook_writer_1 = require("@excel/stream/workbook-writer");
 Object.defineProperty(exports, "WorkbookWriter", { enumerable: true, get: function () { return workbook_writer_1.WorkbookWriter; } });
-var workbook_reader_1 = require("./stream/xlsx/workbook-reader");
+var workbook_reader_1 = require("@excel/stream/workbook-reader");
 Object.defineProperty(exports, "WorkbookReader", { enumerable: true, get: function () { return workbook_reader_1.WorkbookReader; } });
-var worksheet_writer_1 = require("./stream/xlsx/worksheet-writer");
+var worksheet_writer_1 = require("@excel/stream/worksheet-writer");
 Object.defineProperty(exports, "WorksheetWriter", { enumerable: true, get: function () { return worksheet_writer_1.WorksheetWriter; } });
-var worksheet_reader_1 = require("./stream/xlsx/worksheet-reader");
+var worksheet_reader_1 = require("@excel/stream/worksheet-reader");
 Object.defineProperty(exports, "WorksheetReader", { enumerable: true, get: function () { return worksheet_reader_1.WorksheetReader; } });
-var modelcontainer_1 = require("./doc/modelcontainer");
-Object.defineProperty(exports, "ModelContainer", { enumerable: true, get: function () { return modelcontainer_1.ModelContainer; } });
 // =============================================================================
 // Enums
 // =============================================================================
-__exportStar(require("./doc/enums"), exports);
+__exportStar(require("@excel/enums"), exports);
 // =============================================================================
 // Types
 // =============================================================================
 // Export all type definitions from types.ts
-__exportStar(require("./types"), exports);
-var csv_1 = require("./csv/csv");
+__exportStar(require("@excel/types"), exports);
+var csv_1 = require("@csv/csv");
 Object.defineProperty(exports, "CsvParserStream", { enumerable: true, get: function () { return csv_1.CsvParserStream; } });
 Object.defineProperty(exports, "CsvFormatterStream", { enumerable: true, get: function () { return csv_1.CsvFormatterStream; } });
 // =============================================================================
 // Utilities
 // =============================================================================
-__exportStar(require("./utils/sheet-utils"), exports);
+__exportStar(require("@excel/utils/sheet-utils"), exports);

package/dist/cjs/modules/archive/byte-queue.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ByteQueue = void 0;
+class ByteQueue {
+    constructor(initial) {
+        this._start = 0;
+        this._end = 0;
+        this._cachedView = null;
+        this._cachedBuf = null;
+        this._cachedStart = 0;
+        this._cachedEnd = 0;
+        this._buf = new Uint8Array(0);
+        if (initial && initial.length > 0) {
+            this.reset(initial);
+        }
+    }
+    get length() {
+        return this._end - this._start;
+    }
+    isEmpty() {
+        return this.length === 0;
+    }
+    view() {
+        if (this._start === this._end) {
+            return ByteQueue.EMPTY;
+        }
+        if (this._cachedView &&
+            this._cachedBuf === this._buf &&
+            this._cachedStart === this._start &&
+            this._cachedEnd === this._end) {
+            return this._cachedView;
+        }
+        const view = this._buf.subarray(this._start, this._end);
+        this._cachedView = view;
+        this._cachedBuf = this._buf;
+        this._cachedStart = this._start;
+        this._cachedEnd = this._end;
+        return view;
+    }
+    reset(data) {
+        this._cachedView = null;
+        this._cachedBuf = null;
+        if (!data || data.length === 0) {
+            this._buf = ByteQueue.EMPTY;
+            this._start = 0;
+            this._end = 0;
+            return;
+        }
+        // Keep a private copy to ensure future writes cannot mutate the source.
+        const copy = new Uint8Array(data.length);
+        copy.set(data);
+        this._buf = copy;
+        this._start = 0;
+        this._end = copy.length;
+    }
+    append(chunk) {
+        if (chunk.length === 0) {
+            return;
+        }
+        this._cachedView = null;
+        this._cachedBuf = null;
+        const unread = this.length;
+        // Fast path: enough tail room.
+        if (this._end + chunk.length <= this._buf.length) {
+            this._buf.set(chunk, this._end);
+            this._end += chunk.length;
+            return;
+        }
+        // Allocate a new buffer and copy unread bytes (never compacts in-place).
+        const required = unread + chunk.length;
+        const nextSize = this._buf.length === 0 ? required : Math.max(this._buf.length * 2, required);
+        const next = new Uint8Array(nextSize);
+        if (unread > 0) {
+            next.set(this._buf.subarray(this._start, this._end), 0);
+        }
+        next.set(chunk, unread);
+        this._buf = next;
+        this._start = 0;
+        this._end = required;
+    }
+    read(length) {
+        if (length <= 0) {
+            return new Uint8Array(0);
+        }
+        if (length > this.length) {
+            throw new RangeError("ByteQueue: read beyond available data");
+        }
+        // Return a view for performance.
+        // To keep this safe for async consumers, we must ensure we never write into
+        // the same backing buffer again after it becomes fully consumed.
+        const out = this._buf.subarray(this._start, this._start + length);
+        this._start += length;
+        this._cachedView = null;
+        this._cachedBuf = null;
+        if (this._start === this._end) {
+            // Release backing storage to avoid reusing memory that might still be
+            // referenced by previously returned views.
+            this._buf = ByteQueue.EMPTY;
+            this._start = 0;
+            this._end = 0;
+        }
+        return out;
+    }
+    discard(length) {
+        if (length <= 0) {
+            return;
+        }
+        if (length >= this.length) {
+            // Release backing storage for the same reason as read(): previously
+            // returned views may still be referenced by consumers.
+            this._buf = ByteQueue.EMPTY;
+            this._start = 0;
+            this._end = 0;
+            this._cachedView = null;
+            this._cachedBuf = null;
+            return;
+        }
+        this._start += length;
+        this._cachedView = null;
+        this._cachedBuf = null;
+        if (this._start === this._end) {
+            this._buf = ByteQueue.EMPTY;
+            this._start = 0;
+            this._end = 0;
+        }
+    }
+}
+exports.ByteQueue = ByteQueue;
+ByteQueue.EMPTY = new Uint8Array(0);

package/dist/cjs/modules/archive/compress.base.js

@@ -0,0 +1,186 @@
+"use strict";
+/**
+ * Base compression utilities using Web Streams API
+ * Shared between Node.js and Browser implementations
+ *
+ * Uses CompressionStream/DecompressionStream API with "deflate-raw" format
+ * (raw DEFLATE without zlib header/trailer, required for ZIP files)
+ *
+ * Browser fallback: For browsers without deflate-raw support (Firefox < 113, Safari < 16.4),
+ * see deflate-fallback.ts for pure JS implementation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_COMPRESS_THRESHOLD_BYTES = void 0;
+exports.resolveCompressThresholdBytes = resolveCompressThresholdBytes;
+exports.hasCompressionStream = hasCompressionStream;
+exports.probeDeflateRawCompressionStream = probeDeflateRawCompressionStream;
+exports.probeDeflateRawDecompressionStream = probeDeflateRawDecompressionStream;
+exports.probeDeflateRawWebStreams = probeDeflateRawWebStreams;
+exports.hasDeflateRawCompressionStream = hasDeflateRawCompressionStream;
+exports.hasDeflateRawDecompressionStream = hasDeflateRawDecompressionStream;
+exports.hasDeflateRawWebStreams = hasDeflateRawWebStreams;
+exports.compressWithStream = compressWithStream;
+exports.decompressWithStream = decompressWithStream;
+const byte_queue_1 = require("@archive/byte-queue");
+/**
+ * Default threshold (in bytes) to choose the lower-overhead path.
+ *
+ * This is a performance knob, not a correctness requirement.
+ */
+exports.DEFAULT_COMPRESS_THRESHOLD_BYTES = 8 * 1024 * 1024;
+/**
+ * Resolve the effective threshold bytes.
+ */
+function resolveCompressThresholdBytes(options) {
+    const value = options.thresholdBytes;
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+        return exports.DEFAULT_COMPRESS_THRESHOLD_BYTES;
+    }
+    return value;
+}
+/**
+ * Check if CompressionStream is available
+ */
+function hasCompressionStream() {
+    return typeof CompressionStream !== "undefined";
+}
+/**
+ * Non-cached probe for CompressionStream("deflate-raw") support.
+ *
+ * Prefer this in code paths that want up-to-date environment checks
+ * (e.g. tests that stub globals).
+ */
+function probeDeflateRawCompressionStream() {
+    try {
+        if (typeof CompressionStream === "undefined") {
+            return false;
+        }
+        new CompressionStream("deflate-raw");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Non-cached probe for DecompressionStream("deflate-raw") support.
+ */
+function probeDeflateRawDecompressionStream() {
+    try {
+        if (typeof DecompressionStream === "undefined") {
+            return false;
+        }
+        new DecompressionStream("deflate-raw");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Non-cached probe for full deflate-raw Web Streams support.
+ *
+ * Returns true only if BOTH CompressionStream("deflate-raw") and
+ * DecompressionStream("deflate-raw") are supported.
+ */
+function probeDeflateRawWebStreams() {
+    return probeDeflateRawCompressionStream() && probeDeflateRawDecompressionStream();
+}
+let _hasDeflateRawCompressionStream = null;
+let _hasDeflateRawDecompressionStream = null;
+/**
+ * Check if CompressionStream supports the "deflate-raw" format.
+ *
+ * This is a stricter check than {@link hasCompressionStream} because some
+ * environments expose CompressionStream but do not support "deflate-raw".
+ */
+function hasDeflateRawCompressionStream() {
+    if (typeof CompressionStream === "undefined") {
+        return false;
+    }
+    if (_hasDeflateRawCompressionStream !== null) {
+        return _hasDeflateRawCompressionStream;
+    }
+    _hasDeflateRawCompressionStream = probeDeflateRawCompressionStream();
+    return _hasDeflateRawCompressionStream;
+}
+/**
+ * Check if DecompressionStream supports the "deflate-raw" format.
+ */
+function hasDeflateRawDecompressionStream() {
+    if (typeof DecompressionStream === "undefined") {
+        return false;
+    }
+    if (_hasDeflateRawDecompressionStream !== null) {
+        return _hasDeflateRawDecompressionStream;
+    }
+    _hasDeflateRawDecompressionStream = probeDeflateRawDecompressionStream();
+    return _hasDeflateRawDecompressionStream;
+}
+/**
+ * Cached check for full deflate-raw Web Streams support.
+ *
+ * Returns true only if BOTH CompressionStream("deflate-raw") and
+ * DecompressionStream("deflate-raw") are supported.
+ */
+function hasDeflateRawWebStreams() {
+    return hasDeflateRawCompressionStream() && hasDeflateRawDecompressionStream();
+}
+async function streamToUint8Array(reader) {
+    const out = new byte_queue_1.ByteQueue();
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+            break;
+        }
+        out.append(value);
+    }
+    return out.read(out.length);
+}
+async function transformWithStream(data, stream) {
+    const writer = stream.writable.getWriter();
+    const reader = stream.readable.getReader();
+    try {
+        // Start reading immediately to avoid potential backpressure deadlocks
+        // (writer.write/close may wait for the readable side to be consumed).
+        const readPromise = streamToUint8Array(reader);
+        await writer.write(data);
+        await writer.close();
+        return await readPromise;
+    }
+    finally {
+        try {
+            writer.releaseLock();
+        }
+        catch {
+            // ignore
+        }
+        try {
+            reader.releaseLock();
+        }
+        catch {
+            // ignore
+        }
+    }
+}
+/**
+ * Compress using CompressionStream API
+ * Uses "deflate-raw" format (required for ZIP files)
+ *
+ * @param data - Data to compress
+ * @returns Compressed data
+ */
+async function compressWithStream(data) {
+    const cs = new CompressionStream("deflate-raw");
+    return transformWithStream(data, cs);
+}
+/**
+ * Decompress using DecompressionStream API
+ *
+ * @param data - Compressed data (deflate-raw format)
+ * @returns Decompressed data
+ */
+async function decompressWithStream(data) {
+    const ds = new DecompressionStream("deflate-raw");
+    return transformWithStream(data, ds);
+}

package/dist/cjs/modules/archive/compress.browser.js

@@ -0,0 +1,98 @@
+"use strict";
+/**
+ * Browser compression utilities
+ *
+ * Primary: CompressionStream API (Chrome 103+, Firefox 113+, Safari 16.4+)
+ * Fallback: Pure JS DEFLATE implementation for older browsers
+ *
+ * Supported browsers with fallback:
+ * - Chrome >= 89
+ * - Firefox >= 102
+ * - Safari >= 14.1
+ * - Edge >= 89
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasCompressionStream = hasCompressionStream;
+exports.compress = compress;
+exports.compressSync = compressSync;
+exports.decompress = decompress;
+exports.decompressSync = decompressSync;
+const compress_base_1 = require("@archive/compress.base");
+const deflate_fallback_1 = require("@archive/deflate-fallback");
+const defaults_1 = require("@archive/defaults");
+/**
+ * Check if CompressionStream is available in this environment.
+ *
+ * Note: Some environments may expose CompressionStream but not support
+ * the "deflate-raw" format that ZIP requires.
+ */
+function hasCompressionStream() {
+    return typeof CompressionStream !== "undefined";
+}
+/**
+ * Compress data using browser's native CompressionStream or JS fallback
+ *
+ * @param data - Data to compress
+ * @param options - Compression options
+ * @returns Compressed data
+ *
+ * @example
+ * ```ts
+ * const data = new TextEncoder().encode("Hello, World!");
+ * const compressed = await compress(data, { level: 6 });
+ * ```
+ */
+async function compress(data, options = {}) {
+    const level = options.level ?? defaults_1.DEFAULT_COMPRESS_LEVEL;
+    const thresholdBytes = (0, compress_base_1.resolveCompressThresholdBytes)(options);
+    // Level 0 means no compression
+    if (level === 0) {
+        return data;
+    }
+    // Use native CompressionStream only for larger inputs.
+    if ((0, compress_base_1.hasDeflateRawCompressionStream)() && data.byteLength > thresholdBytes) {
+        return (0, compress_base_1.compressWithStream)(data);
+    }
+    // Fallback to pure JS implementation
+    return (0, deflate_fallback_1.deflateRawCompressed)(data);
+}
+/**
+ * Compress data synchronously using pure JS implementation
+ *
+ * @param data - Data to compress
+ * @param options - Compression options
+ * @returns Compressed data
+ */
+function compressSync(data, options = {}) {
+    const level = options.level ?? defaults_1.DEFAULT_COMPRESS_LEVEL;
+    // Level 0 means no compression
+    if (level === 0) {
+        return data;
+    }
+    // Pure JS implementation
+    return (0, deflate_fallback_1.deflateRawCompressed)(data);
+}
+/**
+ * Decompress data using browser's native DecompressionStream or JS fallback
+ *
+ * @param data - Compressed data (deflate-raw format)
+ * @returns Decompressed data
+ */
+async function decompress(data, options = {}) {
+    const thresholdBytes = (0, compress_base_1.resolveCompressThresholdBytes)(options);
+    // Use native DecompressionStream only for larger inputs.
+    if ((0, compress_base_1.hasDeflateRawDecompressionStream)() && data.byteLength > thresholdBytes) {
+        return (0, compress_base_1.decompressWithStream)(data);
+    }
+    // Fallback to pure JS implementation
+    return (0, deflate_fallback_1.inflateRaw)(data);
+}
+/**
+ * Decompress data synchronously using pure JS implementation
+ *
+ * @param data - Compressed data (deflate-raw format)
+ * @returns Decompressed data
+ */
+function decompressSync(data) {
+    return (0, deflate_fallback_1.inflateRaw)(data);
+}

package/dist/cjs/modules/archive/compress.js

@@ -0,0 +1,127 @@
+"use strict";
+/**
+ * Node.js compression utilities using native zlib
+ *
+ * Uses zlib module (C++ implementation, fastest) with "deflate-raw" format
+ * (raw DEFLATE without zlib header/trailer, required for ZIP files)
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasCompressionStream = void 0;
+exports.compress = compress;
+exports.compressSync = compressSync;
+exports.decompress = decompress;
+exports.decompressSync = decompressSync;
+const util_1 = require("util");
+const zlib = __importStar(require("zlib"));
+const defaults_1 = require("@archive/defaults");
+// Re-export shared types and utilities
+var compress_base_1 = require("@archive/compress.base");
+Object.defineProperty(exports, "hasCompressionStream", { enumerable: true, get: function () { return compress_base_1.hasCompressionStream; } });
+function uint8ArrayToBufferView(data) {
+    return Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+}
+const deflateRawAsync = (0, util_1.promisify)(zlib.deflateRaw);
+const inflateRawAsync = (0, util_1.promisify)(zlib.inflateRaw);
+const compress_base_2 = require("@archive/compress.base");
+/**
+ * Compress data using Node.js native zlib
+ *
+ * @param data - Data to compress
+ * @param options - Compression options
+ * @returns Compressed data
+ *
+ * @example
+ * ```ts
+ * const data = new TextEncoder().encode("Hello, World!");
+ * const compressed = await compress(data, { level: 6 });
+ * ```
+ */
+async function compress(data, options = {}) {
+    const level = options.level ?? defaults_1.DEFAULT_COMPRESS_LEVEL;
+    const thresholdBytes = (0, compress_base_2.resolveCompressThresholdBytes)(options);
+    // Level 0 means no compression
+    if (level === 0) {
+        return data;
+    }
+    // Small-input fast path: avoid threadpool overhead.
+    if (data.byteLength <= thresholdBytes) {
+        const result = zlib.deflateRawSync(uint8ArrayToBufferView(data), { level });
+        return new Uint8Array(result.buffer, result.byteOffset, result.byteLength);
+    }
+    const result = await deflateRawAsync(uint8ArrayToBufferView(data), { level });
+    return new Uint8Array(result.buffer, result.byteOffset, result.byteLength);
+}
+/**
+ * Compress data synchronously using Node.js zlib
+ *
+ * @param data - Data to compress
+ * @param options - Compression options
+ * @returns Compressed data
+ */
+function compressSync(data, options = {}) {
+    const level = options.level ?? defaults_1.DEFAULT_COMPRESS_LEVEL;
+    if (level === 0) {
+        return data;
+    }
+    const result = zlib.deflateRawSync(uint8ArrayToBufferView(data), { level });
+    return new Uint8Array(result.buffer, result.byteOffset, result.byteLength);
+}
+/**
+ * Decompress data using Node.js native zlib
+ *
+ * @param data - Compressed data (deflate-raw format)
+ * @returns Decompressed data
+ */
+async function decompress(data, options = {}) {
+    const thresholdBytes = (0, compress_base_2.resolveCompressThresholdBytes)(options);
+    // Small-input fast path: avoid threadpool overhead.
+    if (data.byteLength <= thresholdBytes) {
+        const result = zlib.inflateRawSync(uint8ArrayToBufferView(data));
+        return new Uint8Array(result.buffer, result.byteOffset, result.byteLength);
+    }
+    const result = await inflateRawAsync(uint8ArrayToBufferView(data));
+    return new Uint8Array(result.buffer, result.byteOffset, result.byteLength);
+}
+/**
+ * Decompress data synchronously using Node.js zlib
+ *
+ * @param data - Compressed data (deflate-raw format)
+ * @returns Decompressed data
+ */
+function decompressSync(data) {
+    const result = zlib.inflateRawSync(uint8ArrayToBufferView(data));
+    return new Uint8Array(result.buffer, result.byteOffset, result.byteLength);
+}

package/dist/cjs/modules/archive/crc32.base.js

@@ -0,0 +1,56 @@
+"use strict";
+/**
+ * CRC32 calculation core (shared between Node.js and browser).
+ *
+ * Implements CRC-32 IEEE 802.3 using the reversed polynomial 0xEDB88320.
+ *
+ * Notes:
+ * - Uses a lazily-initialized 256-entry lookup table.
+ * - Exposes an incremental update API for streaming use cases.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.crc32UpdateJS = crc32UpdateJS;
+exports.crc32Finalize = crc32Finalize;
+exports.crc32JS = crc32JS;
+let _crc32Table = null;
+function getCrc32Table() {
+    if (_crc32Table) {
+        return _crc32Table;
+    }
+    const table = new Uint32Array(256);
+    for (let i = 0; i < 256; i++) {
+        let crc = i;
+        for (let j = 0; j < 8; j++) {
+            crc = crc & 1 ? 0xedb88320 ^ (crc >>> 1) : crc >>> 1;
+        }
+        table[i] = crc;
+    }
+    _crc32Table = table;
+    return table;
+}
+/**
+ * Update a CRC32 value with a new data chunk.
+ *
+ * The CRC state here is the non-finalized (inverted) form:
+ * - initial state: 0xffffffff
+ * - finalize: xor with 0xffffffff
+ */
+function crc32UpdateJS(crc, data) {
+    const table = getCrc32Table();
+    for (let i = 0; i < data.length; i++) {
+        crc = table[(crc ^ data[i]) & 0xff] ^ (crc >>> 8);
+    }
+    return crc;
+}
+/**
+ * Finalize CRC32 calculation.
+ */
+function crc32Finalize(crc) {
+    return (crc ^ 0xffffffff) >>> 0;
+}
+/**
+ * Compute CRC32 for the full input using the JS table implementation.
+ */
+function crc32JS(data) {
+    return crc32Finalize(crc32UpdateJS(0xffffffff, data));
+}