@js-ak/excel-toolbox 1.3.2 → 1.4.1

package/build/esm/lib/template/utils/validate-worksheet-xml.js

@@ -0,0 +1,228 @@
+/**
+ * Validates an Excel worksheet XML against the expected structure and rules.
+ *
+ * Checks the following:
+ * 1. XML starts with <?xml declaration
+ * 2. Root element is worksheet
+ * 3. Required elements are present
+ * 4. row numbers are in ascending order
+ * 5. No duplicate row numbers
+ * 6. No overlapping merge ranges
+ * 7. All cells are within the specified dimension
+ * 8. All mergeCell tags refer to existing cells
+ *
+ * @param xml The raw XML content of the worksheet
+ * @returns A ValidationResult object indicating if the XML is valid, and an error message if it's not
+ */
+export function validateWorksheetXml(xml) {
+    const createError = (message, details) => ({
+        error: { details, message },
+        isValid: false,
+    });
+    // 1. Check for XML declaration
+    if (!xml.startsWith("<?xml")) {
+        return createError("XML must start with <?xml> declaration");
+    }
+    if (!xml.includes("<worksheet") || !xml.includes("</worksheet>")) {
+        return createError("Root element worksheet not found");
+    }
+    // 2. Check for required elements
+    const requiredElements = [
+        { name: "sheetViews", tag: "<sheetViews>" },
+        { name: "sheetFormatPr", tag: "<sheetFormatPr" },
+        { name: "cols", tag: "<cols>" },
+        { name: "sheetData", tag: "<sheetData>" },
+        { name: "mergeCells", tag: "<mergeCells" },
+    ];
+    for (const { name, tag } of requiredElements) {
+        if (!xml.includes(tag)) {
+            return createError(`Missing required element ${name}`);
+        }
+    }
+    // 3. Extract and validate sheetData
+    const sheetDataStart = xml.indexOf("<sheetData>");
+    const sheetDataEnd = xml.indexOf("</sheetData>");
+    if (sheetDataStart === -1 || sheetDataEnd === -1) {
+        return createError("Invalid sheetData structure");
+    }
+    const sheetDataContent = xml.substring(sheetDataStart + 10, sheetDataEnd);
+    const rows = sheetDataContent.split("</row>");
+    if (rows.length < 2) {
+        return createError("SheetData should contain at least one row");
+    }
+    // Collect information about all rows and cells
+    const allRows = [];
+    const allCells = [];
+    let prevRowNum = 0;
+    for (const row of rows.slice(0, -1)) {
+        if (!row.includes("<row ")) {
+            return createError("Row tag not found", `Fragment: ${row.substring(0, 50)}...`);
+        }
+        if (!row.includes("<c ")) {
+            return createError("Row does not contain any cells", `Row: ${row.substring(0, 50)}...`);
+        }
+        // Extract row number
+        const rowNumMatch = row.match(/<row\s+r="(\d+)"/);
+        if (!rowNumMatch) {
+            return createError("Row number (attribute r) not specified", `Row: ${row.substring(0, 50)}...`);
+        }
+        const rowNum = parseInt(rowNumMatch[1]);
+        // Check for duplicate row numbers
+        if (allRows.includes(rowNum)) {
+            return createError("Duplicate row number found", `Row number: ${rowNum}`);
+        }
+        allRows.push(rowNum);
+        // Check row number order (should be in ascending order)
+        if (rowNum <= prevRowNum) {
+            return createError("Row order is broken", `Current row: ${rowNum}, previous: ${prevRowNum}`);
+        }
+        prevRowNum = rowNum;
+        // Extract all cells in the row
+        const cells = row.match(/<c\s+r="([A-Z]+)(\d+)"/g) || [];
+        for (const cell of cells) {
+            const match = cell.match(/<c\s+r="([A-Z]+)(\d+)"/);
+            if (!match) {
+                return createError("Invalid cell format", `Cell: ${cell}`);
+            }
+            const col = match[1];
+            const cellRowNum = parseInt(match[2]);
+            // Check row number match for each cell
+            if (cellRowNum !== rowNum) {
+                return createError("Row number mismatch in cell", `Expected: ${rowNum}, found: ${cellRowNum} in cell ${col}${cellRowNum}`);
+            }
+            allCells.push({
+                col,
+                row: rowNum,
+            });
+        }
+    }
+    // 4. Check mergeCells
+    const mergeCellsStart = xml.indexOf("<mergeCells");
+    const mergeCellsEnd = xml.indexOf("</mergeCells>");
+    if (mergeCellsStart === -1 || mergeCellsEnd === -1) {
+        return createError("Invalid mergeCells structure");
+    }
+    const mergeCellsContent = xml.substring(mergeCellsStart, mergeCellsEnd);
+    const countMatch = mergeCellsContent.match(/count="(\d+)"/);
+    if (!countMatch) {
+        return createError("Count attribute not specified for mergeCells");
+    }
+    const mergeCellTags = mergeCellsContent.match(/<mergeCell\s+ref="([A-Z]+\d+:[A-Z]+\d+)"\s*\/>/g);
+    if (!mergeCellTags) {
+        return createError("No merged cells found");
+    }
+    // Check if the number of mergeCells matches the count attribute
+    if (mergeCellTags.length !== parseInt(countMatch[1])) {
+        return createError("Mismatch in the number of merged cells", `Expected: ${countMatch[1]}, found: ${mergeCellTags.length}`);
+    }
+    // Check for duplicates of mergeCell
+    const mergeRefs = new Set();
+    const duplicates = new Set();
+    for (const mergeTag of mergeCellTags) {
+        const refMatch = mergeTag.match(/ref="([A-Z]+\d+:[A-Z]+\d+)"/);
+        if (!refMatch) {
+            return createError("Invalid merge cell format", `Tag: ${mergeTag}`);
+        }
+        const ref = refMatch[1];
+        if (mergeRefs.has(ref)) {
+            duplicates.add(ref);
+        }
+        else {
+            mergeRefs.add(ref);
+        }
+    }
+    if (duplicates.size > 0) {
+        return createError("Duplicates of merged cells found", `Duplicates: ${Array.from(duplicates).join(", ")}`);
+    }
+    // Check for overlapping merge ranges
+    const mergedRanges = Array.from(mergeRefs).map(ref => {
+        const [start, end] = ref.split(":");
+        return {
+            endCol: end.match(/[A-Z]+/)?.[0] || "",
+            endRow: parseInt(end.match(/\d+/)?.[0] || "0"),
+            startCol: start.match(/[A-Z]+/)?.[0] || "",
+            startRow: parseInt(start.match(/\d+/)?.[0] || "0"),
+        };
+    });
+    for (let i = 0; i < mergedRanges.length; i++) {
+        for (let j = i + 1; j < mergedRanges.length; j++) {
+            const a = mergedRanges[i];
+            const b = mergedRanges[j];
+            if (rangesIntersect(a, b)) {
+                return createError("Found intersecting merged cells", `Intersecting: ${getRangeString(a)} and ${getRangeString(b)}`);
+            }
+        }
+    }
+    // 5. Check dimension and match with real data
+    const dimensionMatch = xml.match(/<dimension\s+ref="([A-Z]+\d+:[A-Z]+\d+)"\s*\/>/);
+    if (!dimensionMatch) {
+        return createError("Data range (dimension) is not specified");
+    }
+    const [startCell, endCell] = dimensionMatch[1].split(":");
+    const startCol = startCell.match(/[A-Z]+/)?.[0];
+    const startRow = parseInt(startCell.match(/\d+/)?.[0] || "0");
+    const endCol = endCell.match(/[A-Z]+/)?.[0];
+    const endRow = parseInt(endCell.match(/\d+/)?.[0] || "0");
+    if (!startCol || !endCol || isNaN(startRow) || isNaN(endRow)) {
+        return createError("Invalid dimension format", `Dimension: ${dimensionMatch[1]}`);
+    }
+    const startColNum = colToNumber(startCol);
+    const endColNum = colToNumber(endCol);
+    // Check if all cells are within the dimension
+    for (const cell of allCells) {
+        const colNum = colToNumber(cell.col);
+        if (cell.row < startRow || cell.row > endRow) {
+            return createError("Cell is outside the specified area (by row)", `Cell: ${cell.col}${cell.row}, dimension: ${dimensionMatch[1]}`);
+        }
+        if (colNum < startColNum || colNum > endColNum) {
+            return createError("Cell is outside the specified area (by column)", `Cell: ${cell.col}${cell.row}, dimension: ${dimensionMatch[1]}`);
+        }
+    }
+    // 6. Additional check: all mergeCell tags refer to existing cells
+    for (const mergeTag of mergeCellTags) {
+        const refMatch = mergeTag.match(/ref="([A-Z]+\d+:[A-Z]+\d+)"/);
+        if (!refMatch) {
+            return createError("Invalid merge cell format", `Tag: ${mergeTag}`);
+        }
+        const [cell1, cell2] = refMatch[1].split(":");
+        const cell1Col = cell1.match(/[A-Z]+/)?.[0];
+        const cell1Row = parseInt(cell1.match(/\d+/)?.[0] || "0");
+        const cell2Col = cell2.match(/[A-Z]+/)?.[0];
+        const cell2Row = parseInt(cell2.match(/\d+/)?.[0] || "0");
+        if (!cell1Col || !cell2Col || isNaN(cell1Row) || isNaN(cell2Row)) {
+            return createError("Invalid merged cell coordinates", `Merged cells: ${refMatch[1]}`);
+        }
+        // Check if the merged cells exist
+        const cell1Exists = allCells.some(c => c.row === cell1Row && c.col === cell1Col);
+        const cell2Exists = allCells.some(c => c.row === cell2Row && c.col === cell2Col);
+        if (!cell1Exists || !cell2Exists) {
+            return createError("Merged cell reference points to non-existent cells", `Merged cells: ${refMatch[1]}, missing: ${!cell1Exists ? `${cell1Col}${cell1Row}` : `${cell2Col}${cell2Row}`}`);
+        }
+    }
+    return { isValid: true };
+}
+// A function to check if two ranges intersect
+function rangesIntersect(a, b) {
+    const aStartColNum = colToNumber(a.startCol);
+    const aEndColNum = colToNumber(a.endCol);
+    const bStartColNum = colToNumber(b.startCol);
+    const bEndColNum = colToNumber(b.endCol);
+    // Check if the rows intersect
+    const rowsIntersect = !(a.endRow < b.startRow || a.startRow > b.endRow);
+    // Check if the columns intersect
+    const colsIntersect = !(aEndColNum < bStartColNum || aStartColNum > bEndColNum);
+    return rowsIntersect && colsIntersect;
+}
+// Function to get the range string1
+function getRangeString(range) {
+    return `${range.startCol}${range.startRow}:${range.endCol}${range.endRow}`;
+}
+// Function to convert column letters to numbers
+function colToNumber(col) {
+    let num = 0;
+    for (let i = 0; i < col.length; i++) {
+        num = num * 26 + (col.charCodeAt(i) - 64);
+    }
+    return num;
+}
+;

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

