@js-ak/excel-toolbox 1.2.7 → 1.3.1

package/build/cjs/lib/template/utils/index.js

@@ -0,0 +1,27 @@
+"use strict";
+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 __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 });
+__exportStar(require("./check-row.js"), exports);
+__exportStar(require("./check-rows.js"), exports);
+__exportStar(require("./check-start-row.js"), exports);
+__exportStar(require("./column-index-to-letter.js"), exports);
+__exportStar(require("./escape-xml.js"), exports);
+__exportStar(require("./get-max-row-number.js"), exports);
+__exportStar(require("./get-rows-above.js"), exports);
+__exportStar(require("./get-rows-below.js"), exports);
+__exportStar(require("./parse-rows.js"), exports);
+__exportStar(require("./to-excel-column-object.js"), exports);
+__exportStar(require("./write-rows-to-stream.js"), exports);

package/build/cjs/lib/template/utils/parse-rows.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRows = parseRows;
+function parseRows(innerRows) {
+    const rowsMap = new Map();
+    // Regex to match all <row> elements
+    // 1. `(<row[^>]+r="(\d+)"[^>]*\/>)` - for self-closing tags (<row ... />)
+    // 2. `|(<row[^>]+r="(\d+)"[^>]*>[\s\S]*?<\/row>)` — for self-closing tags (<row ... />)
+    const rowRegex = /(<row[^>]+r="(\d+)"[^>]*\/>)|(<row[^>]+r="(\d+)"[^>]*>[\s\S]*?<\/row>)/g;
+    let match;
+    while ((match = rowRegex.exec(innerRows)) !== null) {
+        // if this is a self-closing tag (<row ... />)
+        if (match[1]) {
+            const fullRow = match[1];
+            const rowNumber = match[2];
+            if (!rowNumber)
+                throw new Error("Row number not found");
+            rowsMap.set(Number(rowNumber), fullRow);
+        }
+        // if this is a regular tag (<row>...</row>)
+        else if (match[3]) {
+            const fullRow = match[3];
+            const rowNumber = match[4];
+            if (!rowNumber)
+                throw new Error("Row number not found");
+            rowsMap.set(Number(rowNumber), fullRow);
+        }
+    }
+    return rowsMap;
+}

package/build/cjs/lib/template/utils/to-excel-column-object.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toExcelColumnObject = toExcelColumnObject;
+/**
+ * Converts an array of values into a Record<string, string> with Excel column names as keys.
+ *
+ * The column names are generated in the standard Excel column naming convention (A, B, ..., Z, AA, AB, ...).
+ * The corresponding values are converted to strings using the String() function.
+ *
+ * @param values - The array of values to convert
+ * @returns The resulting Record<string, string>
+ */
+function toExcelColumnObject(values) {
+    const toExcelColumn = (index) => {
+        let column = "";
+        let i = index;
+        while (i >= 0) {
+            column = String.fromCharCode((i % 26) + 65) + column;
+            i = Math.floor(i / 26) - 1;
+        }
+        return column;
+    };
+    const result = {};
+    for (let i = 0; i < values.length; i++) {
+        const key = toExcelColumn(i);
+        result[key] = String(values[i]);
+    }
+    return result;
+}

package/build/cjs/lib/template/utils/write-rows-to-stream.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeRowsToStream = writeRowsToStream;
+const column_index_to_letter_js_1 = require("./column-index-to-letter.js");
+/**
+ * Writes an async iterable of rows to an Excel XML file.
+ *
+ * Each row is expected to be an array of values, where each value is
+ * converted to a string using the `String()` function. Empty values are
+ * replaced with an empty string.
+ *
+ * The `startRowNumber` parameter is used as the starting row number
+ * for the first row written to the file. Subsequent rows are written
+ * with incrementing row numbers.
+ *
+ * @param output - A file write stream to write the Excel XML to.
+ * @param rows - An async iterable of rows, where each row is an array
+ *               of values.
+ * @param startRowNumber - The starting row number to use for the first
+ *                         row written to the file.
+ *
+ * @returns An object with a single property `rowNumber`, which is the
+ *          last row number written to the file (i.e., the `startRowNumber`
+ *          plus the number of rows written).
+ */
+async function writeRowsToStream(output, rows, startRowNumber) {
+    let rowNumber = startRowNumber;
+    for await (const row of rows) {
+        // Transform the row into XML
+        const cells = row.map((value, colIndex) => {
+            const colLetter = (0, column_index_to_letter_js_1.columnIndexToLetter)(colIndex);
+            const cellRef = `${colLetter}${rowNumber}`;
+            const cellValue = String(value ?? "");
+            return `<c r="${cellRef}" t="inlineStr"><is><t>${cellValue}</t></is></c>`;
+        });
+        // Write the row to the file
+        output.write(`<row r="${rowNumber}">${cells.join("")}</row>`);
+        rowNumber++;
+    }
+    return { rowNumber };
+}

