@js-ak/excel-toolbox 1.2.6 → 1.3.0

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

@@ -1,4 +1,37 @@
 "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 };
 };
@@ -6,6 +39,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.read = read;
 const node_util_1 = __importDefault(require("node:util"));
 const node_zlib_1 = __importDefault(require("node:zlib"));
+const Utils = __importStar(require("./utils/index.js"));
 const inflateRaw = node_util_1.default.promisify(node_zlib_1.default.inflateRaw);
 /**
  * Parses a ZIP archive from a buffer and extracts the files within.
@@ -29,22 +63,37 @@ async function read(buffer) {
         const fileNameEnd = fileNameStart + fileNameLength;
         const fileName = buffer.subarray(fileNameStart, fileNameEnd).toString();
         const dataStart = fileNameEnd + extraFieldLength;
-        const compressedSize = buffer.readUInt32LE(offset + 18);
         const useDataDescriptor = (generalPurposeBitFlag & 0x08) !== 0;
-        if (useDataDescriptor) {
-            throw new Error(`File ${fileName} uses data descriptor. Not supported in this minimal parser.`);
-        }
-        const compressedData = buffer.subarray(dataStart, dataStart + compressedSize);
+        let compressedData;
         let content;
         try {
-            if (compressionMethod === 0) {
-                content = compressedData;
-            }
-            else if (compressionMethod === 8) {
-                content = await inflateRaw(compressedData);
+            if (useDataDescriptor) {
+                const { compressedSize, offset: ddOffset } = Utils.findDataDescriptor(buffer, dataStart);
+                compressedData = buffer.subarray(dataStart, dataStart + compressedSize);
+                if (compressionMethod === 0) {
+                    content = compressedData;
+                }
+                else if (compressionMethod === 8) {
+                    content = await inflateRaw(compressedData);
+                }
+                else {
+                    throw new Error(`Unsupported compression method ${compressionMethod}`);
+                }
+                offset = ddOffset + 16; // Skip over data descriptor
             }
             else {
-                throw new Error(`Unsupported compression method ${compressionMethod}`);
+                const compressedSize = buffer.readUInt32LE(offset + 18);
+                compressedData = buffer.subarray(dataStart, dataStart + compressedSize);
+                if (compressionMethod === 0) {
+                    content = compressedData;
+                }
+                else if (compressionMethod === 8) {
+                    content = await inflateRaw(compressedData);
+                }
+                else {
+                    throw new Error(`Unsupported compression method ${compressionMethod}`);
+                }
+                offset = dataStart + compressedSize;
             }
         }
         catch (error) {
@@ -52,7 +101,6 @@ async function read(buffer) {
             throw new Error(`Error unpacking file ${fileName}: ${message}`);
         }
         files[fileName] = content;
-        offset = dataStart + compressedSize;
     }
     return files;
 }

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

@@ -0,0 +1,36 @@
+"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({
+        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

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.crc32 = crc32;
+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.
+ *
+ * The algorithm follows these characteristics:
+ * - Polynomial: 0xEDB88320 (reversed representation of 0x04C11DB7)
+ * - Initial value: 0xFFFFFFFF (inverted by ~0)
+ * - Final XOR value: 0xFFFFFFFF (achieved by inverting the result)
+ * - Input and output reflection: Yes
+ *
+ * @param {Buffer} buf - The input buffer to calculate checksum for
+ * @returns {number} - The 32-bit unsigned CRC-32 checksum (0x00000000 to 0xFFFFFFFF)
+ */
+function crc32(buf) {
+    // Initialize CRC with all 1's (0xFFFFFFFF) using bitwise NOT
+    let crc = ~0;
+    // Process each byte in the buffer
+    for (let i = 0; i < buf.length; i++) {
+        /*
+         * CRC update algorithm steps:
+         * 1. XOR current CRC with next byte (lowest 8 bits)
+         * 2. Use result as index in precomputed table (0-255)
+         * 3. XOR the table value with right-shifted CRC (8 bits)
+         *
+         * The operation breakdown:
+         * - (crc ^ buf[i]) - XOR with next byte
+         * - & 0xff - Isolate lowest 8 bits
+         * - crc >>> 8 - Shift CRC right by 8 bits (unsigned)
+         * - ^ crcTable[...] - XOR with precomputed table value
+         */
+        crc = (crc >>> 8) ^ constants_js_1.CRC32_TABLE[(crc ^ buf[i]) & 0xff];
+    }
+    /*
+     * Final processing:
+     * 1. Invert all bits (~crc) to match standard CRC-32 output
+     * 2. Convert to unsigned 32-bit integer (>>> 0)
+     */
+    return ~crc >>> 0;
+}