@@ -1,4 +1,5 @@
 import { columnIndexToLetter } from "./column-index-to-letter.js";
+import { escapeXml } from "./escape-xml.js";
 /**
  * Writes an async iterable of rows to an Excel XML file.
  *
@@ -27,7 +28,7 @@ export async function writeRowsToStream(output, rows, startRowNumber) {
         const cells = row.map((value, colIndex) => {
             const colLetter = columnIndexToLetter(colIndex);
             const cellRef = `${colLetter}${rowNumber}`;
-            const cellValue = String(value ?? "");
+            const cellValue = escapeXml(String(value ?? ""));
             return `<c r="${cellRef}" t="inlineStr"><is><t>${cellValue}</t></is></c>`;
         });
         // Write the row to the file

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

@@ -52,9 +52,9 @@ export async function createWithStream(fileKeys, destination, output) {
         });
         const collectCompressed = new PassThrough();
         collectCompressed.on("data", chunk => {
-            // 		// Count compressed bytes
+            // Count compressed bytes
             compSize += chunk.length;
-            // 		// Save compressed chunk
+            // Save compressed chunk
             compressedChunks.push(chunk);
         });
         // Run all transforms in pipeline: read -> count size -> CRC -> deflate -> collect compressed

package/build/types/lib/template/template-fs.d.ts

@@ -29,6 +29,30 @@ export declare class TemplateFs {
      * @experimental This API is experimental and might change in future versions.
      */
     constructor(fileKeys: Set<string>, destination: string);