package/build/cjs/lib/xml/build-merged-sheet.js

@@ -25,7 +25,7 @@ function buildMergedSheet(originalXml, mergedRows, mergeCells = []) {
         // Construct a new <mergeCells> section with the provided merge references
         const mergeCellsXml = `<mergeCells count="${mergeCells.length}">${mergeCells.map(mc => `<mergeCell ref="${mc.ref}"/>`).join("")}</mergeCells>`;
         // Insert <mergeCells> after </sheetData> and before the next XML tag
-        xmlData = xmlData.replace(/(<\/sheetData>)(\s*<)/, `$1\n${mergeCellsXml}\n$2`);
+        xmlData = xmlData.replace(/(<\/sheetData>)(\s*<)/, `$1${mergeCellsXml}$2`);
     }
     return Buffer.from(xmlData);
 }

package/build/cjs/lib/zip/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LOCAL_FILE_HEADER_SIG = exports.END_OF_CENTRAL_DIR_SIG = exports.CENTRAL_DIR_HEADER_SIG = void 0;
+exports.LOCAL_FILE_HEADER_SIG = exports.END_OF_CENTRAL_DIR_SIG = exports.CRC32_TABLE = exports.CENTRAL_DIR_HEADER_SIG = void 0;
 const node_buffer_1 = require("node:buffer");
 /**
  * ZIP file signature constants in Buffer format.
@@ -15,6 +15,21 @@ const node_buffer_1 = require("node:buffer");
  * Found in the central directory that appears at the end of the ZIP file.
  */
 exports.CENTRAL_DIR_HEADER_SIG = node_buffer_1.Buffer.from("504b0102", "hex");
