@js-ak/excel-toolbox 1.0.0 → 1.2.0

package/build/cjs/test/index.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_test_1 = __importDefault(require("node:test"));
+(0, node_test_1.default)("test", () => {
+    node_assert_1.default.equal(true, true);
+});

package/build/esm/index.js

@@ -0,0 +1 @@
+export * from "./lib/index.js";

package/build/esm/lib/index.js

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

package/build/esm/lib/merge-sheets-to-base-file-process.js

@@ -0,0 +1,69 @@
+import * as Utils from "./utils/index.js";
+import * as Xml from "./xml/index.js";
+/**
+ * Merges rows from other Excel files into a base Excel file.
+ *
+ * This function is a process-friendly version of mergeSheetsToBaseFile.
+ * It takes a single object with the following properties:
+ * - additions: An array of objects with two properties:
+ *   - files: A dictionary of file paths to their corresponding XML content
+ *   - sheetIndexes: The 1-based indexes of the sheet to extract rows from
+ * - baseFiles: A dictionary of file paths to their corresponding XML content
+ * - baseSheetIndex: The 1-based index of the sheet in the base file to add rows to
+ * - gap: The number of empty rows to insert between each added section
+ * - sheetNamesToRemove: The names of sheets to remove from the output file
+ * - sheetsToRemove: The 1-based indices of sheets to remove from the output file
+ *
+ * The function returns a dictionary of file paths to their corresponding XML content.
+ */
+export function mergeSheetsToBaseFileProcess(data) {
+    const { additions, baseFiles, baseSheetIndex, gap, sheetNamesToRemove, sheetsToRemove, } = data;
+    const basePath = `xl/worksheets/sheet${baseSheetIndex}.xml`;
+    if (!baseFiles[basePath]) {
+        throw new Error(`Base file does not contain ${basePath}`);
+    }
+    const { lastRowNumber, mergeCells: baseMergeCells, rows: baseRows, } = Xml.extractRowsFromSheet(baseFiles[basePath]);
+    const allRows = [...baseRows];
+    const allMergeCells = [...baseMergeCells];
+    let currentRowOffset = lastRowNumber + gap;
+    for (const { files, sheetIndexes } of additions) {
+        for (const sheetIndex of sheetIndexes) {
+            const sheetPath = `xl/worksheets/sheet${sheetIndex}.xml`;
+            if (!files[sheetPath]) {
+                throw new Error(`File does not contain ${sheetPath}`);
+            }
+            const { mergeCells, rows } = Xml.extractRowsFromSheet(files[sheetPath]);
+            const shiftedRows = Xml.shiftRowIndices(rows, currentRowOffset);
+            const shiftedMergeCells = mergeCells.map(cell => {
+                const [start, end] = cell.ref.split(":");
+                if (!start || !end) {
+                    return cell;
+                }
+                const shiftedStart = Utils.shiftCellRef(start, currentRowOffset);
+                const shiftedEnd = Utils.shiftCellRef(end, currentRowOffset);
+                return { ...cell, ref: `${shiftedStart}:${shiftedEnd}` };
+            });
+            allRows.push(...shiftedRows);
+            allMergeCells.push(...shiftedMergeCells);
+            currentRowOffset += Utils.getMaxRowNumber(rows) + gap;
+        }
+    }
+    const mergedXml = Xml.buildMergedSheet(baseFiles[basePath], allRows, allMergeCells);
+    baseFiles[basePath] = mergedXml;
+    for (const sheetIndex of sheetsToRemove) {
+        const sheetPath = `xl/worksheets/sheet${sheetIndex}.xml`;
+        delete baseFiles[sheetPath];
+        if (baseFiles["xl/workbook.xml"]) {
+            baseFiles["xl/workbook.xml"] = Utils.removeSheetFromWorkbook(baseFiles["xl/workbook.xml"], sheetIndex);
+        }
+        if (baseFiles["xl/_rels/workbook.xml.rels"]) {
+            baseFiles["xl/_rels/workbook.xml.rels"] = Utils.removeSheetFromRels(baseFiles["xl/_rels/workbook.xml.rels"], sheetIndex);
+        }
+        if (baseFiles["[Content_Types].xml"]) {
+            baseFiles["[Content_Types].xml"] = Utils.removeSheetFromContentTypes(baseFiles["[Content_Types].xml"], sheetIndex);
+        }
+    }
+    for (const sheetName of sheetNamesToRemove) {
+        Utils.removeSheetByName(baseFiles, sheetName);
+    }
+}