+    /**
+     * Copies a sheet from the template to a new name.
+     *
+     * @param {string} sourceName - The name of the sheet to copy.
+     * @param {string} newName - The new name for the sheet.
+     * @returns {Promise<void>}
+     * @throws {Error} If the sheet with the source name does not exist.
+     * @throws {Error} If a sheet with the new name already exists.
+     * @experimental This API is experimental and might change in future versions.
+     */
+    copySheet(sourceName: string, newName: string): Promise<void>;
+    /**
+     * Replaces placeholders in the given sheet with values from the replacements map.
+     *
+     * The function searches for placeholders in the format `${key}` within the sheet
+     * content, where `key` corresponds to a path in the replacements object.
+     * If a value is found for the key, it replaces the placeholder with the value.
+     * If no value is found, the original placeholder remains unchanged.
+     *
+     * @param sheetName - The name of the sheet to be replaced.
+     * @param replacements - An object where keys represent placeholder paths and values are the replacements.
+     * @returns A promise that resolves when the substitution is complete.
+     */
+    substitute(sheetName: string, replacements: Record<string, unknown>): Promise<void>;
     /**
      * Inserts rows into a specific sheet in the template.
      *

package/build/types/lib/template/utils/apply-replacements.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Replaces placeholders in the given content string with values from the replacements map.
+ *
+ * The function searches for placeholders in the format `${key}` within the content
+ * string, where `key` corresponds to a path in the replacements object.
+ * If a value is found for the key, it replaces the placeholder with the value.
+ * If no value is found, the original placeholder remains unchanged.
+ *
+ * @param content - The string containing placeholders to be replaced.
+ * @param replacements - An object where keys represent placeholder paths and values are the replacements.
+ * @returns A new string with placeholders replaced by corresponding values from the replacements object.
+ */
+export declare const applyReplacements: (content: string, replacements: Record<string, unknown>) => string;

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