+/**
+ * Precomputed CRC-32 lookup table for optimized checksum calculation.
+ * The table is generated using the standard IEEE 802.3 (Ethernet) polynomial:
+ * 0xEDB88320 (reversed representation of 0x04C11DB7).
+ *
+ * The table is immediately invoked and cached as a constant for performance,
+ * following the common implementation pattern for CRC algorithms.
+ */
+exports.CRC32_TABLE = new Uint32Array(256).map((_, n) => {
+    let c = n;
+    for (let k = 0; k < 8; k++) {
+        c = c & 1 ? 0xEDB88320 ^ (c >>> 1) : c >>> 1;
+    }
+    return c >>> 0;
+});
 /**
  * End of Central Directory Record signature (0x504b0506).
  * Marks the end of the central directory and contains global information

package/build/cjs/lib/zip/create-with-stream.js

@@ -0,0 +1,214 @@
+"use strict";
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWithStream = createWithStream;
+const path = __importStar(require("node:path"));
+const node_stream_1 = require("node:stream");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:stream/promises");
+const node_zlib_1 = __importDefault(require("node:zlib"));
+const index_js_1 = require("./utils/index.js");
+const constants_js_1 = require("./constants.js");
+/**
+ * Creates a ZIP archive from a collection of files, streaming the output to a provided writable stream.
+ *
+ * @param fileKeys - An array of file paths (relative to the destination) that will be used to create a new workbook.
+ * @param destination - The path where the template files are located.
+ * @param output - A Writable stream that the ZIP archive will be written to.
+ *
+ * @throws {Error} - If a file does not exist in the destination.
+ * @throws {Error} - If a file is not readable.
+ * @throws {Error} - If the writable stream emits an error.
+ */
+async function createWithStream(fileKeys, destination, output) {
+    const centralDirectory = [];
+    let offset = 0;
+    for (const filename of fileKeys.sort((a, b) => a.localeCompare(b))) {
+        if (filename.includes("..")) {
+            throw new Error(`Invalid filename: ${filename}`);
+        }
+        const fullPath = path.join(destination, ...filename.split("/"));
+        const fileNameBuf = Buffer.from(filename, "utf8");
+        const modTime = (0, index_js_1.dosTime)(new Date());
+        const source = (0, node_fs_1.createReadStream)(fullPath);
+        const crc32 = (0, index_js_1.crc32Stream)();
+        const deflater = node_zlib_1.default.createDeflateRaw();
+        let uncompSize = 0;
+        let compSize = 0;
+        const compressedChunks = [];
+        const sizeCounter = new node_stream_1.Transform({
+            transform(chunk, _enc, cb) {
+                uncompSize += chunk.length;
+                cb(null, chunk);
+            },
+        });
+        const collectCompressed = new node_stream_1.Transform({
+            transform(chunk, _enc, cb) {
+                compressedChunks.push(chunk);
+                compSize += chunk.length;
+                cb(null, chunk);
+            },
+        });
+        // deflater.on("data", (chunk) => { console.log("deflater data path:", fullPath, "length:", chunk.length); });
+        // deflater.on("finish", () => { console.log("deflater finished path:", fullPath, "uncompSize:", uncompSize, "compSize:", compSize); });
+        // deflater.on("error", (err) => { console.log("deflater error path:", fullPath, "error:", err); });
+        // deflater.on("close", () => { console.log("deflater closed path:", fullPath); });
+        // deflater.on("pipe", (src) => { console.log("deflater pipe path:", fullPath); });
+        // deflater.on("unpipe", (src) => { console.log("deflater unpipe path:", fullPath); });
+        // deflater.on("drain", () => { console.log("deflater drain path:", fullPath); });
+        // deflater.on("pause", () => { console.log("deflater pause path:", fullPath); });
+        // deflater.on("resume", () => { console.log("deflater resume path:", fullPath); });
+        // deflater.on("end", () => console.log("deflater ended, path:", fullPath));
+        // source.on("data", (chunk) => { console.log("source data path:", fullPath, "length:", chunk.length); });
+        // source.on("finish", () => { console.log("source finished path:", fullPath, "uncompSize:", uncompSize, "compSize:", compSize); });
+        // source.on("error", (err) => { console.log("source error path:", fullPath, "error:", err); });
+        // source.on("close", () => { console.log("source closed path:", fullPath); });
+        // source.on("pipe", (src) => { console.log("source pipe path:", fullPath); });
+        // source.on("unpipe", (src) => { console.log("source unpipe path:", fullPath); });
+        // source.on("drain", () => { console.log("source drain path:", fullPath); });
+        // source.on("pause", () => { console.log("source pause path:", fullPath); });
+        // source.on("resume", () => { console.log("source resume path:", fullPath); });
+        // source.on("end", () => console.log("source ended, path:", fullPath));
+        // sizeCounter.on("data", (chunk) => { console.log("sizeCounter data path:", fullPath, "length:", chunk.length); });
+        // sizeCounter.on("finish", () => { console.log("sizeCounter finished path:", fullPath, "uncompSize:", uncompSize, "compSize:", compSize); });
+        // sizeCounter.on("error", (err) => { console.log("sizeCounter error path:", fullPath, "error:", err); });
+        // sizeCounter.on("close", () => { console.log("sizeCounter closed path:", fullPath); });
+        // sizeCounter.on("pipe", (src) => { console.log("sizeCounter pipe path:", fullPath); });
+        // sizeCounter.on("unpipe", (src) => { console.log("sizeCounter unpipe path:", fullPath); });
+        // sizeCounter.on("drain", () => { console.log("sizeCounter drain path:", fullPath); });
+        // sizeCounter.on("pause", () => { console.log("sizeCounter pause path:", fullPath); });
+        // sizeCounter.on("resume", () => { console.log("sizeCounter resume path:", fullPath); });
+        // sizeCounter.on("end", () => console.log("sizeCounter ended, path:", fullPath));
+        // crc32.on("data", (chunk) => { console.log("crc32 data path:", fullPath, "length:", chunk.length); });
+        // crc32.on("finish", () => { console.log("crc32 finished path:", fullPath, "uncompSize:", uncompSize, "compSize:", compSize); });
+        // crc32.on("error", (err) => { console.log("crc32 error path:", fullPath, "error:", err); });
+        // crc32.on("close", () => { console.log("crc32 closed path:", fullPath); });
+        // crc32.on("pipe", (src) => { console.log("crc32 pipe path:", fullPath); });
+        // crc32.on("unpipe", (src) => { console.log("crc32 unpipe path:", fullPath); });
+        // crc32.on("drain", () => { console.log("crc32 drain path:", fullPath); });
+        // crc32.on("pause", () => { console.log("crc32 pause path:", fullPath); });
+        // crc32.on("resume", () => { console.log("crc32 resume path:", fullPath); });
+        // crc32.on("end", () => console.log("crc32 ended, path:", fullPath));
+        collectCompressed.on("data", ( /* chunk */) => { });
+        // collectCompressed.on("finish", () => { console.log("collectCompressed finished path:", fullPath, "uncompSize:", uncompSize, "compSize:", compSize); });
+        // collectCompressed.on("error", (err) => { console.log("collectCompressed error path:", fullPath, "error:", err); });
+        // collectCompressed.on("close", () => { console.log("collectCompressed closed path:", fullPath); });
+        // collectCompressed.on("pipe", (src) => { console.log("collectCompressed pipe path:", fullPath); });
+        // collectCompressed.on("unpipe", (src) => { console.log("collectCompressed unpipe path:", fullPath); });
+        // collectCompressed.on("drain", () => { console.log("collectCompressed drain path:", fullPath); });
+        // collectCompressed.on("pause", () => { console.log("collectCompressed pause path:", fullPath); });
+        // collectCompressed.on("resume", () => { console.log("collectCompressed resume path:", fullPath); });
+        // collectCompressed.on("end", () => console.log("collectCompressed ended, path:", fullPath));
+        // deflater.on("readable", () => {
+        // 	console.log("deflater readable path:", fullPath);
+        // });
+        await (0, promises_1.pipeline)(source, sizeCounter, crc32, deflater, collectCompressed);
+        // await new Promise<void>((resolve, reject) => {
+        // 	source
+        // 		.pipe(sizeCounter)
+        // 		.pipe(crc32)
+        // 		.pipe(deflater)
+        // 		.pipe(collectCompressed)
+        // 		.on("finish", resolve)
+        // 		.on("error", reject);
+        // 	source.on("error", reject);
+        // 	deflater.on("error", reject);
+        // });
+        const crc = crc32.digest();
+        const compressed = Buffer.concat(compressedChunks);
+        const localHeader = Buffer.concat([
+            constants_js_1.LOCAL_FILE_HEADER_SIG,
+            (0, index_js_1.toBytes)(20, 2),
+            (0, index_js_1.toBytes)(0, 2),
+            (0, index_js_1.toBytes)(8, 2),
+            modTime,
+            (0, index_js_1.toBytes)(crc, 4),
+            (0, index_js_1.toBytes)(compSize, 4),
+            (0, index_js_1.toBytes)(uncompSize, 4),
+            (0, index_js_1.toBytes)(fileNameBuf.length, 2),
+            (0, index_js_1.toBytes)(0, 2),
+            fileNameBuf,
+            compressed,
+        ]);
+        await new Promise((resolve, reject) => {
+            output.write(localHeader, err => err ? reject(err) : resolve());
+        });
+        const centralEntry = Buffer.concat([
+            constants_js_1.CENTRAL_DIR_HEADER_SIG,
+            (0, index_js_1.toBytes)(20, 2),
+            (0, index_js_1.toBytes)(20, 2),
+            (0, index_js_1.toBytes)(0, 2),
+            (0, index_js_1.toBytes)(8, 2),
+            modTime,
+            (0, index_js_1.toBytes)(crc, 4),
+            (0, index_js_1.toBytes)(compSize, 4),
+            (0, index_js_1.toBytes)(uncompSize, 4),
+            (0, index_js_1.toBytes)(fileNameBuf.length, 2),
+            (0, index_js_1.toBytes)(0, 2),
+            (0, index_js_1.toBytes)(0, 2),
+            (0, index_js_1.toBytes)(0, 2),
+            (0, index_js_1.toBytes)(0, 2),
+            (0, index_js_1.toBytes)(0, 4),
+            (0, index_js_1.toBytes)(offset, 4),
+            fileNameBuf,
+        ]);
+        centralDirectory.push(centralEntry);
+        offset += localHeader.length;
+    }
+    const centralDirSize = centralDirectory.reduce((sum, entry) => sum + entry.length, 0);
+    const centralDirOffset = offset;
+    for (const entry of centralDirectory) {
+        await new Promise((resolve, reject) => {
+            output.write(entry, err => err ? reject(err) : resolve());
+        });
+    }
+    const endRecord = Buffer.concat([
+        constants_js_1.END_OF_CENTRAL_DIR_SIG,
+        (0, index_js_1.toBytes)(0, 2),
+        (0, index_js_1.toBytes)(0, 2),
+        (0, index_js_1.toBytes)(centralDirectory.length, 2),
+        (0, index_js_1.toBytes)(centralDirectory.length, 2),
+        (0, index_js_1.toBytes)(centralDirSize, 4),
+        (0, index_js_1.toBytes)(centralDirOffset, 4),
+        (0, index_js_1.toBytes)(0, 2),
+    ]);
+    await new Promise((resolve, reject) => {
+        output.write(endRecord, err => err ? reject(err) : resolve());
+    });
+    output.end();
+}