package/build/esm/lib/merge-sheets-to-base-file-sync.js

@@ -0,0 +1,41 @@
+import * as Utils from "./utils/index.js";
+import * as Zip from "./zip/index.js";
+import { mergeSheetsToBaseFileProcess } from "./merge-sheets-to-base-file-process.js";
+/**
+ * Merge rows from other Excel files into a base Excel file.
+ * The output is a new Excel file with the merged content.
+ *
+ * @param {Object} data
+ * @param {Object[]} data.additions
+ * @param {Buffer} data.additions.file - The file to extract rows from
+ * @param {number[]} data.additions.sheetIndexes - The 1-based indexes of the sheet to extract rows from
+ * @param {Buffer} data.baseFile - The base file to add rows to
+ * @param {number} [data.baseSheetIndex=1] - The 1-based index of the sheet in the base file to add rows to
+ * @param {number} [data.gap=0] - The number of empty rows to insert between each added section
+ * @param {string[]} [data.sheetNamesToRemove=[]] - The names of sheets to remove from the output file
+ * @param {number[]} [data.sheetsToRemove=[]] - The 1-based indices of sheets to remove from the output file
+ * @returns {Buffer} - The merged Excel file
+ */
+export function mergeSheetsToBaseFileSync(data) {
+    const { additions = [], baseFile, baseSheetIndex = 1, gap = 0, sheetNamesToRemove = [], sheetsToRemove = [], } = data;
+    const baseFiles = Zip.readSync(baseFile);
+    const additionsUpdated = [];
+    for (const { file, isBaseFile, sheetIndexes } of additions) {
+        const files = (isBaseFile || Utils.isSameBuffer(file, baseFile))
+            ? baseFiles
+            : Zip.readSync(file);
+        additionsUpdated.push({
+            files,
+            sheetIndexes,
+        });
+    }
+    mergeSheetsToBaseFileProcess({
+        additions: additionsUpdated,
+        baseFiles,
+        baseSheetIndex,
+        gap,
+        sheetNamesToRemove,
+        sheetsToRemove,
+    });
+    return Zip.createSync(baseFiles);
+}

package/build/esm/lib/merge-sheets-to-base-file.js

@@ -0,0 +1,41 @@
+import * as Utils from "./utils/index.js";
+import * as Zip from "./zip/index.js";
+import { mergeSheetsToBaseFileProcess } from "./merge-sheets-to-base-file-process.js";
+/**
+ * Merge rows from other Excel files into a base Excel file.
+ * The output is a new Excel file with the merged content.
+ *
+ * @param {Object} data
+ * @param {Object[]} data.additions
+ * @param {Buffer} data.additions.file - The file to extract rows from
+ * @param {number[]} data.additions.sheetIndexes - The 1-based indexes of the sheet to extract rows from
+ * @param {Buffer} data.baseFile - The base file to add rows to
+ * @param {number} [data.baseSheetIndex=1] - The 1-based index of the sheet in the base file to add rows to
+ * @param {number} [data.gap=0] - The number of empty rows to insert between each added section
+ * @param {string[]} [data.sheetNamesToRemove=[]] - The names of sheets to remove from the output file
+ * @param {number[]} [data.sheetsToRemove=[]] - The 1-based indices of sheets to remove from the output file
+ * @returns {Promise<Buffer>} - The merged Excel file
+ */
+export async function mergeSheetsToBaseFile(data) {
+    const { additions = [], baseFile, baseSheetIndex = 1, gap = 0, sheetNamesToRemove = [], sheetsToRemove = [], } = data;
+    const baseFiles = await Zip.read(baseFile);
+    const additionsUpdated = [];
+    for (const { file, isBaseFile, sheetIndexes } of additions) {
+        const files = (isBaseFile || Utils.isSameBuffer(file, baseFile))
+            ? baseFiles
+            : await Zip.read(file);
+        additionsUpdated.push({
+            files,
+            sheetIndexes,
+        });
+    }
+    mergeSheetsToBaseFileProcess({
+        additions: additionsUpdated,
+        baseFiles,
+        baseSheetIndex,
+        gap,
+        sheetNamesToRemove,
+        sheetsToRemove,
+    });
+    return Zip.create(baseFiles);
+}

package/build/esm/lib/utils/get-max-row-number.js

