@js-ak/excel-toolbox 1.1.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/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

@@ -29,7 +29,7 @@ export function extractRowsFromSheet(sheet) {
     }
     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

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/zip/create.js → esm/lib/zip/create-sync.js}

@@ -8,7 +8,7 @@ import { CENTRAL_DIR_HEADER_SIG, END_OF_CENTRAL_DIR_SIG, LOCAL_FILE_HEADER_SIG,
  * @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;

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

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

@@ -6,7 +6,7 @@ import { inflateRawSync } from "node:zlib";
  * @returns {Object.<string, string>} - An object where keys are file names and values are file contents.
  * @throws {Error} - Throws an error if an unsupported compression method is encountered or if decompression fails.
  */
-export function read(buffer) {
+export function readSync(buffer) {
     const files = {};
     let offset = 0;
     while (offset + 4 <= buffer.length) {

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

@@ -0,0 +1,55 @@
+import util from "node:util";
+import zlib from "node:zlib";
+const inflateRaw = util.promisify(zlib.inflateRaw);
+/**
+ * Parses a ZIP archive from a buffer and extracts the files within.
+ *
+ * @param {Buffer} buffer - The buffer containing the ZIP archive data.
+ * @returns {Object.<string, string>} - An object where keys are file names and values are file contents.
+ * @throws {Error} - Throws an error if an unsupported compression method is encountered or if decompression fails.
+ */
+export async function read(buffer) {
+    const files = {};
+    let offset = 0;
+    while (offset + 4 <= buffer.length) {
+        const signature = buffer.readUInt32LE(offset);
+        if (signature !== 0x04034b50)
+            break;
+        const compressionMethod = buffer.readUInt16LE(offset + 8);
+        const fileNameLength = buffer.readUInt16LE(offset + 26);
+        const extraLength = buffer.readUInt16LE(offset + 28);
+        const fileNameStart = offset + 30;
+        const fileNameEnd = fileNameStart + fileNameLength;
+        const fileName = buffer.subarray(fileNameStart, fileNameEnd).toString();
+        const dataStart = fileNameEnd + extraLength;
+        let nextOffset = dataStart;
+        while (nextOffset + 4 <= buffer.length) {
+            if (buffer.readUInt32LE(nextOffset) === 0x04034b50)
+                break;
+            nextOffset++;
+        }
+        if (nextOffset + 4 > buffer.length) {
+            nextOffset = buffer.length;
+        }
+        const compressedData = buffer.subarray(dataStart, nextOffset);
+        let content = "";
+        try {
+            if (compressionMethod === 0) {
+                content = compressedData.toString();
+            }
+            else if (compressionMethod === 8) {
+                content = (await inflateRaw(new Uint8Array(compressedData))).toString();
+            }
+            else {
+                throw new Error(`Unsupported compression method ${compressionMethod}`);
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Unknown error";
+            throw new Error(`Error unpacking file ${fileName}: ${message}`);
+        }
+        files[fileName] = content;
+        offset = nextOffset;
+    }
+    return files;
+}

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

@@ -1,4 +1,4 @@
-import { Buffer } from "buffer";
+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:

package/build/esm/test/index.js

@@ -0,0 +1,5 @@
+import assert from "node:assert";
+import test from "node:test";
+test("test", () => {
+    assert.equal(true, true);
+});

package/build/types/index.d.ts

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

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

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

package/build/types/lib/merge-sheets-to-base-file-process.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 declare function mergeSheetsToBaseFileProcess(data: {
+    additions: {
+        files: Record<string, string>;
+        sheetIndexes: number[];
+    }[];
+    baseFiles: Record<string, string>;
+    baseSheetIndex: number;
+    gap: number;
+    sheetNamesToRemove: string[];
+    sheetsToRemove: number[];
+}): void;

package/build/{lib/merge-sheets-to-base-file.d.ts → types/lib/merge-sheets-to-base-file-sync.d.ts}

@@ -7,18 +7,19 @@
  * @param {Object} data
  * @param {Object[]} data.additions
  * @param {Buffer} data.additions.file - The file to extract rows from
- * @param {number} data.additions.sheetIndex - The 1-based index of the sheet 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=1] - The number of empty rows to insert between each added section
+ * @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 declare function mergeSheetsToBaseFile(data: {
+export declare function mergeSheetsToBaseFileSync(data: {
     additions: {
         file: Buffer;
-        sheetIndex: number;
+        isBaseFile?: boolean;
+        sheetIndexes: number[];
     }[];
     baseFile: Buffer;
     baseSheetIndex?: number;
@@ -26,4 +27,3 @@ export declare function mergeSheetsToBaseFile(data: {
     sheetNamesToRemove?: string[];
     sheetsToRemove?: number[];
 }): Buffer;
-//# sourceMappingURL=merge-sheets-to-base-file.d.ts.map

package/build/types/lib/merge-sheets-to-base-file.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/**
+ * 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 declare function mergeSheetsToBaseFile(data: {
+    additions: {
+        file: Buffer;
+        isBaseFile?: boolean;
+        sheetIndexes: number[];
+    }[];
+    baseFile: Buffer;
+    baseSheetIndex?: number;
+    gap?: number;
+    sheetNamesToRemove?: string[];
+    sheetsToRemove?: number[];
+}): Promise<Buffer>;

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

@@ -0,0 +1,6 @@
+/**
+ * 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 declare function getMaxRowNumber(rows: string[]): number;

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

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