package/build/cjs/lib/zip/index.js

@@ -15,6 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./create-sync.js"), exports);
+__exportStar(require("./create-with-stream.js"), exports);
 __exportStar(require("./create.js"), exports);
 __exportStar(require("./read-sync.js"), exports);
 __exportStar(require("./read.js"), exports);

package/build/cjs/lib/zip/utils/crc-32-stream.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.crc32Stream = crc32Stream;
+const node_stream_1 = require("node:stream");
+const constants_js_1 = require("../constants.js");
+/**
+ * Computes the CRC-32 checksum for the given byte, using the standard IEEE 802.3 polynomial.
+ * This is a low-level function that is used by the crc32Stream() function.
+ *
+ * @param {number} byte - The byte (0-255) to add to the checksum.
+ * @param {number} crc - The current checksum value to update.
+ * @returns {number} - The new checksum value.
+ */
+function crc32(byte, crc = 0xffffffff) {
+    return constants_js_1.CRC32_TABLE[(crc ^ byte) & 0xff] ^ (crc >>> 8);
+}
+/**
+ * Creates a Transform stream that computes the CRC-32 checksum of the input data.
+ *
+ * The `digest()` method can be called on the returned stream to get the final checksum value.
+ *
+ * @returns {Transform & { digest: () => number }} - The Transform stream.
+ */
+function crc32Stream() {
+    let crc = 0xffffffff;
+    const transform = new node_stream_1.Transform({
+        final(callback) {
+            callback();
+        },
+        flush(callback) {
+            callback();
+        },
+        transform(chunk, _encoding, callback) {
+            for (let i = 0; i < chunk.length; i++) {
+                crc = crc32(chunk[i], crc);
+            }
+            callback(null, chunk);
+        },
+    });
+    transform.digest = () => (crc ^ 0xffffffff) >>> 0;
+    return transform;
+}