@@ -0,0 +1,19 @@
+/**
+ * Finds the maximum row number in a list of <row> elements.
+ * @param {string[]} rows - An array of strings, each representing a <row> element.
+ * @returns {number} - The maximum row number.
+ */
+export function getMaxRowNumber(rows) {
+    let max = 0;
+    for (const row of rows) {
+        const match = row.match(/<row[^>]* r="(\d+)"/);
+        if (match) {
+            if (!match[1])
+                continue;
+            const num = parseInt(match[1], 10);
+            if (num > max)
+                max = num;
+        }
+    }
+    return max;
+}

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

@@ -0,0 +1,7 @@
+export * from "./get-max-row-number.js";
+export * from "./is-same-buffer.js";
+export * from "./remove-sheet-by-name.js";
+export * from "./remove-sheet-from-content-types.js";
+export * from "./remove-sheet-from-rels.js";
+export * from "./remove-sheet-from-workbook.js";
+export * from "./shift-cell-ref.js";

package/build/esm/lib/utils/is-same-buffer.js

@@ -0,0 +1,9 @@
+/**
+ * Checks if two Buffers are the same
+ * @param {Buffer} buf1 - the first Buffer
+ * @param {Buffer} buf2 - the second Buffer
+ * @returns {boolean} - true if the Buffers are the same, false otherwise
+ */
+export function isSameBuffer(buf1, buf2) {
+    return buf1.equals(buf2);
+}

package/build/esm/lib/utils/remove-sheet-by-name.js

