appium-ios-remotexpc 2.2.4 → 2.3.0

package/build/src/services/ios/zipconduit/stream-zip.js

@@ -0,0 +1,883 @@
+/**
+ * @license node-stream-zip | (c) 2020 Antelle | https://github.com/antelle/node-stream-zip/blob/master/LICENSE
+ * Portions copyright https://github.com/cthackers/adm-zip | https://raw.githubusercontent.com/cthackers/adm-zip/master/LICENSE
+ *
+ * Vendored from node-stream-zip@1.15.0, trimmed to the archive-reading paths
+ * used by ZipConduit (central-directory listing + streaming entry reads).
+ * Removed unused features: extract-to-disk, synchronous entry data, setFs,
+ * and the async helpers entriesCount/comment/entry/entryData/extract.
+ */
+import { EventEmitter } from 'node:events';
+import fs from 'node:fs';
+import stream from 'node:stream';
+import zlib from 'node:zlib';
+const ZIP = {
+    LOCHDR: 30,
+    LOCSIG: 0x04034b50,
+    LOCVER: 4,
+    LOCFLG: 6,
+    LOCHOW: 8,
+    LOCTIM: 10,
+    LOCCRC: 14,
+    LOCSIZ: 18,
+    LOCLEN: 22,
+    LOCNAM: 26,
+    LOCEXT: 28,
+    CENHDR: 46,
+    CENSIG: 0x02014b50,
+    CENVEM: 4,
+    CENVER: 6,
+    CENFLG: 8,
+    CENHOW: 10,
+    CENTIM: 12,
+    CENCRC: 16,
+    CENSIZ: 20,
+    CENLEN: 24,
+    CENNAM: 28,
+    CENEXT: 30,
+    CENCOM: 32,
+    CENDSK: 34,
+    CENATT: 36,
+    CENATX: 38,
+    CENOFF: 42,
+    ENDHDR: 22,
+    ENDSIG: 0x06054b50,
+    ENDSIGFIRST: 0x50,
+    ENDSUB: 8,
+    ENDTOT: 10,
+    ENDSIZ: 12,
+    ENDOFF: 16,
+    ENDCOM: 20,
+    MAXFILECOMMENT: 0xffff,
+    ENDL64HDR: 20,
+    ENDL64SIG: 0x07064b50,
+    ENDL64SIGFIRST: 0x50,
+    END64HDR: 56,
+    END64SIG: 0x06064b50,
+    END64SIGFIRST: 0x50,
+    END64SUB: 24,
+    END64TOT: 32,
+    END64SIZ: 40,
+    END64OFF: 48,
+    STORED: 0,
+    DEFLATED: 8,
+    FLG_ENTRY_ENC: 1,
+    ID_ZIP64: 0x0001,
+    EF_ZIP64_OR_32: 0xffffffff,
+    EF_ZIP64_OR_16: 0xffff,
+};
+class CentralDirectoryHeader {
+    volumeEntries = 0;
+    totalEntries = 0;
+    size = 0;
+    offset = 0;
+    commentLength = 0;
+    headerOffset = 0;
+    read(data) {
+        if (data.length !== ZIP.ENDHDR || data.readUInt32LE(0) !== ZIP.ENDSIG) {
+            throw new Error('Invalid central directory');
+        }
+        this.volumeEntries = data.readUInt16LE(ZIP.ENDSUB);
+        this.totalEntries = data.readUInt16LE(ZIP.ENDTOT);
+        this.size = data.readUInt32LE(ZIP.ENDSIZ);
+        this.offset = data.readUInt32LE(ZIP.ENDOFF);
+        this.commentLength = data.readUInt16LE(ZIP.ENDCOM);
+    }
+}
+class CentralDirectoryLoc64Header {
+    headerOffset = 0;
+    read(data) {
+        if (data.length !== ZIP.ENDL64HDR ||
+            data.readUInt32LE(0) !== ZIP.ENDL64SIG) {
+            throw new Error('Invalid zip64 central directory locator');
+        }
+        this.headerOffset = readUInt64LE(data, ZIP.ENDSUB);
+    }
+}
+class CentralDirectoryZip64Header {
+    volumeEntries = 0;
+    totalEntries = 0;
+    size = 0;
+    offset = 0;
+    read(data) {
+        if (data.length !== ZIP.END64HDR || data.readUInt32LE(0) !== ZIP.END64SIG) {
+            throw new Error('Invalid central directory');
+        }
+        this.volumeEntries = readUInt64LE(data, ZIP.END64SUB);
+        this.totalEntries = readUInt64LE(data, ZIP.END64TOT);
+        this.size = readUInt64LE(data, ZIP.END64SIZ);
+        this.offset = readUInt64LE(data, ZIP.END64OFF);
+    }
+}
+class FsRead {
+    fd;
+    buffer;
+    offset;
+    length;
+    position;
+    callback;
+    bytesRead = 0;
+    waiting = false;
+    constructor(fd, buffer, offset, length, position, callback) {
+        this.fd = fd;
+        this.buffer = buffer;
+        this.offset = offset;
+        this.length = length;
+        this.position = position;
+        this.callback = callback;
+    }
+    read(sync = false) {
+        this.waiting = true;
+        if (sync) {
+            let err;
+            let bytesRead = 0;
+            try {
+                bytesRead = fs.readSync(this.fd, this.buffer, this.offset + this.bytesRead, this.length - this.bytesRead, this.position + this.bytesRead);
+            }
+            catch (e) {
+                err = e;
+            }
+            this.readCallback(sync, err ?? null, err ? bytesRead : null);
+        }
+        else {
+            fs.read(this.fd, this.buffer, this.offset + this.bytesRead, this.length - this.bytesRead, this.position + this.bytesRead, (err, bytesRead) => this.readCallback(sync, err, bytesRead));
+        }
+        return this;
+    }
+    readCallback(sync, err, bytesRead) {
+        if (typeof bytesRead === 'number') {
+            this.bytesRead += bytesRead;
+        }
+        if (err || !bytesRead || this.bytesRead === this.length) {
+            this.waiting = false;
+            this.callback(err, this.bytesRead);
+            return;
+        }
+        this.read(sync);
+    }
+}
+class FileWindowBuffer {
+    fd;
+    position = 0;
+    buffer = Buffer.alloc(0);
+    fsOp = null;
+    constructor(fd) {
+        this.fd = fd;
+    }
+    read(pos, length, callback) {
+        this.checkOp();
+        if (this.buffer.length < length) {
+            this.buffer = Buffer.alloc(length);
+        }
+        this.position = pos;
+        this.fsOp = new FsRead(this.fd, this.buffer, 0, length, this.position, callback);
+        this.fsOp.read();
+    }
+    expandLeft(length, callback) {
+        this.checkOp();
+        this.buffer = Buffer.concat([Buffer.alloc(length), this.buffer]);
+        this.position -= length;
+        if (this.position < 0) {
+            this.position = 0;
+        }
+        this.fsOp = new FsRead(this.fd, this.buffer, 0, length, this.position, callback);
+        this.fsOp.read();
+    }
+    expandRight(length, callback) {
+        this.checkOp();
+        const offset = this.buffer.length;
+        this.buffer = Buffer.concat([this.buffer, Buffer.alloc(length)]);
+        this.fsOp = new FsRead(this.fd, this.buffer, offset, length, this.position + offset, callback);
+        this.fsOp.read();
+    }
+    moveRight(length, callback, shift = 0) {
+        this.checkOp();
+        if (shift) {
+            this.buffer.copy(this.buffer, 0, shift);
+        }
+        this.position += shift;
+        this.fsOp = new FsRead(this.fd, this.buffer, this.buffer.length - shift, shift, this.position + this.buffer.length - shift, callback);
+        this.fsOp.read();
+    }
+    checkOp() {
+        if (this.fsOp?.waiting) {
+            throw new Error('Operation in progress');
+        }
+    }
+}
+class EntryDataReaderStream extends stream.Readable {
+    fd;
+    dataOffset;
+    length;
+    readChunkSize;
+    pos = 0;
+    constructor(fd, dataOffset, length, readChunkSize) {
+        super({ highWaterMark: readChunkSize });
+        this.fd = fd;
+        this.dataOffset = dataOffset;
+        this.length = length;
+        this.readChunkSize = readChunkSize;
+    }
+    _read() {
+        const toRead = Math.min(this.readChunkSize, this.length - this.pos);
+        const buffer = Buffer.allocUnsafe(toRead);
+        if (buffer.length) {
+            fs.read(this.fd, buffer, 0, buffer.length, this.dataOffset + this.pos, (err, bytesRead) => this.onRead(err, bytesRead, buffer));
+        }
+        else {
+            this.push(null);
+        }
+    }
+    onRead(err, bytesRead, buffer) {
+        this.pos += bytesRead;
+        if (err) {
+            this.emit('error', err);
+            this.push(null);
+            return;
+        }
+        if (!bytesRead) {
+            this.push(null);
+            return;
+        }
+        this.push(bytesRead === buffer.length ? buffer : buffer.subarray(0, bytesRead));
+    }
+}
+class CrcVerify {
+    expectedCrc;
+    expectedSize;
+    static crcTable;
+    state = { crc: ~0, size: 0 };
+    constructor(expectedCrc, expectedSize) {
+        this.expectedCrc = expectedCrc;
+        this.expectedSize = expectedSize;
+    }
+    data(data) {
+        const crcTable = CrcVerify.getCrcTable();
+        let crc = this.state.crc;
+        let off = 0;
+        let len = data.length;
+        while (--len >= 0) {
+            crc = crcTable[(crc ^ data[off++]) & 0xff] ^ (crc >>> 8);
+        }
+        this.state.crc = crc;
+        this.state.size += data.length;
+        if (this.state.size >= this.expectedSize) {
+            const buf = Buffer.alloc(4);
+            buf.writeInt32LE(~this.state.crc & 0xffffffff, 0);
+            crc = buf.readUInt32LE(0);
+            if (crc !== this.expectedCrc) {
+                throw new Error('Invalid CRC');
+            }
+            if (this.state.size !== this.expectedSize) {
+                throw new Error('Invalid size');
+            }
+        }
+    }
+    static getCrcTable() {
+        if (CrcVerify.crcTable) {
+            return CrcVerify.crcTable;
+        }
+        const crcTable = [];
+        const b = Buffer.alloc(4);
+        for (let n = 0; n < 256; n++) {
+            let c = n;
+            for (let k = 7; k >= 0; k--) {
+                c = (c & 1) !== 0 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+            }
+            if (c < 0) {
+                b.writeInt32LE(c, 0);
+                c = b.readUInt32LE(0);
+            }
+            crcTable[n] = c;
+        }
+        CrcVerify.crcTable = crcTable;
+        return crcTable;
+    }
+}
+class EntryVerifyStream extends stream.Transform {
+    verify;
+    constructor(baseStm, crc, size) {
+        super();
+        this.verify = new CrcVerify(crc, size);
+        baseStm.on('error', (e) => this.emit('error', e));
+    }
+    _transform(data, _encoding, callback) {
+        let err;
+        try {
+            this.verify.data(data);
+        }
+        catch (e) {
+            err = e;
+        }
+        callback(err, data);
+    }
+}
+/** ZIP central-directory entry (also returned from {@link StreamZip.entries}). */
+export class ZipEntry {
+    verMade = 0;
+    version = 0;
+    flags = 0;
+    method = 0;
+    time = 0;
+    crc = 0;
+    compressedSize = 0;
+    size = 0;
+    fnameLen = 0;
+    extraLen = 0;
+    comLen = 0;
+    diskStart = 0;
+    inattr = 0;
+    attr = 0;
+    offset = 0;
+    headerOffset = 0;
+    name = '';
+    isDirectory = false;
+    comment = null;
+    readHeader(data, offset) {
+        if (data.length < offset + ZIP.CENHDR ||
+            data.readUInt32LE(offset) !== ZIP.CENSIG) {
+            throw new Error('Invalid entry header');
+        }
+        this.verMade = data.readUInt16LE(offset + ZIP.CENVEM);
+        this.version = data.readUInt16LE(offset + ZIP.CENVER);
+        this.flags = data.readUInt16LE(offset + ZIP.CENFLG);
+        this.method = data.readUInt16LE(offset + ZIP.CENHOW);
+        const timebytes = data.readUInt16LE(offset + ZIP.CENTIM);
+        const datebytes = data.readUInt16LE(offset + ZIP.CENTIM + 2);
+        this.time = parseZipTime(timebytes, datebytes);
+        this.crc = data.readUInt32LE(offset + ZIP.CENCRC);
+        this.compressedSize = data.readUInt32LE(offset + ZIP.CENSIZ);
+        this.size = data.readUInt32LE(offset + ZIP.CENLEN);
+        this.fnameLen = data.readUInt16LE(offset + ZIP.CENNAM);
+        this.extraLen = data.readUInt16LE(offset + ZIP.CENEXT);
+        this.comLen = data.readUInt16LE(offset + ZIP.CENCOM);
+        this.diskStart = data.readUInt16LE(offset + ZIP.CENDSK);
+        this.inattr = data.readUInt16LE(offset + ZIP.CENATT);
+        this.attr = data.readUInt32LE(offset + ZIP.CENATX);
+        this.offset = data.readUInt32LE(offset + ZIP.CENOFF);
+    }
+    readDataHeader(data) {
+        if (data.readUInt32LE(0) !== ZIP.LOCSIG) {
+            throw new Error('Invalid local header');
+        }
+        this.version = data.readUInt16LE(ZIP.LOCVER);
+        this.flags = data.readUInt16LE(ZIP.LOCFLG);
+        this.method = data.readUInt16LE(ZIP.LOCHOW);
+        const timebytes = data.readUInt16LE(ZIP.LOCTIM);
+        const datebytes = data.readUInt16LE(ZIP.LOCTIM + 2);
+        this.time = parseZipTime(timebytes, datebytes);
+        this.crc = data.readUInt32LE(ZIP.LOCCRC) || this.crc;
+        const compressedSize = data.readUInt32LE(ZIP.LOCSIZ);
+        if (compressedSize && compressedSize !== ZIP.EF_ZIP64_OR_32) {
+            this.compressedSize = compressedSize;
+        }
+        const size = data.readUInt32LE(ZIP.LOCLEN);
+        if (size && size !== ZIP.EF_ZIP64_OR_32) {
+            this.size = size;
+        }
+        this.fnameLen = data.readUInt16LE(ZIP.LOCNAM);
+        this.extraLen = data.readUInt16LE(ZIP.LOCEXT);
+    }
+    read(data, offset, textDecoder) {
+        const nameData = data.slice(offset, (offset += this.fnameLen));
+        this.name = textDecoder
+            ? textDecoder.decode(new Uint8Array(nameData))
+            : nameData.toString('utf8');
+        const lastChar = data[offset - 1];
+        this.isDirectory = lastChar === 47 || lastChar === 92;
+        if (this.extraLen) {
+            this.readExtra(data, offset);
+            offset += this.extraLen;
+        }
+        this.comment = this.comLen
+            ? data.slice(offset, offset + this.comLen).toString()
+            : null;
+    }
+    validateName() {
+        if (/\\|^\w+:|^\/|(^|\/)\.\.(\/|$)/.test(this.name)) {
+            throw new Error(`Malicious entry: ${this.name}`);
+        }
+    }
+    readExtra(data, offset) {
+        const maxPos = offset + this.extraLen;
+        while (offset < maxPos) {
+            const signature = data.readUInt16LE(offset);
+            offset += 2;
+            const size = data.readUInt16LE(offset);
+            offset += 2;
+            if (ZIP.ID_ZIP64 === signature) {
+                this.parseZip64Extra(data, offset, size);
+            }
+            offset += size;
+        }
+    }
+    parseZip64Extra(data, offset, length) {
+        if (length >= 8 && this.size === ZIP.EF_ZIP64_OR_32) {
+            this.size = readUInt64LE(data, offset);
+            offset += 8;
+            length -= 8;
+        }
+        if (length >= 8 && this.compressedSize === ZIP.EF_ZIP64_OR_32) {
+            this.compressedSize = readUInt64LE(data, offset);
+            offset += 8;
+            length -= 8;
+        }
+        if (length >= 8 && this.offset === ZIP.EF_ZIP64_OR_32) {
+            this.offset = readUInt64LE(data, offset);
+            offset += 8;
+            length -= 8;
+        }
+        if (length >= 4 && this.diskStart === ZIP.EF_ZIP64_OR_16) {
+            this.diskStart = data.readUInt32LE(offset);
+        }
+    }
+    get encrypted() {
+        return (this.flags & ZIP.FLG_ENTRY_ENC) === ZIP.FLG_ENTRY_ENC;
+    }
+    get isFile() {
+        return !this.isDirectory;
+    }
+}
+/** Streaming ZIP reader with promise-based entry access. */
+export class StreamZip extends EventEmitter {
+    config;
+    entriesCount = 0;
+    comment = null;
+    centralDirectory;
+    fd = null;
+    fileSize = 0;
+    chunkSize = 0;
+    closed = false;
+    signatureOp = null;
+    entriesOp = null;
+    entryMap;
+    textDecoder;
+    readyPromise;
+    constructor(config) {
+        super();
+        this.config = config;
+        this.entryMap = config.storeEntries !== false ? {} : null;
+        this.textDecoder = config.nameEncoding
+            ? new TextDecoder(config.nameEncoding)
+            : null;
+        this.readyPromise = new Promise((resolve, reject) => {
+            this.once('ready', () => {
+                this.removeListener('error', reject);
+                resolve();
+            });
+            this.once('error', reject);
+        });
+        this.open();
+    }
+    /** Resolves when the central directory has been parsed. */
+    async waitUntilReady() {
+        await this.readyPromise;
+    }
+    async entries() {
+        await this.readyPromise;
+        const entryMap = this.entryMap;
+        if (!entryMap) {
+            throw new Error('storeEntries disabled');
+        }
+        return entryMap;
+    }
+    async stream(entry) {
+        await this.readyPromise;
+        const resolvedEntry = await this.resolveFileEntry(entry);
+        const openedEntry = this.config.skipLocalHeaderRead === true &&
+            resolvedEntry.method === ZIP.STORED
+            ? resolvedEntry
+            : await this.openEntry(resolvedEntry);
+        if (openedEntry.encrypted) {
+            throw new Error('Entry encrypted');
+        }
+        const offset = this.dataOffset(openedEntry);
+        if (this.fd === null) {
+            throw new Error('Archive closed');
+        }
+        let entryStream = new EntryDataReaderStream(this.fd, offset, openedEntry.compressedSize, this.chunkSize || 1024 * 1024);
+        if (openedEntry.method === ZIP.STORED) {
+            // stored — pass through
+        }
+        else if (openedEntry.method === ZIP.DEFLATED) {
+            entryStream = entryStream.pipe(zlib.createInflateRaw());
+        }
+        else {
+            throw new Error(`Unknown compression method: ${openedEntry.method}`);
+        }
+        if (this.config.verifyEntryCrc !== false &&
+            this.canVerifyCrc(openedEntry)) {
+            entryStream = entryStream.pipe(new EntryVerifyStream(entryStream, openedEntry.crc, openedEntry.size));
+        }
+        return entryStream;
+    }
+    async openEntry(entry) {
+        await this.readyPromise;
+        let resolvedEntry;
+        if (typeof entry === 'string') {
+            const entryMap = this.entryMap;
+            if (!entryMap) {
+                throw new Error('storeEntries disabled');
+            }
+            resolvedEntry = entryMap[entry];
+            if (!resolvedEntry) {
+                throw new Error('Entry not found');
+            }
+        }
+        else {
+            resolvedEntry = entry;
+        }
+        if (!resolvedEntry.isFile) {
+            throw new Error('Entry is not file');
+        }
+        const fd = this.fd;
+        if (fd === null) {
+            throw new Error('Archive closed');
+        }
+        const entryOffset = resolvedEntry.offset;
+        const buffer = Buffer.alloc(ZIP.LOCHDR);
+        await new Promise((resolve, reject) => {
+            new FsRead(fd, buffer, 0, buffer.length, entryOffset, (err) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                resolve();
+            }).read();
+        });
+        resolvedEntry.readDataHeader(buffer);
+        if (resolvedEntry.encrypted) {
+            throw new Error('Entry encrypted');
+        }
+        return resolvedEntry;
+    }
+    async close() {
+        if (this.closed || this.fd === null) {
+            this.closed = true;
+            return;
+        }
+        this.closed = true;
+        const fd = this.fd;
+        this.fd = null;
+        await new Promise((resolve, reject) => {
+            fs.close(fd, (err) => (err ? reject(err) : resolve()));
+        });
+    }
+    emit(event, ...args) {
+        if (this.closed) {
+            return false;
+        }
+        return super.emit(event, ...args);
+    }
+    async resolveFileEntry(entry) {
+        if (typeof entry === 'string') {
+            const entryMap = this.entryMap;
+            if (!entryMap) {
+                throw new Error('storeEntries disabled');
+            }
+            const resolvedEntry = entryMap[entry];
+            if (!resolvedEntry) {
+                throw new Error('Entry not found');
+            }
+            if (!resolvedEntry.isFile) {
+                throw new Error('Entry is not file');
+            }
+            return resolvedEntry;
+        }
+        if (!entry.isFile) {
+            throw new Error('Entry is not file');
+        }
+        return entry;
+    }
+    open() {
+        if (this.config.fd !== undefined) {
+            this.fd = this.config.fd;
+            this.readFile();
+            return;
+        }
+        const filePath = this.config.file;
+        if (!filePath) {
+            this.emit('error', new Error('ZIP file path is required'));
+            return;
+        }
+        fs.open(filePath, 'r', (err, f) => {
+            if (err) {
+                this.emit('error', err);
+                return;
+            }
+            this.fd = f;
+            this.readFile();
+        });
+    }
+    readFile() {
+        if (this.fd === null) {
+            return;
+        }
+        fs.fstat(this.fd, (err, stat) => {
+            if (err) {
+                this.emit('error', err);
+                return;
+            }
+            this.fileSize = stat.size;
+            let chunk = this.config.chunkSize ?? Math.round(this.fileSize / 1000);
+            chunk = Math.max(Math.min(chunk, Math.min(128 * 1024, this.fileSize)), Math.min(1024, this.fileSize));
+            this.chunkSize = chunk;
+            this.readCentralDirectory();
+        });
+    }
+    readUntilFoundCallback = (err, bytesRead) => {
+        const op = this.signatureOp;
+        if (!op) {
+            return;
+        }
+        if (err || !bytesRead) {
+            this.emit('error', err ?? new Error('Archive read error'));
+            return;
+        }
+        let pos = op.lastPos;
+        let bufferPosition = pos - op.win.position;
+        const buffer = op.win.buffer;
+        const minPos = op.minPos;
+        while (--pos >= minPos && --bufferPosition >= 0) {
+            if (buffer.length - bufferPosition >= 4 &&
+                buffer[bufferPosition] === op.firstByte) {
+                if (buffer.readUInt32LE(bufferPosition) === op.sig) {
+                    op.lastBufferPosition = bufferPosition;
+                    op.lastBytesRead = bytesRead;
+                    op.complete();
+                    return;
+                }
+            }
+        }
+        if (pos === minPos) {
+            this.emit('error', new Error('Bad archive'));
+            return;
+        }
+        op.lastPos = pos + 1;
+        op.chunkSize *= 2;
+        if (pos <= minPos) {
+            this.emit('error', new Error('Bad archive'));
+            return;
+        }
+        const expandLength = Math.min(op.chunkSize, pos - minPos);
+        op.win.expandLeft(expandLength, this.readUntilFoundCallback);
+    };
+    readCentralDirectory() {
+        if (this.fd === null) {
+            return;
+        }
+        const totalReadLength = Math.min(ZIP.ENDHDR + ZIP.MAXFILECOMMENT, this.fileSize);
+        this.signatureOp = {
+            win: new FileWindowBuffer(this.fd),
+            totalReadLength,
+            minPos: this.fileSize - totalReadLength,
+            lastPos: this.fileSize,
+            chunkSize: Math.min(1024, this.chunkSize),
+            firstByte: ZIP.ENDSIGFIRST,
+            sig: ZIP.ENDSIG,
+            lastBufferPosition: 0,
+            lastBytesRead: 0,
+            complete: () => this.readCentralDirectoryComplete(),
+        };
+        const op = this.signatureOp;
+        op.win.read(this.fileSize - op.chunkSize, op.chunkSize, this.readUntilFoundCallback);
+    }
+    readCentralDirectoryComplete() {
+        const op = this.signatureOp;
+        if (!op) {
+            return;
+        }
+        const buffer = op.win.buffer;
+        const pos = op.lastBufferPosition;
+        try {
+            const centralDirectory = new CentralDirectoryHeader();
+            centralDirectory.read(buffer.subarray(pos, pos + ZIP.ENDHDR));
+            centralDirectory.headerOffset = op.win.position + pos;
+            if (centralDirectory.commentLength) {
+                this.comment = buffer
+                    .subarray(pos + ZIP.ENDHDR, pos + ZIP.ENDHDR + centralDirectory.commentLength)
+                    .toString();
+            }
+            else {
+                this.comment = null;
+            }
+            this.entriesCount = centralDirectory.volumeEntries;
+            this.centralDirectory = centralDirectory;
+            if ((centralDirectory.volumeEntries === ZIP.EF_ZIP64_OR_16 &&
+                centralDirectory.totalEntries === ZIP.EF_ZIP64_OR_16) ||
+                centralDirectory.size === ZIP.EF_ZIP64_OR_32 ||
+                centralDirectory.offset === ZIP.EF_ZIP64_OR_32) {
+                this.readZip64CentralDirectoryLocator();
+            }
+            else {
+                this.signatureOp = null;
+                this.readEntries();
+            }
+        }
+        catch (err) {
+            this.emit('error', err);
+        }
+    }
+    readZip64CentralDirectoryLocator() {
+        const op = this.signatureOp;
+        if (!op) {
+            return;
+        }
+        const length = ZIP.ENDL64HDR;
+        if (op.lastBufferPosition > length) {
+            op.lastBufferPosition -= length;
+            this.readZip64CentralDirectoryLocatorComplete();
+            return;
+        }
+        this.signatureOp = {
+            win: op.win,
+            totalReadLength: length,
+            minPos: op.win.position - length,
+            lastPos: op.win.position,
+            chunkSize: op.chunkSize,
+            firstByte: ZIP.ENDL64SIGFIRST,
+            sig: ZIP.ENDL64SIG,
+            lastBufferPosition: op.lastBufferPosition,
+            lastBytesRead: op.lastBytesRead,
+            complete: () => this.readZip64CentralDirectoryLocatorComplete(),
+        };
+        const next = this.signatureOp;
+        next.win.read(next.lastPos - next.chunkSize, next.chunkSize, this.readUntilFoundCallback);
+    }
+    readZip64CentralDirectoryLocatorComplete() {
+        const op = this.signatureOp;
+        if (!op) {
+            return;
+        }
+        const buffer = op.win.buffer;
+        const locHeader = new CentralDirectoryLoc64Header();
+        locHeader.read(buffer.subarray(op.lastBufferPosition, op.lastBufferPosition + ZIP.ENDL64HDR));
+        const readLength = this.fileSize - locHeader.headerOffset;
+        this.signatureOp = {
+            win: op.win,
+            totalReadLength: readLength,
+            minPos: locHeader.headerOffset,
+            lastPos: op.lastPos,
+            chunkSize: op.chunkSize,
+            firstByte: ZIP.END64SIGFIRST,
+            sig: ZIP.END64SIG,
+            lastBufferPosition: op.lastBufferPosition,
+            lastBytesRead: op.lastBytesRead,
+            complete: () => this.readZip64CentralDirectoryComplete(),
+        };
+        const next = this.signatureOp;
+        next.win.read(this.fileSize - next.chunkSize, next.chunkSize, this.readUntilFoundCallback);
+    }
+    readZip64CentralDirectoryComplete() {
+        const op = this.signatureOp;
+        if (!op) {
+            return;
+        }
+        const buffer = op.win.buffer;
+        const zip64cd = new CentralDirectoryZip64Header();
+        zip64cd.read(buffer.subarray(op.lastBufferPosition, op.lastBufferPosition + ZIP.END64HDR));
+        this.centralDirectory.volumeEntries = zip64cd.volumeEntries;
+        this.centralDirectory.totalEntries = zip64cd.totalEntries;
+        this.centralDirectory.size = zip64cd.size;
+        this.centralDirectory.offset = zip64cd.offset;
+        this.entriesCount = zip64cd.volumeEntries;
+        this.signatureOp = null;
+        this.readEntries();
+    }
+    readEntries() {
+        if (this.fd === null) {
+            return;
+        }
+        this.entriesOp = {
+            win: new FileWindowBuffer(this.fd),
+            pos: this.centralDirectory.offset,
+            chunkSize: this.chunkSize,
+            entriesLeft: this.centralDirectory.volumeEntries,
+            entry: null,
+        };
+        const op = this.entriesOp;
+        op.win.read(op.pos, Math.min(this.chunkSize, this.fileSize - op.pos), this.readEntriesCallback);
+    }
+    readEntriesCallback = (err, bytesRead) => {
+        const op = this.entriesOp;
+        if (!op) {
+            return;
+        }
+        if (err || !bytesRead) {
+            this.emit('error', err ?? new Error('Entries read error'));
+            return;
+        }
+        let bufferPos = op.pos - op.win.position;
+        let entry = op.entry;
+        const buffer = op.win.buffer;
+        const bufferLength = buffer.length;
+        try {
+            while (op.entriesLeft > 0) {
+                if (!entry) {
+                    entry = new ZipEntry();
+                    entry.readHeader(buffer, bufferPos);
+                    entry.headerOffset = op.win.position + bufferPos;
+                    op.entry = entry;
+                    op.pos += ZIP.CENHDR;
+                    bufferPos += ZIP.CENHDR;
+                }
+                const entryHeaderSize = entry.fnameLen + entry.extraLen + entry.comLen;
+                const advanceBytes = entryHeaderSize + (op.entriesLeft > 1 ? ZIP.CENHDR : 0);
+                if (bufferLength - bufferPos < advanceBytes) {
+                    op.win.moveRight(this.chunkSize, this.readEntriesCallback, bufferPos);
+                    op.move = true;
+                    return;
+                }
+                entry.read(buffer, bufferPos, this.textDecoder);
+                if (!this.config.skipEntryNameValidation) {
+                    entry.validateName();
+                }
+                if (this.entryMap) {
+                    this.entryMap[entry.name] = entry;
+                }
+                this.emit('entry', entry);
+                op.entry = null;
+                entry = null;
+                op.entriesLeft--;
+                op.pos += entryHeaderSize;
+                bufferPos += entryHeaderSize;
+            }
+            this.emit('ready');
+        }
+        catch (readErr) {
+            this.emit('error', readErr);
+        }
+    };
+    dataOffset(entry) {
+        return entry.offset + ZIP.LOCHDR + entry.fnameLen + entry.extraLen;
+    }
+    canVerifyCrc(entry) {
+        return (entry.flags & 0x8) !== 0x8;
+    }
+}
+function parseZipTime(timebytes, datebytes) {
+    const timebits = toBits(timebytes, 16);
+    const datebits = toBits(datebytes, 16);
+    const mt = {
+        h: Number.parseInt(timebits.slice(0, 5).join(''), 2),
+        m: Number.parseInt(timebits.slice(5, 11).join(''), 2),
+        s: Number.parseInt(timebits.slice(11, 16).join(''), 2) * 2,
+        Y: Number.parseInt(datebits.slice(0, 7).join(''), 2) + 1980,
+        M: Number.parseInt(datebits.slice(7, 11).join(''), 2),
+        D: Number.parseInt(datebits.slice(11, 16).join(''), 2),
+    };
+    const dtStr = `${[mt.Y, mt.M, mt.D].join('-')} ${[mt.h, mt.m, mt.s].join(':')} GMT+0`;
+    return new Date(dtStr).getTime();
+}
+function toBits(dec, size) {
+    let b = (dec >>> 0).toString(2);
+    while (b.length < size) {
+        b = `0${b}`;
+    }
+    return b.split('');
+}
+function readUInt64LE(buffer, offset) {
+    return (buffer.readUInt32LE(offset + 4) * 0x0000000100000000 +
+        buffer.readUInt32LE(offset));
+}
+//# sourceMappingURL=stream-zip.js.map