package/build/cjs/lib/zip/utils/crc-32.js

@@ -1,40 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.crc32 = crc32;
-/**
- * Precomputed CRC-32 lookup table for optimized checksum calculation.
- * The table is generated using the standard IEEE 802.3 (Ethernet) polynomial:
- * 0xEDB88320 (reversed representation of 0x04C11DB7).
- *
- * The table is immediately invoked and cached as a constant for performance,
- * following the common implementation pattern for CRC algorithms.
- */
-const crcTable = (() => {
-    // Create a typed array for better performance with 256 32-bit unsigned integers
-    const table = new Uint32Array(256);
-    // Generate table entries for all possible byte values (0-255)
-    for (let i = 0; i < 256; i++) {
-        let crc = i; // Initialize with current byte value
-        // Process each bit (8 times)
-        for (let j = 0; j < 8; j++) {
-            /*
-             * CRC division algorithm:
-             * 1. If LSB is set (crc & 1), XOR with polynomial
-             * 2. Right-shift by 1 (unsigned)
-             *
-             * The polynomial 0xEDB88320 is:
-             * - Bit-reversed version of 0x04C11DB7
-             * - Uses reflected input/output algorithm
-             */
-            crc = crc & 1
-                ? 0xedb88320 ^ (crc >>> 1) // XOR with polynomial if LSB is set
-                : crc >>> 1; // Just shift right if LSB is not set
-        }
-        // Store final 32-bit value (>>> 0 ensures unsigned 32-bit representation)
-        table[i] = crc >>> 0;
-    }
-    return table;
-})();
+const constants_js_1 = require("../constants.js");
 /**
  * Computes a CRC-32 checksum for the given Buffer using the standard IEEE 802.3 polynomial.
  * This implementation uses a precomputed lookup table for optimal performance.
@@ -65,7 +32,7 @@ function crc32(buf) {
          * - crc >>> 8 - Shift CRC right by 8 bits (unsigned)
          * - ^ crcTable[...] - XOR with precomputed table value
          */
-        crc = (crc >>> 8) ^ crcTable[(crc ^ buf[i]) & 0xff];
+        crc = (crc >>> 8) ^ constants_js_1.CRC32_TABLE[(crc ^ buf[i]) & 0xff];
     }
     /*
      * Final processing:

package/build/cjs/lib/zip/utils/index.js

@@ -14,6 +14,7 @@ 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 });
+__exportStar(require("./crc-32-stream.js"), exports);
 __exportStar(require("./crc-32.js"), exports);
 __exportStar(require("./dos-time.js"), exports);
 __exportStar(require("./find-data-descriptor.js"), exports);

package/build/esm/lib/index.js

@@ -1,2 +1,3 @@
 export * from "./merge-sheets-to-base-file-sync.js";
 export * from "./merge-sheets-to-base-file.js";
+export * from "./template/index.js";

package/build/esm/lib/template/index.js

@@ -0,0 +1 @@
+export * from "./template-fs.js";