@cj-tech-master/excelts 1.6.2-canary.20251224015244.0b06ae9 → 1.6.3-canary.20251224124621.73c5d94

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.

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

@@ -14,12 +14,12 @@ exports.Parse = void 0;
 exports.createParse = createParse;
 const zlib_1 = __importDefault(require("zlib"));
 const stream_1 = require("stream");
-const pull_stream_js_1 = require("./pull-stream");
-const noop_stream_js_1 = require("./noop-stream");
-const buffer_stream_js_1 = require("./buffer-stream");
-const parse_extra_field_js_1 = require("./parse-extra-field");
-const parse_datetime_js_1 = require("./parse-datetime");
-const parse_buffer_js_1 = require("./parse-buffer");
+const pull_stream_1 = require("./pull-stream");
+const noop_stream_1 = require("./noop-stream");
+const buffer_stream_1 = require("./buffer-stream");
+const parse_extra_field_1 = require("./parse-extra-field");
+const parse_datetime_1 = require("./parse-datetime");
+const parse_buffer_1 = require("./parse-buffer");
 // Check if native zlib is available (Node.js environment)
 // In browser with polyfill, createInflateRaw may not exist or may not work properly
 const hasNativeZlib = typeof zlib_1.default?.createInflateRaw === "function" &&
@@ -103,7 +103,7 @@ function createInflateRaw() {
 }
 const endDirectorySignature = Buffer.alloc(4);
 endDirectorySignature.writeUInt32LE(0x06054b50, 0);
-class Parse extends pull_stream_js_1.PullStream {
+class Parse extends pull_stream_1.PullStream {
     constructor(opts = {}) {
         super();
         this._opts = opts;
@@ -163,7 +163,7 @@ class Parse extends pull_stream_js_1.PullStream {
     }
     async _readCrxHeader() {
         const data = await this.pull(12);
-        this.crxHeader = (0, parse_buffer_js_1.parse)(data, [
+        this.crxHeader = (0, parse_buffer_1.parse)(data, [
             ["version", 4],
             ["pubKeyLength", 4],
             ["signatureLength", 4]
@@ -176,7 +176,7 @@ class Parse extends pull_stream_js_1.PullStream {
     }
     async _readFile() {
         const data = await this.pull(26);
-        const vars = (0, parse_buffer_js_1.parse)(data, [
+        const vars = (0, parse_buffer_1.parse)(data, [
             ["versionsNeededToExtract", 2],
             ["flags", 2],
             ["compressionMethod", 2],
@@ -188,7 +188,7 @@ class Parse extends pull_stream_js_1.PullStream {
             ["fileNameLength", 2],
             ["extraFieldLength", 2]
         ]);
-        vars.lastModifiedDateTime = (0, parse_datetime_js_1.parseDateTime)(vars.lastModifiedDate || 0, vars.lastModifiedTime || 0);
+        vars.lastModifiedDateTime = (0, parse_datetime_1.parseDateTime)(vars.lastModifiedDate || 0, vars.lastModifiedTime || 0);
         if (this.crxHeader) {
             vars.crxHeader = this.crxHeader;
         }
@@ -198,7 +198,7 @@ class Parse extends pull_stream_js_1.PullStream {
         let __autodraining = false;
         entry.autodrain = function () {
             __autodraining = true;
-            const draining = entry.pipe(new noop_stream_js_1.NoopStream());
+            const draining = entry.pipe(new noop_stream_1.NoopStream());
             draining.promise = function () {
                 return new Promise((resolve, reject) => {
                     draining.on("finish", resolve);
@@ -208,7 +208,7 @@ class Parse extends pull_stream_js_1.PullStream {
             return draining;
         };
         entry.buffer = function () {
-            return (0, buffer_stream_js_1.bufferStream)(entry);
+            return (0, buffer_stream_1.bufferStream)(entry);
         };
         entry.path = fileName;
         entry.props = {
@@ -233,7 +233,7 @@ class Parse extends pull_stream_js_1.PullStream {
             }
         }
         const extraFieldData = await this.pull(vars.extraFieldLength || 0);
-        const extra = (0, parse_extra_field_js_1.parseExtraField)(extraFieldData, vars);
+        const extra = (0, parse_extra_field_1.parseExtraField)(extraFieldData, vars);
         entry.vars = vars;
         entry.extra = extra;
         if (this._opts.forceStream) {
@@ -278,7 +278,7 @@ class Parse extends pull_stream_js_1.PullStream {
     }
     async _processDataDescriptor(entry) {
         const data = await this.pull(16);
-        const vars = (0, parse_buffer_js_1.parse)(data, [
+        const vars = (0, parse_buffer_1.parse)(data, [
             ["dataDescriptorSignature", 4],
             ["crc32", 4],
             ["compressedSize", 4],
@@ -289,7 +289,7 @@ class Parse extends pull_stream_js_1.PullStream {
     }
     async _readCentralDirectoryFileHeader() {
         const data = await this.pull(42);
-        const vars = (0, parse_buffer_js_1.parse)(data, [
+        const vars = (0, parse_buffer_1.parse)(data, [
             ["versionMadeBy", 2],
             ["versionsNeededToExtract", 2],
             ["flags", 2],
@@ -314,7 +314,7 @@ class Parse extends pull_stream_js_1.PullStream {
     }
     async _readEndOfCentralDirectoryRecord() {
         const data = await this.pull(18);
-        const vars = (0, parse_buffer_js_1.parse)(data, [
+        const vars = (0, parse_buffer_1.parse)(data, [
             ["diskNumber", 2],
             ["diskStart", 2],
             ["numberOfRecordsOnDisk", 2],

package/dist/cjs/utils/unzip/zip-parser.js

@@ -9,7 +9,7 @@ exports.ZipParser = void 0;
 exports.parseZipEntries = parseZipEntries;
 exports.extractEntryData = extractEntryData;
 exports.extractEntryDataSync = extractEntryDataSync;
-const compress_js_1 = require("../zip/compress");
+const compress_1 = require("../zip/compress");
 // ZIP file signatures
 const LOCAL_FILE_HEADER_SIG = 0x04034b50;
 const CENTRAL_DIR_HEADER_SIG = 0x02014b50;
@@ -322,7 +322,7 @@ async function extractEntryData(data, entry) {
         return compressedData;
     }
     else if (entry.compressionMethod === COMPRESSION_DEFLATE) {
-        return (0, compress_js_1.decompress)(compressedData);
+        return (0, compress_1.decompress)(compressedData);
     }
     else {
         throw new Error(`Unsupported compression method: ${entry.compressionMethod}`);
@@ -363,7 +363,7 @@ function extractEntryDataSync(data, entry) {
         return compressedData;
     }
     else if (entry.compressionMethod === COMPRESSION_DEFLATE) {
-        return (0, compress_js_1.decompressSync)(compressedData);
+        return (0, compress_1.decompressSync)(compressedData);
     }
     else {
         throw new Error(`Unsupported compression method: ${entry.compressionMethod}`);