@@ -1,14 +1,9 @@
 /**
- * Validates that each key in the given row object is a valid cell reference.
+ * Validates an object representing a single row of data to ensure that its keys
+ * are valid Excel column references. Throws an error if any of the keys are
+ * invalid.
  *
- * 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.
+ * @param row An object with string keys that represent the cell references and
+ * string values that represent the values of those cells.
  */
 export declare function checkRow(row: Record<string, string>): void;

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

@@ -1,7 +1,15 @@
 /**
- * Converts a 0-based column index to an Excel-style letter (A, B, ..., Z, AA, AB, ...).
+ * Converts a zero-based column index to its corresponding Excel column letter.
  *
- * @param index - The 0-based column index.
- * @returns The Excel-style letter for the given column index.
+ * @throws Will throw an error if the input is not a positive integer.
+ * @param {number} index - The zero-based index of the column to convert.
+ * @returns {string} The corresponding Excel column letter.
+ *
+ * @example
+ * columnIndexToLetter(0); // returns "A"
+ * columnIndexToLetter(25); // returns "Z"
+ * columnIndexToLetter(26); // returns "AA"
+ * columnIndexToLetter(51); // returns "AZ"
+ * columnIndexToLetter(52); // returns "BA"
  */
 export declare function columnIndexToLetter(index: number): string;

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

