@js-ak/excel-toolbox 1.2.6 → 1.3.0

package/build/types/lib/template/utils/check-row.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Validates that each key in the given row object is a valid cell reference.
+ *
+ * This function checks that all keys in the provided row object are composed
+ * only of column letters (A-Z, case insensitive). If a key is found that does
+ * not match this pattern, an error is thrown with a message indicating the
+ * invalid cell reference.
+ *
+ * @param row - An object representing a row of data, where keys are cell
+ *              references and values are strings.
+ *
+ * @throws {Error} If any key in the row is not a valid column letter.
+ */
+export declare function checkRow(row: Record<string, string>): void;

package/build/types/lib/template/utils/check-rows.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Validates an array of row objects to ensure each cell reference is valid.
+ * Each row object is checked to ensure that its keys (cell references) are
+ * composed of valid column letters (e.g., "A", "B", "C").
+ *
+ * @param rows An array of row objects, where each object represents a row
+ * of data with cell references as keys and cell values as strings.
+ *
+ * @throws {Error} If any cell reference in the rows is invalid.
+ */
+export declare function checkRows(rows: Record<string, string>[]): void;

package/build/types/lib/template/utils/check-start-row.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Checks if startRow is a positive integer.
+ *
+ * @param startRow The start row to check.
+ *
+ * @throws {Error} If startRow is not a positive integer.
+ */
+export declare function checkStartRow(startRow?: number): void;

package/build/types/lib/template/utils/column-index-to-letter.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Converts a 0-based column index to an Excel-style letter (A, B, ..., Z, AA, AB, ...).
+ *
+ * @param index - The 0-based column index.
+ * @returns The Excel-style letter for the given column index.
+ */
+export declare function columnIndexToLetter(index: number): string;

package/build/types/lib/template/utils/escape-xml.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Escapes special characters in a string for use in an XML document.
+ *
+ * Replaces:
+ * - `&` with `&`
+ * - `<` with `&lt;`
+ * - `>` with `&gt;`
+ * - `"` with `&quot;`
+ * - `'` with `&apos;`
+ *
+ * @param str - The string to escape.
+ * @returns The escaped string.
+ */
+export declare function escapeXml(str: string): string;

package/build/types/lib/template/utils/get-max-row-number.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Finds the maximum row number in a list of <row> elements
+ * and returns the maximum row number + 1.
+ * @param {string} line - The line of XML to parse.
+ * @returns {number} - The maximum row number found + 1.
+ */
+export declare function getMaxRowNumber(line: string): number;

package/build/types/lib/template/utils/get-rows-above.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Filters out all rows in the given map that have a row number
+ * lower than or equal to the given minRow, and returns the
+ * filtered rows as a single string. Useful for removing rows
+ * from a template that are positioned above a certain row
+ * number.
+ *
+ * @param {Map<number, string>} map - The map of row numbers to row content
+ * @param {number} minRow - The minimum row number to include in the output
+ * @returns {string} The filtered rows, concatenated into a single string
+ */
+export declare function getRowsAbove(map: Map<number, string>, minRow: number): string;

package/build/types/lib/template/utils/get-rows-below.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Filters out all rows in the given map that have a row number
+ * greater than or equal to the given maxRow, and returns the
+ * filtered rows as a single string. Useful for removing rows
+ * from a template that are positioned below a certain row
+ * number.
+ *
+ * @param {Map<number, string>} map - The map of row numbers to row content
+ * @param {number} maxRow - The maximum row number to include in the output
+ * @returns {string} The filtered rows, concatenated into a single string
+ */
+export declare function getRowsBelow(map: Map<number, string>, maxRow: number): string;

package/build/types/lib/template/utils/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./check-row.js";
+export * from "./check-rows.js";
+export * from "./check-start-row.js";
+export * from "./column-index-to-letter.js";
+export * from "./escape-xml.js";
+export * from "./get-max-row-number.js";
+export * from "./get-rows-above.js";
+export * from "./get-rows-below.js";
+export * from "./parse-rows.js";
+export * from "./to-excel-column-object.js";
+export * from "./write-rows-to-stream.js";

package/build/types/lib/template/utils/parse-rows.d.ts

@@ -0,0 +1 @@
+export declare function parseRows(innerRows: string): Map<number, string>;

