@cj-tech-master/excelts 1.6.3 → 2.0.0

package/dist/cjs/utils/shared-formula.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.slideFormula = slideFormula;
-const col_cache_js_1 = require("./col-cache");
+const col_cache_1 = require("./col-cache");
 // const cellRefRegex = /(([a-z_\-0-9]*)!)?[$]?([a-z]+)[$]?([1-9][0-9]*)/i;
 const replacementCandidateRx = /(([a-z_\-0-9]*)!)?([a-z0-9_$]{2,})([(])?/gi;
 const CRrx = /^([$])?([a-z]+)([$])?([1-9][0-9]*)$/i;
 function slideFormula(formula, fromCell, toCell) {
-    const offset = col_cache_js_1.colCache.decode(fromCell);
-    const to = col_cache_js_1.colCache.decode(toCell);
+    const offset = col_cache_1.colCache.decode(fromCell);
+    const to = col_cache_1.colCache.decode(toCell);
     return formula.replace(replacementCandidateRx, (refMatch, sheet, sheetMaybe, addrPart, trailingParen) => {
         if (trailingParen) {
             return refMatch;
@@ -22,7 +22,7 @@ function slideFormula(formula, fromCell, toCell) {
                 // > XFD is the highest col number in excel 2007 and beyond, so this is a named range
                 return refMatch;
             }
-            let col = col_cache_js_1.colCache.l2n(colStr);
+            let col = col_cache_1.colCache.l2n(colStr);
             let row = parseInt(rowStr, 10);
             if (!colDollar) {
                 col += to.col - offset.col;
@@ -30,7 +30,7 @@ function slideFormula(formula, fromCell, toCell) {
             if (!rowDollar) {
                 row += to.row - offset.row;
             }
-            const res = (sheet || "") + (colDollar || "") + col_cache_js_1.colCache.n2l(col) + (rowDollar || "") + row;
+            const res = (sheet || "") + (colDollar || "") + col_cache_1.colCache.n2l(col) + (rowDollar || "") + row;
             return res;
         }
         return refMatch;

package/dist/cjs/utils/sheet-utils.js

@@ -22,9 +22,9 @@ exports.bookAppendSheet = bookAppendSheet;
 exports.aoaToSheet = aoaToSheet;
 exports.sheetAddAoa = sheetAddAoa;
 exports.sheetToAoa = sheetToAoa;
-const workbook_js_1 = require("../doc/workbook");
-const col_cache_js_1 = require("./col-cache");
-const cell_format_js_1 = require("./cell-format");
+const workbook_1 = require("../doc/workbook");
+const col_cache_1 = require("./col-cache");
+const cell_format_1 = require("./cell-format");
 /**
  * Convert a Date object back to Excel serial number without timezone issues.
  * This reverses the excelToDate conversion exactly.
@@ -113,15 +113,15 @@ function formatValue(value, fmt, dateFormat) {
             if (serial < 0) {
                 serial += 1;
             }
-            return (0, cell_format_js_1.format)(fmt, serial);
+            return (0, cell_format_1.format)(fmt, serial);
         }
         // Only apply dateFormat override to actual date formats
         // (not elapsed time formats like [h]:mm:ss)
         const actualFmt = dateFormat && isDateFormat(fmt) ? dateFormat : fmt;
-        return (0, cell_format_js_1.format)(actualFmt, serial);
+        return (0, cell_format_1.format)(actualFmt, serial);
     }
     // Number/Boolean/String - let cellFormat handle it
-    return (0, cell_format_js_1.format)(fmt, value);
+    return (0, cell_format_1.format)(fmt, value);
 }
 /**
  * Get formatted display text for a cell value
@@ -170,14 +170,14 @@ function getCellDisplayText(cell, dateFormat) {
  * @example decodeCol("A") => 0, decodeCol("Z") => 25, decodeCol("AA") => 26
  */
 function decodeCol(colstr) {
-    return col_cache_js_1.colCache.l2n(colstr.toUpperCase()) - 1;
+    return col_cache_1.colCache.l2n(colstr.toUpperCase()) - 1;
 }
 /**
  * Encode 0-indexed column number to string
  * @example encodeCol(0) => "A", encodeCol(25) => "Z", encodeCol(26) => "AA"
  */
 function encodeCol(col) {
-    return col_cache_js_1.colCache.n2l(col + 1);
+    return col_cache_1.colCache.n2l(col + 1);
 }
 /**
  * Decode row string to 0-indexed number
@@ -198,7 +198,7 @@ function encodeRow(row) {
  * @example decodeCell("A1") => {c: 0, r: 0}, decodeCell("B2") => {c: 1, r: 1}
  */
 function decodeCell(cstr) {
-    const addr = col_cache_js_1.colCache.decodeAddress(cstr.toUpperCase());
+    const addr = col_cache_1.colCache.decodeAddress(cstr.toUpperCase());
     return { c: addr.col - 1, r: addr.row - 1 };
 }
 /**
@@ -206,7 +206,7 @@ function decodeCell(cstr) {
  * @example encodeCell({c: 0, r: 0}) => "A1", encodeCell({c: 1, r: 1}) => "B2"
  */
 function encodeCell(cell) {
-    return col_cache_js_1.colCache.encodeAddress(cell.r + 1, cell.c + 1);
+    return col_cache_1.colCache.encodeAddress(cell.r + 1, cell.c + 1);
 }
 /**
  * Decode range string to Range object
@@ -241,7 +241,7 @@ function encodeRange(startOrRange, end) {
 function jsonToSheet(data, opts) {
     const o = opts || {};
     // Create a temporary workbook to get a worksheet
-    const tempWb = new workbook_js_1.Workbook();
+    const tempWb = new workbook_1.Workbook();
     const worksheet = tempWb.addWorksheet("Sheet1");
     if (data.length === 0) {
         return worksheet;
@@ -573,7 +573,7 @@ function sheetToCsv(worksheet, opts) {
  * Create a new workbook
  */
 function bookNew() {
-    return new workbook_js_1.Workbook();
+    return new workbook_1.Workbook();
 }
 /**
  * Append worksheet to workbook (xlsx compatible)
@@ -610,7 +610,7 @@ function bookAppendSheet(workbook, worksheet, name) {
  * const ws = aoaToSheet([["Name", "Age"], ["Alice", 30], ["Bob", 25]])
  */
 function aoaToSheet(data, opts) {
-    const tempWb = new workbook_js_1.Workbook();
+    const tempWb = new workbook_1.Workbook();
     const worksheet = tempWb.addWorksheet("Sheet1");
     if (data.length === 0) {
         return worksheet;

package/dist/cjs/utils/stream-buf.browser.js

@@ -0,0 +1,355 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamBuf = void 0;
+const string_buf_1 = require("./string-buf");
+// =============================================================================
+// Data chunks - encapsulating incoming data
+class StringChunk {
+    constructor(data, encoding) {
+        this._data = data;
+        this._encoding = encoding;
+    }
+    get length() {
+        return this.toBuffer().length;
+    }
+    copy(target, targetOffset, offset, length) {
+        const buf = this.toBuffer();
+        const bytesToCopy = Math.min(length, buf.length - offset);
+        target.set(buf.subarray(offset, offset + bytesToCopy), targetOffset);
+        return bytesToCopy;
+    }
+    toBuffer() {
+        if (!this._buffer) {
+            this._buffer = new TextEncoder().encode(this._data);
+        }
+        return this._buffer;
+    }
+}
+class StringBufChunk {
+    constructor(data) {
+        this._data = data;
+    }
+    get length() {
+        return this._data.length;
+    }
+    copy(target, targetOffset, offset, length) {
+        const buf = this.toBuffer();
+        const bytesToCopy = Math.min(length, buf.length - offset);
+        target.set(buf.subarray(offset, offset + bytesToCopy), targetOffset);
+        return bytesToCopy;
+    }
+    toBuffer() {
+        return this._data.toBuffer();
+    }
+}
+class BufferChunk {
+    constructor(data) {
+        this._data = data;
+    }
+    get length() {
+        return this._data.length;
+    }
+    copy(target, targetOffset, offset, length) {
+        const bytesToCopy = Math.min(length, this._data.length - offset);
+        target.set(this._data.subarray(offset, offset + bytesToCopy), targetOffset);
+    }
+    toBuffer() {
+        return this._data;
+    }
+}
+// =============================================================================
+// ReadWriteBuf - a single buffer supporting simple read-write
+class ReadWriteBuf {
+    constructor(size) {
+        this.size = size;
+        this.buffer = new Uint8Array(size);
+        this.iRead = 0;
+        this.iWrite = 0;
+    }
+    toBuffer() {
+        if (this.iRead === 0 && this.iWrite === this.size) {
+            return this.buffer;
+        }
+        return this.buffer.slice(this.iRead, this.iWrite);
+    }
+    get length() {
+        return this.iWrite - this.iRead;
+    }
+    get eod() {
+        return this.iRead === this.iWrite;
+    }
+    get full() {
+        return this.iWrite === this.size;
+    }
+    read(size) {
+        if (size === 0) {
+            return null;
+        }
+        if (size === undefined || size >= this.length) {
+            const buf = this.toBuffer();
+            this.iRead = this.iWrite;
+            return buf;
+        }
+        const buf = this.buffer.slice(this.iRead, this.iRead + size);
+        this.iRead += size;
+        return buf;
+    }
+    write(chunk, offset, length) {
+        const size = Math.min(length, this.size - this.iWrite);
+        chunk.copy(this.buffer, this.iWrite, offset, offset + size);
+        this.iWrite += size;
+        return size;
+    }
+}
+// =============================================================================
+// StreamBuf - Browser version without Node.js stream dependency
+// A simple buffer manager that mimics stream behavior for xlsx writing
+class StreamBuf {
+    constructor(options) {
+        options = options || {};
+        this.bufSize = options.bufSize || 1024 * 1024;
+        this.buffers = [];
+        this.batch = options.batch || false;
+        this.corked = false;
+        this.paused = false;
+        this.encoding = null;
+        this.pipes = [];
+        this.events = new Map();
+    }
+    // Event emitter methods
+    on(event, callback) {
+        const callbacks = this.events.get(event) || [];
+        callbacks.push(callback);
+        this.events.set(event, callbacks);
+        return this;
+    }
+    once(event, callback) {
+        const onceCallback = (...args) => {
+            this.off(event, onceCallback);
+            callback(...args);
+        };
+        return this.on(event, onceCallback);
+    }
+    off(event, callback) {
+        const callbacks = this.events.get(event) || [];
+        const index = callbacks.indexOf(callback);
+        if (index !== -1) {
+            callbacks.splice(index, 1);
+        }
+        return this;
+    }
+    emit(event, ...args) {
+        const callbacks = this.events.get(event) || [];
+        callbacks.forEach(cb => cb(...args));
+        return callbacks.length > 0;
+    }
+    removeListener(event, callback) {
+        return this.off(event, callback);
+    }
+    toBuffer() {
+        switch (this.buffers.length) {
+            case 0:
+                return null;
+            case 1:
+                return this.buffers[0].toBuffer();
+            default: {
+                const totalLength = this.buffers.reduce((acc, buf) => acc + buf.length, 0);
+                const result = new Uint8Array(totalLength);
+                let offset = 0;
+                for (const rwBuf of this.buffers) {
+                    const buf = rwBuf.toBuffer();
+                    result.set(buf, offset);
+                    offset += buf.length;
+                }
+                return result;
+            }
+        }
+    }
+    _getWritableBuffer() {
+        if (this.buffers.length) {
+            const last = this.buffers[this.buffers.length - 1];
+            if (!last.full) {
+                return last;
+            }
+        }
+        const buf = new ReadWriteBuf(this.bufSize);
+        this.buffers.push(buf);
+        return buf;
+    }
+    async _pipe(chunk) {
+        const write = (pipe) => {
+            return new Promise(resolve => {
+                pipe.write(chunk.toBuffer(), () => {
+                    resolve();
+                });
+            });
+        };
+        await Promise.all(this.pipes.map(write));
+    }
+    _writeToBuffers(chunk) {
+        let inPos = 0;
+        const inLen = chunk.length;
+        while (inPos < inLen) {
+            const buffer = this._getWritableBuffer();
+            inPos += buffer.write(chunk, inPos, inLen - inPos);
+        }
+    }
+    async write(data, encoding, callback) {
+        const nop = () => { };
+        if (encoding instanceof Function) {
+            callback = encoding;
+            encoding = "utf8";
+        }
+        callback = callback || nop;
+        let chunk;
+        if (data instanceof string_buf_1.StringBuf || (data && data.constructor?.name === "StringBuf")) {
+            chunk = new StringBufChunk(data);
+        }
+        else if (data instanceof Uint8Array) {
+            chunk = new BufferChunk(data);
+        }
+        else if (ArrayBuffer.isView(data)) {
+            chunk = new BufferChunk(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+        }
+        else if (data instanceof ArrayBuffer) {
+            chunk = new BufferChunk(new Uint8Array(data));
+        }
+        else if (typeof data === "string" || data instanceof String) {
+            chunk = new StringChunk(String(data), encoding);
+        }
+        else {
+            throw new Error("Chunk must be one of type String, Uint8Array, ArrayBuffer or StringBuf.");
+        }
+        if (this.pipes.length) {
+            if (this.batch) {
+                this._writeToBuffers(chunk);
+                while (!this.corked && this.buffers.length > 1) {
+                    await this._pipe(new BufferChunk(this.buffers.shift().toBuffer()));
+                }
+            }
+            else if (!this.corked) {
+                await this._pipe(chunk);
+                callback();
+            }
+            else {
+                this._writeToBuffers(chunk);
+                queueMicrotask(() => callback());
+            }
+        }
+        else {
+            if (!this.paused) {
+                this.emit("data", chunk.toBuffer());
+            }
+            this._writeToBuffers(chunk);
+            this.emit("readable");
+        }
+        return true;
+    }
+    cork() {
+        this.corked = true;
+    }
+    _flush() {
+        if (this.pipes.length) {
+            while (this.buffers.length) {
+                this._pipe(new BufferChunk(this.buffers.shift().toBuffer()));
+            }
+        }
+    }
+    uncork() {
+        this.corked = false;
+        this._flush();
+    }
+    end(chunk, encoding, callback) {
+        const writeComplete = (error) => {
+            if (error) {
+                callback?.(error);
+            }
+            else {
+                this._flush();
+                this.pipes.forEach((pipe) => {
+                    pipe.end();
+                });
+                this.emit("finish");
+            }
+        };
+        if (chunk) {
+            this.write(chunk, encoding, writeComplete);
+        }
+        else {
+            writeComplete();
+        }
+    }
+    read(size) {
+        let buffers;
+        if (size) {
+            buffers = [];
+            while (size && this.buffers.length && !this.buffers[0].eod) {
+                const first = this.buffers[0];
+                const buffer = first.read(size);
+                if (buffer) {
+                    size -= buffer.length;
+                    buffers.push(buffer);
+                }
+                if (first.eod && first.full) {
+                    this.buffers.shift();
+                }
+            }
+            return concatUint8Arrays(buffers);
+        }
+        buffers = this.buffers.map(buf => buf.toBuffer()).filter(Boolean);
+        this.buffers = [];
+        return concatUint8Arrays(buffers);
+    }
+    setEncoding(encoding) {
+        this.encoding = encoding;
+    }
+    pause() {
+        this.paused = true;
+    }
+    resume() {
+        this.paused = false;
+    }
+    isPaused() {
+        return this.paused;
+    }
+    pipe(destination) {
+        this.pipes.push(destination);
+        if (!this.paused && this.buffers.length) {
+            this.end();
+        }
+        return destination;
+    }
+    unpipe(destination) {
+        this.pipes = this.pipes.filter((pipe) => pipe !== destination);
+    }
+    unshift() {
+        throw new Error("Not Implemented");
+    }
+    wrap() {
+        throw new Error("Not Implemented");
+    }
+    push(chunk) {
+        if (chunk !== null) {
+            this.write(chunk);
+        }
+        return true;
+    }
+}
+exports.StreamBuf = StreamBuf;
+// Helper function to concatenate Uint8Arrays
+function concatUint8Arrays(arrays) {
+    if (arrays.length === 0) {
+        return new Uint8Array(0);
+    }
+    if (arrays.length === 1) {
+        return arrays[0];
+    }
+    const totalLength = arrays.reduce((acc, arr) => acc + arr.length, 0);
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const arr of arrays) {
+        result.set(arr, offset);
+        offset += arr.length;
+    }
+    return result;
+}

package/dist/cjs/utils/stream-buf.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StreamBuf = void 0;
 const stream_1 = require("stream");
-const utils_js_1 = require("./utils");
-const string_buf_js_1 = require("./string-buf");
+const utils_1 = require("./utils");
+const string_buf_1 = require("./string-buf");
 // =============================================================================
 // data chunks - encapsulating incoming data
 class StringChunk {
@@ -142,7 +142,7 @@ const StreamBuf = function (options) {
     this.encoding = null;
 };
 exports.StreamBuf = StreamBuf;
-(0, utils_js_1.inherits)(StreamBuf, stream_1.Duplex, {
+(0, utils_1.inherits)(StreamBuf, stream_1.Duplex, {
     toBuffer() {
         switch (this.buffers.length) {
             case 0:
@@ -195,11 +195,11 @@ exports.StreamBuf = StreamBuf;
             callback = encoding;
             encoding = "utf8";
         }
-        callback = callback || utils_js_1.nop;
+        callback = callback || utils_1.nop;
         // encapsulate data into a chunk
         let chunk;
         // Use constructor name check for better ES6 module compatibility
-        if (data instanceof string_buf_js_1.StringBuf || (data && data.constructor?.name === "StringBuf")) {
+        if (data instanceof string_buf_1.StringBuf || (data && data.constructor?.name === "StringBuf")) {
             chunk = new StringBufChunk(data);
         }
         else if (Buffer.isBuffer(data)) {

package/dist/cjs/utils/unzip/extract.js

@@ -10,7 +10,7 @@ exports.extractAll = extractAll;
 exports.extractFile = extractFile;
 exports.listFiles = listFiles;
 exports.forEachEntry = forEachEntry;
-const zip_parser_js_1 = require("./zip-parser");
+const zip_parser_1 = require("./zip-parser");
 /**
  * Extract all files from a ZIP buffer
  *
@@ -19,7 +19,7 @@ const zip_parser_js_1 = require("./zip-parser");
  *
  * @example
  * ```ts
- * import { extractAll } from "./utils/unzip/extract.js";
+ * import { extractAll } from "./utils/unzip/extract";
  *
  * const zipData = fs.readFileSync("archive.zip");
  * const files = await extractAll(zipData);
@@ -31,7 +31,7 @@ const zip_parser_js_1 = require("./zip-parser");
  */
 async function extractAll(zipData) {
     const files = new Map();
-    const parser = new zip_parser_js_1.ZipParser(zipData);
+    const parser = new zip_parser_1.ZipParser(zipData);
     for (const entry of parser.getEntries()) {
         const data = await parser.extract(entry.path);
         files.set(entry.path, {
@@ -52,7 +52,7 @@ async function extractAll(zipData) {
  *
  * @example
  * ```ts
- * import { extractFile } from "./utils/unzip/extract.js";
+ * import { extractFile } from "./utils/unzip/extract";
  *
  * const zipData = fs.readFileSync("archive.zip");
  * const content = await extractFile(zipData, "readme.txt");
@@ -62,7 +62,7 @@ async function extractAll(zipData) {
  * ```
  */
 async function extractFile(zipData, filePath) {
-    const parser = new zip_parser_js_1.ZipParser(zipData);
+    const parser = new zip_parser_1.ZipParser(zipData);
     return parser.extract(filePath);
 }
 /**
@@ -73,7 +73,7 @@ async function extractFile(zipData, filePath) {
  *
  * @example
  * ```ts
- * import { listFiles } from "./utils/unzip/extract.js";
+ * import { listFiles } from "./utils/unzip/extract";
  *
  * const zipData = fs.readFileSync("archive.zip");
  * const paths = await listFiles(zipData);
@@ -81,7 +81,7 @@ async function extractFile(zipData, filePath) {
  * ```
  */
 async function listFiles(zipData) {
-    const parser = new zip_parser_js_1.ZipParser(zipData);
+    const parser = new zip_parser_1.ZipParser(zipData);
     return parser.listFiles();
 }
 /**
@@ -92,7 +92,7 @@ async function listFiles(zipData) {
  *
  * @example
  * ```ts
- * import { forEachEntry } from "./utils/unzip/extract.js";
+ * import { forEachEntry } from "./utils/unzip/extract";
  *
  * await forEachEntry(zipData, async (path, getData) => {
  *   if (path.endsWith(".xml")) {
@@ -104,11 +104,11 @@ async function listFiles(zipData) {
  * ```
  */
 async function forEachEntry(zipData, callback) {
-    const parser = new zip_parser_js_1.ZipParser(zipData);
+    const parser = new zip_parser_1.ZipParser(zipData);
     await parser.forEach(async (entry, getData) => {
         return callback(entry.path, getData, entry);
     });
 }
 // Re-export ZipParser for advanced usage
-var zip_parser_js_2 = require("./zip-parser");
-Object.defineProperty(exports, "ZipParser", { enumerable: true, get: function () { return zip_parser_js_2.ZipParser; } });
+var zip_parser_2 = require("./zip-parser");
+Object.defineProperty(exports, "ZipParser", { enumerable: true, get: function () { return zip_parser_2.ZipParser; } });

package/dist/cjs/utils/unzip/index.js

@@ -21,25 +21,25 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZipParser = exports.forEachEntry = exports.listFiles = exports.extractFile = exports.extractAll = exports.parseExtraField = exports.parseDateTime = exports.parseBuffer = exports.bufferStream = exports.NoopStream = exports.PullStream = exports.createParse = exports.Parse = void 0;
 // Stream-based API (Node.js only - requires stream module)
-var parse_js_1 = require("./parse");
-Object.defineProperty(exports, "Parse", { enumerable: true, get: function () { return parse_js_1.Parse; } });
-Object.defineProperty(exports, "createParse", { enumerable: true, get: function () { return parse_js_1.createParse; } });
-var pull_stream_js_1 = require("./pull-stream");
-Object.defineProperty(exports, "PullStream", { enumerable: true, get: function () { return pull_stream_js_1.PullStream; } });
-var noop_stream_js_1 = require("./noop-stream");
-Object.defineProperty(exports, "NoopStream", { enumerable: true, get: function () { return noop_stream_js_1.NoopStream; } });
-var buffer_stream_js_1 = require("./buffer-stream");
-Object.defineProperty(exports, "bufferStream", { enumerable: true, get: function () { return buffer_stream_js_1.bufferStream; } });
-var parse_buffer_js_1 = require("./parse-buffer");
-Object.defineProperty(exports, "parseBuffer", { enumerable: true, get: function () { return parse_buffer_js_1.parse; } });
-var parse_datetime_js_1 = require("./parse-datetime");
-Object.defineProperty(exports, "parseDateTime", { enumerable: true, get: function () { return parse_datetime_js_1.parseDateTime; } });
-var parse_extra_field_js_1 = require("./parse-extra-field");
-Object.defineProperty(exports, "parseExtraField", { enumerable: true, get: function () { return parse_extra_field_js_1.parseExtraField; } });
+var parse_1 = require("./parse");
+Object.defineProperty(exports, "Parse", { enumerable: true, get: function () { return parse_1.Parse; } });
+Object.defineProperty(exports, "createParse", { enumerable: true, get: function () { return parse_1.createParse; } });
+var pull_stream_1 = require("./pull-stream");
+Object.defineProperty(exports, "PullStream", { enumerable: true, get: function () { return pull_stream_1.PullStream; } });
+var noop_stream_1 = require("./noop-stream");
+Object.defineProperty(exports, "NoopStream", { enumerable: true, get: function () { return noop_stream_1.NoopStream; } });
+var buffer_stream_1 = require("./buffer-stream");
+Object.defineProperty(exports, "bufferStream", { enumerable: true, get: function () { return buffer_stream_1.bufferStream; } });
+var parse_buffer_1 = require("./parse-buffer");
+Object.defineProperty(exports, "parseBuffer", { enumerable: true, get: function () { return parse_buffer_1.parse; } });
+var parse_datetime_1 = require("./parse-datetime");
+Object.defineProperty(exports, "parseDateTime", { enumerable: true, get: function () { return parse_datetime_1.parseDateTime; } });
+var parse_extra_field_1 = require("./parse-extra-field");
+Object.defineProperty(exports, "parseExtraField", { enumerable: true, get: function () { return parse_extra_field_1.parseExtraField; } });
 // Buffer-based API (Browser + Node.js - cross-platform)
-var extract_js_1 = require("./extract");
-Object.defineProperty(exports, "extractAll", { enumerable: true, get: function () { return extract_js_1.extractAll; } });
-Object.defineProperty(exports, "extractFile", { enumerable: true, get: function () { return extract_js_1.extractFile; } });
-Object.defineProperty(exports, "listFiles", { enumerable: true, get: function () { return extract_js_1.listFiles; } });
-Object.defineProperty(exports, "forEachEntry", { enumerable: true, get: function () { return extract_js_1.forEachEntry; } });
-Object.defineProperty(exports, "ZipParser", { enumerable: true, get: function () { return extract_js_1.ZipParser; } });
+var extract_1 = require("./extract");
+Object.defineProperty(exports, "extractAll", { enumerable: true, get: function () { return extract_1.extractAll; } });
+Object.defineProperty(exports, "extractFile", { enumerable: true, get: function () { return extract_1.extractFile; } });
+Object.defineProperty(exports, "listFiles", { enumerable: true, get: function () { return extract_1.listFiles; } });
+Object.defineProperty(exports, "forEachEntry", { enumerable: true, get: function () { return extract_1.forEachEntry; } });
+Object.defineProperty(exports, "ZipParser", { enumerable: true, get: function () { return extract_1.ZipParser; } });

package/dist/cjs/utils/unzip/parse-extra-field.js

@@ -8,12 +8,12 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseExtraField = parseExtraField;
-const parse_buffer_js_1 = require("./parse-buffer");
+const parse_buffer_1 = require("./parse-buffer");
 function parseExtraField(extraField, vars) {
     let extra;
     // Find the ZIP64 header, if present.
     while (!extra && extraField && extraField.length) {
-        const candidateExtra = (0, parse_buffer_js_1.parse)(extraField, [
+        const candidateExtra = (0, parse_buffer_1.parse)(extraField, [
             ["signature", 2],
             ["partSize", 2]
         ]);
@@ -30,7 +30,7 @@ function parseExtraField(extraField, vars) {
                 fieldsToExpect.push(["offsetToLocalFileHeader", 8]);
             }
             // slice off the 4 bytes for signature and partSize
-            extra = (0, parse_buffer_js_1.parse)(extraField.slice(4), fieldsToExpect);
+            extra = (0, parse_buffer_1.parse)(extraField.slice(4), fieldsToExpect);
         }
         else {
             // Advance the buffer to the next part.