@@ -0,0 +1,14 @@
+/**
+ * Extracts the XML declaration from a given XML string.
+ *
+ * The XML declaration is a string that looks like `<?xml ...?>` and is usually
+ * present at the beginning of an XML file. It contains information about the
+ * XML version, encoding, and standalone status.
+ *
+ * This function returns `null` if the input string does not have a valid XML
+ * declaration.
+ *
+ * @param xmlString - The XML string to extract the declaration from.
+ * @returns The extracted XML declaration string, or `null`.
+ */
+export declare function extractXmlDeclaration(xmlString: string): string | null;

package/build/types/lib/template/utils/get-by-path.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Gets a value from an object by a given path.
+ *
+ * @param obj - The object to search.
+ * @param path - The path to the value, separated by dots.
+ * @returns The value at the given path, or undefined if not found.
+ */
+export declare function getByPath(obj: unknown, path: string): unknown;

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

@@ -1,11 +1,20 @@
+export * from "./apply-replacements.js";
 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 "./extract-xml-declaration.js";
+export * from "./get-by-path.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 "./process-merge-cells.js";
+export * from "./process-merge-finalize.js";
+export * from "./process-rows.js";
+export * from "./process-shared-strings.js";
 export * from "./to-excel-column-object.js";
+export * from "./update-dimension.js";
+export * from "./validate-worksheet-xml.js";
 export * from "./write-rows-to-stream.js";

package/build/types/lib/template/utils/process-merge-cells.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Processes the sheet XML by extracting the initial <mergeCells> block and
+ * extracting all merge cell references. The function returns an object with
+ * three properties:
+ * - `initialMergeCells`: The initial <mergeCells> block as a string array.
+ * - `mergeCellMatches`: An array of objects with `from` and `to` properties,
+ *   representing the merge cell references.
+ * - `modifiedXml`: The modified sheet XML with the <mergeCells> block removed.
+ *
+ * @param sheetXml - The sheet XML string.
+ * @returns An object with the above three properties.
+ */
+export declare function processMergeCells(sheetXml: string): {
+    initialMergeCells: string[];
+    mergeCellMatches: {
+        from: string;
+        to: string;
+    }[];
+    modifiedXml: string;
+};

package/build/types/lib/template/utils/process-merge-finalize.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Finalizes the processing of the merged sheet by updating the merge cells and
+ * inserting them into the sheet XML. It also returns the modified sheet XML and
+ * shared strings.
+ *
+ * @param {object} data - An object containing the following properties:
+ *   - `initialMergeCells`: The initial merge cells from the original sheet.
+ *   - `lastIndex`: The last processed position in the sheet XML.
+ *   - `mergeCellMatches`: An array of objects with `from` and `to` properties,
+ *     describing the merge cells.
+ *   - `resultRows`: An array of processed XML rows.
+ *   - `rowShift`: The total row shift.
+ *   - `sharedStrings`: An array of shared strings.
+ *   - `sharedStringsHeader`: The XML declaration of the shared strings.
+ *   - `sheetMergeCells`: An array of merge cell XML strings.
+ *   - `sheetXml`: The original sheet XML string.
+ *
+ * @returns An object with two properties:
+ *   - `shared`: The modified shared strings XML string.
+ *   - `sheet`: The modified sheet XML string with updated merge cells.
+ */
+export declare function processMergeFinalize(data: {
+    initialMergeCells: string[];
+    lastIndex: number;
+    mergeCellMatches: {
+        from: string;
+        to: string;
+    }[];
+    resultRows: string[];
+    rowShift: number;
+    sharedStrings: string[];
+    sharedStringsHeader: string | null;
+    sheetMergeCells: string[];
+    sheetXml: string;
+}): {
+    shared: string;
+    sheet: string;
+};

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