package/build/types/lib/template/utils/to-excel-column-object.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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>
+ */
+export declare function toExcelColumnObject(values: unknown[]): Record<string, string>;

package/build/types/lib/template/utils/write-rows-to-stream.d.ts

@@ -0,0 +1,25 @@
+import * as fs from "node:fs";
+/**
+ * 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).
+ */
+export declare function writeRowsToStream(output: fs.WriteStream, rows: AsyncIterable<unknown[]>, startRowNumber: number): Promise<{
+    rowNumber: number;
+}>;

package/build/types/lib/zip/constants.d.ts

@@ -12,6 +12,15 @@ import { Buffer } from "node:buffer";
  * Found in the central directory that appears at the end of the ZIP file.
  */
 export declare const CENTRAL_DIR_HEADER_SIG: Buffer<ArrayBuffer>;
+/**
+ * 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.
+ */
+export declare const CRC32_TABLE: Uint32Array<ArrayBuffer>;
 /**
  * End of Central Directory Record signature (0x504b0506).
  * Marks the end of the central directory and contains global information

package/build/types/lib/zip/create-with-stream.d.ts

@@ -0,0 +1,13 @@
+import { Writable } from "node:stream";
+/**
+ * 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.
+ */
+export declare function createWithStream(fileKeys: string[], destination: string, output: Writable): Promise<void>;

package/build/types/lib/zip/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./create-sync.js";
+export * from "./create-with-stream.js";
 export * from "./create.js";
 export * from "./read-sync.js";
 export * from "./read.js";

package/build/types/lib/zip/utils/crc-32-stream.d.ts

@@ -0,0 +1,11 @@
+import { Transform } from "node:stream";
+/**
+ * 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.
+ */
+export declare function crc32Stream(): Transform & {
+    digest: () => number;
+};

package/build/types/lib/zip/utils/crc-32.d.ts

@@ -0,0 +1,15 @@
+import { Buffer } from "node:buffer";
+/**
+ * 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)
+ */
+export declare function crc32(buf: Buffer): number;

package/build/types/lib/zip/utils/dos-time.d.ts

@@ -0,0 +1,25 @@
+import { Buffer } from "node:buffer";
+/**
+ * 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
+ */
+export declare function dosTime(date: Date): Buffer;

package/build/types/lib/zip/utils/find-data-descriptor.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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.
+ */
+export declare function findDataDescriptor(buffer: Buffer, start: number): {
+    offset: number;
+    compressedSize: number;
+};

package/build/types/lib/zip/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./crc-32-stream.js";
+export * from "./crc-32.js";
+export * from "./dos-time.js";
+export * from "./find-data-descriptor.js";
+export * from "./to-bytes.js";

package/build/types/lib/zip/utils/to-bytes.d.ts

@@ -0,0 +1,20 @@
+import { Buffer } from "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)
+ */
+export declare function toBytes(value: number, len: number): Buffer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@js-ak/excel-toolbox",
-  "version": "1.2.6",
+  "version": "1.3.0",
   "description": "excel-toolbox",
   "publishConfig": {
     "access": "public",

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

@@ -1,157 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.crc32 = crc32;
-exports.dosTime = dosTime;
-exports.toBytes = toBytes;
-const node_buffer_1 = require("node:buffer");
-/**
- * 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;
-})();
-/**
- * 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) ^ crcTable[(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;
-}
-/**
- * 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([
-        ...toBytes(time, 2), // Convert time to 2 bytes (LSB first)
-        ...toBytes(day, 2), // Convert date to 2 bytes (LSB first)
-    ]);
-}
-/**
- * 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/zip/utils.js

@@ -1,152 +0,0 @@
-import { Buffer } from "node:buffer";
-/**
- * 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;
-})();
-/**
- * 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)
- */
-export 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) ^ crcTable[(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;
-}
-/**
- * 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
- */
-export 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 Buffer.from([
-        ...toBytes(time, 2), // Convert time to 2 bytes (LSB first)
-        ...toBytes(day, 2), // Convert date to 2 bytes (LSB first)
-    ]);
-}
-/**
- * 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)
- */
-export function toBytes(value, len) {
-    // Allocate a new Buffer of the requested length, automatically zero-filled
-    const buf = 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;
-}