package/build/cjs/lib/zip/utils/dos-time.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dosTime = dosTime;
+const node_buffer_1 = require("node:buffer");
+const to_bytes_js_1 = require("./to-bytes.js");
+/**
+ * Converts a JavaScript Date object to a 4-byte Buffer in MS-DOS date/time format
+ * as specified in the ZIP file format specification (PKZIP APPNOTE.TXT).
+ *
+ * The MS-DOS date/time format packs both date and time into 4 bytes (32 bits) with
+ * the following bit layout:
+ *
+ * Time portion (2 bytes/16 bits):
+ * - Bits 00-04: Seconds divided by 2 (0-29, representing 0-58 seconds)
+ * - Bits 05-10: Minutes (0-59)
+ * - Bits 11-15: Hours (0-23)
+ *
+ * Date portion (2 bytes/16 bits):
+ * - Bits 00-04: Day (1-31)
+ * - Bits 05-08: Month (1-12)
+ * - Bits 09-15: Year offset from 1980 (0-127, representing 1980-2107)
+ *
+ * @param {Date} date - The JavaScript Date object to convert
+ * @returns {Buffer} - 4-byte Buffer containing:
+ *                    - Bytes 0-1: DOS time (hours, minutes, seconds/2)
+ *                    - Bytes 2-3: DOS date (year-1980, month, day)
+ * @throws {RangeError} - If the date is before 1980 or after 2107
+ */
+function dosTime(date) {
+    // Pack time components into 2 bytes (16 bits):
+    // - Hours (5 bits) shifted left 11 positions (bits 11-15)
+    // - Minutes (6 bits) shifted left 5 positions (bits 5-10)
+    // - Seconds/2 (5 bits) in least significant bits (bits 0-4)
+    const time = (date.getHours() << 11) | // Hours occupy bits 11-15
+        (date.getMinutes() << 5) | // Minutes occupy bits 5-10
+        (Math.floor(date.getSeconds() / 2)); // Seconds/2 occupy bits 0-4
+    // Pack date components into 2 bytes (16 bits):
+    // - (Year-1980) (7 bits) shifted left 9 positions (bits 9-15)
+    // - Month (4 bits) shifted left 5 positions (bits 5-8)
+    // - Day (5 bits) in least significant bits (bits 0-4)
+    const day = ((date.getFullYear() - 1980) << 9) | // Years since 1980 (bits 9-15)
+        ((date.getMonth() + 1) << 5) | // Month 1-12 (bits 5-8)
+        date.getDate(); // Day 1-31 (bits 0-4)
+    // Combine both 2-byte values into a single 4-byte Buffer
+    // Note: Using little-endian byte order for each 2-byte segment
+    return node_buffer_1.Buffer.from([
+        ...(0, to_bytes_js_1.toBytes)(time, 2), // Convert time to 2 bytes (LSB first)
+        ...(0, to_bytes_js_1.toBytes)(day, 2), // Convert date to 2 bytes (LSB first)
+    ]);
+}

package/build/cjs/lib/zip/utils/find-data-descriptor.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findDataDescriptor = findDataDescriptor;
+/**
+ * Finds a Data Descriptor in a ZIP archive buffer.
+ *
+ * The Data Descriptor is an optional 16-byte structure that appears at the end of a file's compressed data.
+ * It contains the compressed size of the file, and must be used when the Local File Header does not contain this information.
+ *
+ * @param buffer - The buffer containing the ZIP archive data.
+ * @param start - The starting offset in the buffer to search for the Data Descriptor.
+ * @returns - An object with `offset` and `compressedSize` properties.
+ * @throws {Error} - If the Data Descriptor is not found.
+ */
+function findDataDescriptor(buffer, start) {
+    const DATA_DESCRIPTOR_SIGNATURE = 0x08074b50;
+    const DATA_DESCRIPTOR_TOTAL_LENGTH = 16;
+    const COMPRESSED_SIZE_OFFSET_FROM_SIGNATURE = 8;
+    for (let i = start; i <= buffer.length - DATA_DESCRIPTOR_TOTAL_LENGTH; i++) {
+        if (buffer.readUInt32LE(i) === DATA_DESCRIPTOR_SIGNATURE) {
+            const compressedSize = buffer.readUInt32LE(i + COMPRESSED_SIZE_OFFSET_FROM_SIGNATURE);
+            return {
+                compressedSize,
+                offset: i,
+            };
+        }
+    }
+    throw new Error("Data Descriptor not found");
+}

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

@@ -0,0 +1,21 @@
+"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("./crc-32-stream.js"), exports);
+__exportStar(require("./crc-32.js"), exports);
+__exportStar(require("./dos-time.js"), exports);
+__exportStar(require("./find-data-descriptor.js"), exports);
+__exportStar(require("./to-bytes.js"), exports);

package/build/cjs/lib/zip/utils/to-bytes.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toBytes = toBytes;
+const node_buffer_1 = require("node:buffer");
+/**
+ * Converts a numeric value into a fixed-length Buffer representation,
+ * storing the value in little-endian format with right-padding of zeros.
+ *
+ * This is particularly useful for binary protocols or file formats that
+ * require fixed-width numeric fields.
+ *
+ * @param {number} value - The numeric value to convert to bytes.
+ *        Note: JavaScript numbers are IEEE 754 doubles, but only the
+ *        integer portion will be used (up to 53-bit precision).
+ * @param {number} len - The desired length of the output Buffer in bytes.
+ *        Must be a positive integer.
+ * @returns {Buffer} - A new Buffer of exactly `len` bytes containing:
+ *        1. The value's bytes in little-endian order (least significant byte first)
+ *        2. Zero padding in any remaining higher-order bytes
+ * @throws {RangeError} - If the value requires more bytes than `len` to represent
+ *        (though this is currently not explicitly checked)
+ */
+function toBytes(value, len) {
+    // Allocate a new Buffer of the requested length, automatically zero-filled
+    const buf = node_buffer_1.Buffer.alloc(len);
+    // Process each byte position from least significant to most significant
+    for (let i = 0; i < len; i++) {
+        // Store the least significant byte of the current value
+        buf[i] = value & 0xff; // Mask to get bottom 8 bits
+        // Right-shift the value by 8 bits to process the next byte
+        // Note: This uses unsigned right shift (>>> would be signed)
+        value >>= 8;
+        // If the loop completes with value != 0, we've overflowed the buffer length,
+        // but this isn't currently checked/handled
+    }
+    return buf;
+}

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";