@@ -0,0 +1,41 @@
+/**
+ * Removes a sheet from the Excel workbook by name.
+ * @param {Object.<string, string | Buffer>} files - The dictionary of files in the workbook.
+ * @param {string} sheetName - The name of the sheet to remove.
+ * @returns {void}
+ */
+export function removeSheetByName(files, sheetName) {
+    const workbookXml = files["xl/workbook.xml"];
+    const relsXml = files["xl/_rels/workbook.xml.rels"];
+    if (!workbookXml || !relsXml) {
+        return;
+    }
+    const sheetMatch = workbookXml.match(new RegExp(`<sheet[^>]+name=["']${sheetName}["'][^>]*/>`));
+    if (!sheetMatch) {
+        return;
+    }
+    const sheetTag = sheetMatch[0];
+    const sheetIdMatch = sheetTag.match(/sheetId=["'](\d+)["']/);
+    const ridMatch = sheetTag.match(/r:id=["'](rId\d+)["']/);
+    if (!sheetIdMatch || !ridMatch) {
+        return;
+    }
+    const relId = ridMatch[1];
+    const relMatch = relsXml.match(new RegExp(`<Relationship[^>]+Id=["']${relId}["'][^>]+Target=["']([^"']+)["'][^>]*/>`));
+    if (!relMatch) {
+        return;
+    }
+    const relTag = relMatch[0];
+    const targetMatch = relTag.match(/Target=["']([^"']+)["']/);
+    if (!targetMatch) {
+        return;
+    }
+    const targetPath = `xl/${targetMatch[1]}`.replace(/\\/g, "/");
+    delete files[targetPath];
+    files["xl/workbook.xml"] = workbookXml.replace(sheetTag, "");
+    files["xl/_rels/workbook.xml.rels"] = relsXml.replace(relTag, "");
+    const contentTypes = files["[Content_Types].xml"];
+    if (contentTypes) {
+        files["[Content_Types].xml"] = contentTypes.replace(new RegExp(`<Override[^>]+PartName=["']/${targetPath}["'][^>]*/>`, "g"), "");
+    }
+}

package/build/esm/lib/utils/remove-sheet-from-content-types.js

@@ -0,0 +1,9 @@
+/**
+ * Removes the specified sheet from the Content_Types.xml file.
+ * @param {string} xml - The Content_Types.xml file contents as a string
+ * @param {number} sheetIndex - The 1-based index of the sheet to remove
+ * @returns {string} - The modified Content_Types.xml file contents
+ */
+export function removeSheetFromContentTypes(xml, sheetIndex) {
+    return xml.replace(new RegExp(`<Override[^>]+PartName=["']/xl/worksheets/sheet${sheetIndex}\\.xml["'][^>]*/>`, "g"), "");
+}

package/build/esm/lib/utils/remove-sheet-from-rels.js

@@ -0,0 +1,9 @@
+/**
+ * Removes the specified sheet from the workbook relationships file (xl/_rels/workbook.xml.rels).
+ * @param {string} xml - The workbook relationships file contents as a string
+ * @param {number} sheetIndex - The 1-based index of the sheet to remove
+ * @returns {string} - The modified workbook relationships file contents
+ */
+export function removeSheetFromRels(xml, sheetIndex) {
+    return xml.replace(new RegExp(`<Relationship[^>]+Target=["']worksheets/sheet${sheetIndex}\\.xml["'][^>]*/>`, "g"), "");
+}

package/build/esm/lib/utils/remove-sheet-from-workbook.js

@@ -0,0 +1,9 @@
+/**
+ * Removes the specified sheet from the workbook (xl/workbook.xml).
+ * @param {string} xml - The workbook file contents as a string
+ * @param {number} sheetIndex - The 1-based index of the sheet to remove
+ * @returns {string} - The modified workbook file contents
+ */
+export function removeSheetFromWorkbook(xml, sheetIndex) {
+    return xml.replace(new RegExp(`<sheet[^>]+sheetId=["']${sheetIndex}["'][^>]*/>`, "g"), "");
+}

package/build/esm/lib/utils/shift-cell-ref.js

@@ -0,0 +1,22 @@
+/**
+ * Shifts the row number in a cell reference by the specified number of rows.
+ * The function takes a cell reference string in the format "A1" and a row shift value.
+ * It returns the shifted cell reference string.
+ *
+ * @example
+ * // Shifts the cell reference "A1" down by 2 rows, resulting in "A3"
+ * shiftCellRef('A1', 2);
+ * @param {string} cellRef - The cell reference string to be shifted
+ * @param {number} rowShift - The number of rows to shift the reference by
+ * @returns {string} - The shifted cell reference string
+ */
+export function shiftCellRef(cellRef, rowShift) {
+    const match = cellRef.match(/^([A-Z]+)(\d+)$/);
+    if (!match)
+        return cellRef;
+    const col = match[1];
+    if (!match[2])
+        return cellRef;
+    const row = parseInt(match[2], 10);
+    return `${col}${row + rowShift}`;
+}

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

@@ -0,0 +1,28 @@
+/**
+ * Builds a new XML string for a merged Excel sheet by combining the original XML
+ * with merged rows and optional cell merge information.
+ *
+ * This function replaces the <sheetData> section in the original XML with the provided merged rows,
+ * and optionally adds <mergeCells> definitions after the </sheetData> tag.
+ *
+ * @param {string} originalXml - The original XML string of the Excel worksheet.
+ * @param {string[]} mergedRows - Array of XML strings representing each row in the merged sheet.
+ * @param {Object[]} [mergeCells] - Optional array of merge cell definitions.
+ *        Each object should have a 'ref' property specifying the merge range (e.g., "A1:B2").
+ * @returns {string} - The reconstructed XML string with merged content.
+ */
+export function buildMergedSheet(originalXml, mergedRows, mergeCells = []) {
+    // Remove any existing <mergeCells> section from the XML
+    let xmlData = originalXml.replace(/<mergeCells[^>]*>[\s\S]*?<\/mergeCells>/g, "");
+    // Construct a new <sheetData> section with the provided rows
+    const sheetDataXml = `<sheetData>${mergedRows.join("")}</sheetData>`;
+    // Replace the existing <sheetData> section with the new one
+    xmlData = xmlData.replace(/<sheetData[^>]*>[\s\S]*?<\/sheetData>/, sheetDataXml);
+    if (mergeCells.length > 0) {
+        // 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`);
+    }
+    return xmlData;
+}

package/build/{lib → esm/lib}/xml/extract-rows-from-sheet.js

@@ -1,4 +1,4 @@
-import { extractXmlFromSheet } from './extract-xml-from-sheet.js';
+import { extractXmlFromSheet } from "./extract-xml-from-sheet.js";
 /**
  * Parses a worksheet (either as Buffer or string) to extract row data,
  * last row number, and merge cell information from Excel XML format.
@@ -21,15 +21,15 @@ import { extractXmlFromSheet } from './extract-xml-from-sheet.js';
  */
 export function extractRowsFromSheet(sheet) {
     // Convert Buffer input to XML string if needed
-    const xml = typeof sheet === 'string' ? sheet : extractXmlFromSheet(sheet);
+    const xml = typeof sheet === "string" ? sheet : extractXmlFromSheet(sheet);
     // Extract the sheetData section containing all rows
     const sheetDataMatch = xml.match(/<sheetData[^>]*>([\s\S]*?)<\/sheetData>/);
     if (!sheetDataMatch) {
-        throw new Error('sheetData not found in worksheet XML');
+        throw new Error("sheetData not found in worksheet XML");
     }
-    const sheetDataContent = sheetDataMatch[1] || '';
+    const sheetDataContent = sheetDataMatch[1] || "";
     // Extract all <row> elements using regex
-    const rowMatches = [...sheetDataContent.matchAll(/<row[\s\S]*?<\/row>/g)];
+    const rowMatches = [...sheetDataContent.matchAll(/<row\b[^>]*\/>|<row\b[^>]*>[\s\S]*?<\/row>/g)];
     const rows = rowMatches.map(match => match[0]);
     // Calculate the highest row number present in the sheet
     const lastRowNumber = rowMatches
@@ -54,8 +54,8 @@ export function extractRowsFromSheet(sheet) {
         });
     }
     return {
-        rows,
         lastRowNumber,
         mergeCells,
+        rows,
     };
 }

package/build/{lib → esm/lib}/xml/extract-xml-from-sheet.js

@@ -1,4 +1,4 @@
-import { inflateRaw } from 'pako';
+import { inflateRaw } from "pako";
 /**
  * Extracts and parses XML content from an Excel worksheet file (e.g., xl/worksheets/sheet1.xml).
  * Handles both compressed (raw deflate) and uncompressed (plain XML) formats.
@@ -14,38 +14,32 @@ import { inflateRaw } from 'pako';
  */
 export function extractXmlFromSheet(buffer) {
     if (!buffer || buffer.length === 0) {
-        throw new Error('Empty buffer provided');
+        throw new Error("Empty buffer provided");
     }
     let xml;
     // Check if the buffer starts with an XML declaration (<?xml)
-    const startsWithXml = buffer.subarray(0, 5).toString('utf8').trim().startsWith('<?xml');
+    const startsWithXml = buffer.subarray(0, 5).toString("utf8").trim().startsWith("<?xml");
     if (startsWithXml) {
         // Case 1: Already uncompressed XML - convert directly to string
-        xml = buffer.toString('utf8');
+        xml = buffer.toString("utf8");
     }
     else {
         // Case 2: Attempt to decompress as raw deflate data
-        try {
-            const inflated = inflateRaw(buffer, { to: 'string' });
-            // Validate the decompressed content contains worksheet data
-            if (inflated && inflated.includes('<sheetData')) {
-                xml = inflated;
-            }
-            else {
-                throw new Error('Decompressed data does not contain sheetData');
-            }
+        const inflated = inflateRaw(buffer, { to: "string" });
+        // Validate the decompressed content contains worksheet data
+        if (inflated && inflated.includes("<sheetData")) {
+            xml = inflated;
         }
-        catch (e) {
-            console.error('Decompression failed:', e);
-            // Continue to fallback attempt
+        else {
+            throw new Error("Decompressed data does not contain sheetData");
         }
     }
     // Fallback: If no XML obtained yet, try direct UTF-8 conversion
     if (!xml) {
-        xml = buffer.toString('utf8');
+        xml = buffer.toString("utf8");
     }
     // Sanitize XML by removing control characters (except tab, newline, carriage return)
     // This handles potential corruption from binary data or encoding issues
-    xml = xml.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, '');
+    xml = xml.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, "");
     return xml;
 }

package/build/{lib → esm/lib}/xml/extract-xml-from-system-content.js

@@ -1,4 +1,4 @@
-import { inflateRaw } from 'pako';
+import { inflateRaw } from "pako";
 /**
  * Extracts and decompresses XML content from Excel system files (e.g., workbook.xml, [Content_Types].xml).
  * Handles both compressed (raw DEFLATE) and uncompressed (plain XML) formats with comprehensive error handling.
@@ -20,17 +20,17 @@ export const extractXmlFromSystemContent = (buffer, name) => {
     }
     let xml;
     // Check for XML declaration in first 5 bytes (<?xml)
-    const startsWithXml = buffer.subarray(0, 5).toString('utf8').trim().startsWith('<?xml');
+    const startsWithXml = buffer.subarray(0, 5).toString("utf8").trim().startsWith("<?xml");
     if (startsWithXml) {
         // Case 1: Already uncompressed XML - convert directly to string
-        xml = buffer.toString('utf8');
+        xml = buffer.toString("utf8");
     }
     else {
         // Case 2: Attempt DEFLATE decompression
         try {
-            const inflated = inflateRaw(buffer, { to: 'string' });
+            const inflated = inflateRaw(buffer, { to: "string" });
             // Validate decompressed content contains XML declaration
-            if (inflated && inflated.includes('<?xml')) {
+            if (inflated && inflated.includes("<?xml")) {
                 xml = inflated;
             }
             else {
@@ -38,12 +38,12 @@ export const extractXmlFromSystemContent = (buffer, name) => {
             }
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : 'Unknown error';
+            const message = error instanceof Error ? error.message : "Unknown error";
             throw new Error(`Failed to decompress ${name}: ${message}`);
         }
     }
     // Sanitize XML by removing illegal control characters (per XML 1.0 spec)
     // Preserves tabs (0x09), newlines (0x0A), and carriage returns (0x0D)
-    xml = xml.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, '');
+    xml = xml.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, "");
     return xml;
 };

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

@@ -0,0 +1,5 @@
+export * from "./build-merged-sheet.js";
+export * from "./extract-rows-from-sheet.js";
+export * from "./extract-xml-from-sheet.js";
+export * from "./extract-xml-from-system-content.js";
+export * from "./shift-row-indices.js";

package/build/{lib → esm/lib}/zip/constants.js

@@ -1,4 +1,4 @@
-import { Buffer } from 'node:buffer';
+import { Buffer } from "node:buffer";
 /**
  * ZIP file signature constants in Buffer format.
  * These magic numbers identify different sections of a ZIP file,
@@ -11,7 +11,7 @@ import { Buffer } from 'node:buffer';
  * Format: 'PK\01\02'
  * Found in the central directory that appears at the end of the ZIP file.
  */
-export const CENTRAL_DIR_HEADER_SIG = Buffer.from('504b0102', 'hex');
+export const CENTRAL_DIR_HEADER_SIG = Buffer.from("504b0102", "hex");
 /**
  * End of Central Directory Record signature (0x504b0506).
  * Marks the end of the central directory and contains global information
@@ -19,11 +19,11 @@ export const CENTRAL_DIR_HEADER_SIG = Buffer.from('504b0102', 'hex');
  * Format: 'PK\05\06'
  * This is the last record in a valid ZIP file.
  */
-export const END_OF_CENTRAL_DIR_SIG = Buffer.from('504b0506', 'hex');
+export const END_OF_CENTRAL_DIR_SIG = Buffer.from("504b0506", "hex");
 /**
  * Local File Header signature (0x504b0304).
  * Marks the beginning of a file entry within the ZIP archive.
  * Format: 'PK\03\04' (ASCII letters PK followed by version numbers)
  * Appears before each file's compressed data.
  */
-export const LOCAL_FILE_HEADER_SIG = Buffer.from('504b0304', 'hex');
+export const LOCAL_FILE_HEADER_SIG = Buffer.from("504b0304", "hex");

package/build/{lib/zip/create.js → esm/lib/zip/create-sync.js}

@@ -1,23 +1,23 @@
-import { Buffer } from 'node:buffer';
-import { deflateRawSync } from 'node:zlib';
-import { toBytes, dosTime, crc32 } from './utils.js';
-import { LOCAL_FILE_HEADER_SIG, CENTRAL_DIR_HEADER_SIG, END_OF_CENTRAL_DIR_SIG, } from './constants.js';
+import { Buffer } from "node:buffer";
+import { deflateRawSync } from "node:zlib";
+import { crc32, dosTime, toBytes } from "./utils.js";
+import { CENTRAL_DIR_HEADER_SIG, END_OF_CENTRAL_DIR_SIG, LOCAL_FILE_HEADER_SIG, } from "./constants.js";
 /**
  * Creates a ZIP archive from a collection of files.
  *
  * @param {Object.<string, Buffer|string>} files - An object with file paths as keys and either Buffer or string content as values.
  * @returns {Buffer} - The ZIP archive as a Buffer.
  */
-export function create(files) {
+export function createSync(files) {
     const fileEntries = [];
     const centralDirectory = [];
     let offset = 0;
     for (const [filename, rawContent] of Object.entries(files).sort(([a], [b]) => a.localeCompare(b))) {
-        if (filename.includes('..')) {
+        if (filename.includes("..")) {
             throw new Error(`Invalid filename: ${filename}`);
         }
         const content = Buffer.isBuffer(rawContent) ? rawContent : Buffer.from(rawContent);
-        const fileNameBuf = Buffer.from(filename, 'utf8');
+        const fileNameBuf = Buffer.from(filename, "utf8");
         const modTime = dosTime(new Date());
         const crc = crc32(content);
         const compressed = deflateRawSync(content);

package/build/esm/lib/zip/create.js

@@ -0,0 +1,82 @@
+import { Buffer } from "node:buffer";
+import util from "node:util";
+import zlib from "node:zlib";
+const deflateRaw = util.promisify(zlib.deflateRaw);
+import { crc32, dosTime, toBytes } from "./utils.js";
+import { CENTRAL_DIR_HEADER_SIG, END_OF_CENTRAL_DIR_SIG, LOCAL_FILE_HEADER_SIG, } from "./constants.js";
+/**
+ * Creates a ZIP archive from a collection of files.
+ *
+ * @param {Object.<string, Buffer|string>} files - An object with file paths as keys and either Buffer or string content as values.
+ * @returns {Buffer} - The ZIP archive as a Buffer.
+ */
+export async function create(files) {
+    const fileEntries = [];
+    const centralDirectory = [];
+    let offset = 0;
+    for (const [filename, rawContent] of Object.entries(files).sort(([a], [b]) => a.localeCompare(b))) {
+        if (filename.includes("..")) {
+            throw new Error(`Invalid filename: ${filename}`);
+        }
+        const content = Buffer.isBuffer(rawContent) ? rawContent : Buffer.from(rawContent);
+        const fileNameBuf = Buffer.from(filename, "utf8");
+        const modTime = dosTime(new Date());
+        const crc = crc32(content);
+        const compressed = await deflateRaw(content);
+        const compSize = compressed.length;
+        const uncompSize = content.length;
+        // Local file header
+        const localHeader = Buffer.concat([
+            LOCAL_FILE_HEADER_SIG,
+            toBytes(20, 2),
+            toBytes(0, 2),
+            toBytes(8, 2),
+            modTime,
+            toBytes(crc, 4),
+            toBytes(compSize, 4),
+            toBytes(uncompSize, 4),
+            toBytes(fileNameBuf.length, 2),
+            toBytes(0, 2),
+        ]);
+        const localEntry = Buffer.concat([
+            localHeader,
+            fileNameBuf,
+            compressed,
+        ]);
+        fileEntries.push(localEntry);
+        const centralEntry = Buffer.concat([
+            Buffer.from(CENTRAL_DIR_HEADER_SIG),
+            Buffer.from(toBytes(20, 2)), // Version made by
+            Buffer.from(toBytes(20, 2)), // Version needed
+            Buffer.from(toBytes(0, 2)), // Flags
+            Buffer.from(toBytes(8, 2)), // Compression
+            Buffer.from(modTime),
+            Buffer.from(toBytes(crc, 4)),
+            Buffer.from(toBytes(compSize, 4)),
+            Buffer.from(toBytes(uncompSize, 4)),
+            Buffer.from(toBytes(fileNameBuf.length, 2)),
+            Buffer.from(toBytes(0, 2)), // Extra field length
+            Buffer.from(toBytes(0, 2)), // Comment length
+            Buffer.from(toBytes(0, 2)), // Disk start
+            Buffer.from(toBytes(0, 2)), // Internal attrs
+            Buffer.from(toBytes(0, 4)), // External attrs
+            Buffer.from(toBytes(offset, 4)),
+            fileNameBuf,
+        ]);
+        centralDirectory.push(centralEntry);
+        offset += localEntry.length;
+    }
+    const centralDirSize = centralDirectory.reduce((sum, entry) => sum + entry.length, 0);
+    const centralDirOffset = offset;
+    const endRecord = Buffer.concat([
+        Buffer.from(END_OF_CENTRAL_DIR_SIG),
+        Buffer.from(toBytes(0, 2)), // Disk #
+        Buffer.from(toBytes(0, 2)), // Start disk #
+        Buffer.from(toBytes(centralDirectory.length, 2)),
+        Buffer.from(toBytes(centralDirectory.length, 2)),
+        Buffer.from(toBytes(centralDirSize, 4)),
+        Buffer.from(toBytes(centralDirOffset, 4)),
+        Buffer.from(toBytes(0, 2)), // Comment length
+    ]);
+    return Buffer.concat(fileEntries.concat(centralDirectory).concat([endRecord]));
+}

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

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