@@ -0,0 +1,31 @@
+/**
+ * Processes a sheet XML by replacing table placeholders with real data and adjusting row numbers accordingly.
+ *
+ * @param data - An object containing the following properties:
+ *   - `replacements`: An object where keys are table names and values are arrays of objects with table data.
+ *   - `sharedIndexMap`: A Map of shared string indexes by their text content.
+ *   - `mergeCellMatches`: An array of objects with `from` and `to` properties, describing the merge cells.
+ *   - `sharedStrings`: An array of shared strings.
+ *   - `sheetMergeCells`: An array of merge cell XML strings.
+ *   - `sheetXml`: The sheet XML string.
+ *
+ * @returns An object with the following properties:
+ *   - `lastIndex`: The last processed position in the sheet XML.
+ *   - `resultRows`: An array of processed XML rows.
+ *   - `rowShift`: The total row shift.
+ */
+export declare function processRows(data: {
+    replacements: Record<string, unknown>;
+    sharedIndexMap: Map<string, number>;
+    mergeCellMatches: {
+        from: string;
+        to: string;
+    }[];
+    sharedStrings: string[];
+    sheetMergeCells: string[];
+    sheetXml: string;
+}): {
+    lastIndex: number;
+    resultRows: string[];
+    rowShift: number;
+};

package/build/types/lib/template/utils/process-shared-strings.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Processes the shared strings XML by extracting the XML declaration,
+ * extracting individual <si> elements, and storing them in an array.
+ *
+ * The function returns an object with four properties:
+ * - sharedIndexMap: A map of shared string content to their corresponding index
+ * - sharedStrings: An array of shared strings
+ * - sharedStringsHeader: The XML declaration of the shared strings
+ * - sheetMergeCells: An empty array, which is only used for type compatibility
+ *                    with the return type of processBuild.
+ *
+ * @param sharedStringsXml - The XML string of the shared strings
+ * @returns An object with the four properties above
+ */
+export declare function processSharedStrings(sharedStringsXml: string): {
+    sharedIndexMap: Map<string, number>;
+    sharedStrings: string[];
+    sharedStringsHeader: string | null;
+    sheetMergeCells: string[];
+};

package/build/types/lib/template/utils/update-dimension.d.ts

@@ -0,0 +1 @@
+export declare function updateDimension(xml: string): string;

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

@@ -0,0 +1,25 @@
+interface ValidationResult {
+    isValid: boolean;
+    error?: {
+        message: string;
+        details?: string;
+    };
+}
+/**
+ * Validates an Excel worksheet XML against the expected structure and rules.
+ *
+ * Checks the following:
+ * 1. XML starts with <?xml declaration
+ * 2. Root element is worksheet
+ * 3. Required elements are present
+ * 4. row numbers are in ascending order
+ * 5. No duplicate row numbers
+ * 6. No overlapping merge ranges
+ * 7. All cells are within the specified dimension
+ * 8. All mergeCell tags refer to existing cells
+ *
+ * @param xml The raw XML content of the worksheet
+ * @returns A ValidationResult object indicating if the XML is valid, and an error message if it's not
+ */
+export declare function validateWorksheetXml(xml: string): ValidationResult;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@js-ak/excel-toolbox",
-  "version": "1.3.2",
+  "version": "1.4.1",
   "description": "excel-toolbox",
   "publishConfig": {
     "access": "public",
@@ -38,13 +38,14 @@
     "package.json"
   ],
   "scripts": {
-    "build": "npm run build:cjs && npm run build:esm && npm run postbuild:esm && npm run postbuild:cjs",
+    "build": "npm run build:cjs && npm run build:esm && npm run postbuild:cjs && npm run postbuild:esm",
     "build:esm": "tsc -p tsconfig.esm.json",
     "build:cjs": "tsc -p tsconfig.cjs.json",
     "lint": "eslint . --ext .ts",
     "postbuild:esm": "node scripts/write-esm-package.js",
     "postbuild:cjs": "node scripts/write-cjs-package.js",
-    "test": "npm run build && node ./build/esm/test/index.js"
+    "test": "vitest run",
+    "test:watch": "vitest"
   },
   "repository": {
     "type": "git",
@@ -75,7 +76,8 @@
     "globals": "16.0.0",
     "semantic-release": "24.0.0",
     "typescript": "5.8.3",
-    "typescript-eslint": "8.29.0"
+    "typescript-eslint": "8.29.0",
+    "vitest": "3.1.1"
   },
   "dependencies": {
     "pako": "2.1.0"