@openclaw/fs-safe 0.5.5 → 0.6.0

package/dist/archive-zip-count.d.ts

@@ -0,0 +1,2 @@
+export declare function readZipCentralDirectoryEntryCount(buffer: Buffer | Uint8Array): number | null;
+//# sourceMappingURL=archive-zip-count.d.ts.map

package/dist/archive-zip-count.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"archive-zip-count.d.ts","sourceRoot":"","sources":["../src/archive-zip-count.ts"],"names":[],"mappings":"AA4KA,wBAAgB,iCAAiC,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,GAAG,MAAM,GAAG,IAAI,CAU5F"}

package/dist/archive-zip-count.js

@@ -0,0 +1,140 @@
+// Conservative public count hint; strict admission must not rely on its fallback.
+const ZIP_EOCD_SIGNATURE = 0x06054b50;
+const ZIP64_EOCD_SIGNATURE = 0x06064b50;
+const ZIP64_EOCD_LOCATOR_SIGNATURE = 0x07064b50;
+const ZIP_EOCD_MIN_BYTES = 22;
+const ZIP_EOCD_MAX_COMMENT_BYTES = 0xffff;
+const ZIP64_ENTRY_COUNT_SENTINEL = 0xffff;
+const ZIP64_UINT32_SENTINEL = 0xffffffff;
+const ZIP_CENTRAL_FILE_HEADER_SIGNATURE = 0x02014b50;
+const ZIP_CENTRAL_FILE_HEADER_MIN_BYTES = 46;
+const ZIP_CENTRAL_FILE_HEADER_NAME_LENGTH_OFFSET = 28;
+const ZIP_CENTRAL_FILE_HEADER_EXTRA_LENGTH_OFFSET = 30;
+const ZIP_CENTRAL_FILE_HEADER_COMMENT_LENGTH_OFFSET = 32;
+const ZIP_EOCD_TOTAL_ENTRIES_OFFSET = 10;
+const ZIP_EOCD_CENTRAL_DIRECTORY_SIZE_OFFSET = 12;
+const ZIP_EOCD_CENTRAL_DIRECTORY_OFFSET_OFFSET = 16;
+const ZIP_EOCD_COMMENT_LENGTH_OFFSET = 20;
+const ZIP64_EOCD_LOCATOR_BYTES = 20;
+const ZIP64_EOCD_OFFSET_OFFSET = 8;
+const ZIP64_EOCD_TOTAL_ENTRIES_OFFSET = 32;
+const ZIP64_EOCD_CENTRAL_DIRECTORY_SIZE_OFFSET = 40;
+const ZIP64_EOCD_CENTRAL_DIRECTORY_OFFSET_OFFSET = 48;
+function asBufferView(buffer) {
+    if (Buffer.isBuffer(buffer)) {
+        return buffer;
+    }
+    return Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+}
+function readSafeUInt64LE(buffer, offset) {
+    const value = buffer.readBigUInt64LE(offset);
+    if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+        return Number.MAX_SAFE_INTEGER;
+    }
+    return Number(value);
+}
+function findZipEndOfCentralDirectory(buffer) {
+    if (buffer.byteLength < ZIP_EOCD_MIN_BYTES) {
+        return -1;
+    }
+    const minOffset = Math.max(0, buffer.byteLength - ZIP_EOCD_MIN_BYTES - ZIP_EOCD_MAX_COMMENT_BYTES);
+    for (let offset = buffer.byteLength - ZIP_EOCD_MIN_BYTES; offset >= minOffset; offset -= 1) {
+        if (buffer.readUInt32LE(offset) !== ZIP_EOCD_SIGNATURE) {
+            continue;
+        }
+        const commentLength = buffer.readUInt16LE(offset + ZIP_EOCD_COMMENT_LENGTH_OFFSET);
+        if (offset + ZIP_EOCD_MIN_BYTES + commentLength === buffer.byteLength) {
+            return offset;
+        }
+    }
+    return -1;
+}
+function readZip64CentralDirectoryInfo(buffer, eocdOffset) {
+    const locatorOffset = eocdOffset - ZIP64_EOCD_LOCATOR_BYTES;
+    if (locatorOffset < 0 || buffer.readUInt32LE(locatorOffset) !== ZIP64_EOCD_LOCATOR_SIGNATURE) {
+        return null;
+    }
+    const zip64EocdOffset = readSafeUInt64LE(buffer, locatorOffset + ZIP64_EOCD_OFFSET_OFFSET);
+    if (zip64EocdOffset < 0 ||
+        zip64EocdOffset + ZIP64_EOCD_CENTRAL_DIRECTORY_OFFSET_OFFSET + 8 > buffer.byteLength ||
+        buffer.readUInt32LE(zip64EocdOffset) !== ZIP64_EOCD_SIGNATURE) {
+        return null;
+    }
+    return {
+        declaredEntryCount: readSafeUInt64LE(buffer, zip64EocdOffset + ZIP64_EOCD_TOTAL_ENTRIES_OFFSET),
+        centralDirectorySize: readSafeUInt64LE(buffer, zip64EocdOffset + ZIP64_EOCD_CENTRAL_DIRECTORY_SIZE_OFFSET),
+        centralDirectoryOffset: readSafeUInt64LE(buffer, zip64EocdOffset + ZIP64_EOCD_CENTRAL_DIRECTORY_OFFSET_OFFSET),
+        endOfCentralDirectoryOffset: eocdOffset,
+    };
+}
+function readZipCentralDirectoryInfo(buffer) {
+    const eocdOffset = findZipEndOfCentralDirectory(buffer);
+    if (eocdOffset < 0) {
+        return null;
+    }
+    const declaredEntryCount = buffer.readUInt16LE(eocdOffset + ZIP_EOCD_TOTAL_ENTRIES_OFFSET);
+    const centralDirectorySize = buffer.readUInt32LE(eocdOffset + ZIP_EOCD_CENTRAL_DIRECTORY_SIZE_OFFSET);
+    const centralDirectoryOffset = buffer.readUInt32LE(eocdOffset + ZIP_EOCD_CENTRAL_DIRECTORY_OFFSET_OFFSET);
+    const usesZip64 = declaredEntryCount === ZIP64_ENTRY_COUNT_SENTINEL ||
+        centralDirectorySize === ZIP64_UINT32_SENTINEL ||
+        centralDirectoryOffset === ZIP64_UINT32_SENTINEL;
+    if (usesZip64) {
+        return (readZip64CentralDirectoryInfo(buffer, eocdOffset) ?? {
+            declaredEntryCount,
+            centralDirectoryOffset,
+            centralDirectorySize,
+            endOfCentralDirectoryOffset: eocdOffset,
+        });
+    }
+    return {
+        declaredEntryCount,
+        centralDirectoryOffset,
+        centralDirectorySize,
+        endOfCentralDirectoryOffset: eocdOffset,
+    };
+}
+function countZipCentralDirectoryHeaders(buffer, info) {
+    const start = info.centralDirectoryOffset;
+    const declaredEnd = start + info.centralDirectorySize;
+    const scanEnd = info.endOfCentralDirectoryOffset;
+    if (!Number.isSafeInteger(start) ||
+        !Number.isSafeInteger(declaredEnd) ||
+        !Number.isSafeInteger(scanEnd) ||
+        start < 0 ||
+        declaredEnd < start ||
+        scanEnd < start ||
+        scanEnd > buffer.byteLength) {
+        return null;
+    }
+    let offset = start;
+    let count = 0;
+    while (offset < scanEnd) {
+        if (scanEnd - offset < ZIP_CENTRAL_FILE_HEADER_MIN_BYTES) {
+            break;
+        }
+        if (buffer.readUInt32LE(offset) !== ZIP_CENTRAL_FILE_HEADER_SIGNATURE) {
+            break;
+        }
+        const nameLength = buffer.readUInt16LE(offset + ZIP_CENTRAL_FILE_HEADER_NAME_LENGTH_OFFSET);
+        const extraLength = buffer.readUInt16LE(offset + ZIP_CENTRAL_FILE_HEADER_EXTRA_LENGTH_OFFSET);
+        const commentLength = buffer.readUInt16LE(offset + ZIP_CENTRAL_FILE_HEADER_COMMENT_LENGTH_OFFSET);
+        const nextOffset = offset + ZIP_CENTRAL_FILE_HEADER_MIN_BYTES + nameLength + extraLength + commentLength;
+        if (nextOffset <= offset || nextOffset > scanEnd) {
+            return null;
+        }
+        count += 1;
+        offset = nextOffset;
+    }
+    return count > 0 || info.declaredEntryCount === 0 ? count : null;
+}
+export function readZipCentralDirectoryEntryCount(buffer) {
+    const view = asBufferView(buffer);
+    const info = readZipCentralDirectoryInfo(view);
+    if (!info) {
+        return null;
+    }
+    const countedEntryCount = countZipCentralDirectoryHeaders(view, info);
+    return countedEntryCount === null
+        ? info.declaredEntryCount
+        : Math.max(info.declaredEntryCount, countedEntryCount);
+}

package/dist/archive-zip-directory.d.ts

@@ -0,0 +1,8 @@
+import { type ResolvedArchiveExtractLimits } from "./archive-limits.js";
+export type ZipRead = {
+    offset: number;
+    length: number;
+};
+export type ZipScan = Generator<ZipRead, number, Buffer>;
+export declare function scanZipDirectory(size: number, limits: ResolvedArchiveExtractLimits): ZipScan;
+//# sourceMappingURL=archive-zip-directory.d.ts.map

package/dist/archive-zip-directory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"archive-zip-directory.d.ts","sourceRoot":"","sources":["../src/archive-zip-directory.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,4BAA4B,EAClC,MAAM,qBAAqB,CAAC;AAG7B,MAAM,MAAM,OAAO,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AACzD,MAAM,MAAM,OAAO,GAAG,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAmIzD,wBAAiB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,4BAA4B,GAAG,OAAO,CA8D7F"}

package/dist/archive-zip-directory.js

@@ -0,0 +1,224 @@
+import { assertArchiveEntryCountWithinLimit, } from "./archive-limits.js";
+import { admitZipNames, zipExtraFields, zipFormat, zipUInt64 } from "./archive-zip-names.js";
+function* read(offset, length, bound) {
+    if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(length) || offset < 0 || length < 0 || length > bound - offset) {
+        zipFormat("record outside archive bounds");
+    }
+    const bytes = yield { offset, length };
+    if (bytes.length !== length)
+        zipFormat("truncated record");
+    return bytes;
+}
+function endOffset(tail) {
+    let found = -1;
+    for (let offset = tail.length - 22; offset >= 0; offset--) {
+        if (tail.readUInt32LE(offset) === 0x06054b50 && offset + 22 + tail.readUInt16LE(offset + 20) === tail.length) {
+            if (found !== -1)
+                zipFormat("ambiguous end records");
+            found = offset;
+        }
+    }
+    if (found < 0)
+        zipFormat("end record missing");
+    return found;
+}
+function* zip64End(locator, locatorAt, size) {
+    const advertised = zipUInt64(locator, 8);
+    // Seek the advertised record, or the fixed ordinary record for a prefixed
+    // archive. Never hunt through payload bytes for a ZIP64 signature.
+    const candidates = new Set([advertised, locatorAt - 56]);
+    let found;
+    for (const at of candidates) {
+        if (at < 0 || at > locatorAt - 56)
+            continue;
+        const record = yield* read(at, 56, size);
+        if (record.readUInt32LE(0) !== 0x06064b50)
+            continue;
+        const bodySize = zipUInt64(record, 4);
+        if (bodySize < 44 || bodySize !== locatorAt - at - 12)
+            continue;
+        if (found)
+            zipFormat("ambiguous ZIP64 end records");
+        found = { at, record };
+    }
+    if (!found)
+        zipFormat("unsupported ZIP64 end record");
+    return found;
+}
+function* layout(size) {
+    const tailStart = Math.max(0, size - 65_557);
+    const tail = yield* read(tailStart, size - tailStart, size);
+    const at = endOffset(tail);
+    const end = tail.subarray(at, at + 22);
+    const physicalEnd = tailStart + at;
+    if (end.readUInt16LE(4) || end.readUInt16LE(6))
+        zipFormat("multi-disk archive");
+    let count = end.readUInt16LE(10);
+    let directorySize = end.readUInt32LE(12);
+    let offset = end.readUInt32LE(16);
+    let directoryEnd = physicalEnd;
+    const wide = count === 0xffff || end.readUInt16LE(8) === 0xffff || directorySize === 0xffffffff || offset === 0xffffffff;
+    if (wide) {
+        const locator = yield* read(physicalEnd - 20, 20, size);
+        if (locator.readUInt32LE(0) !== 0x07064b50 || locator.readUInt32LE(4) || locator.readUInt32LE(16) !== 1) {
+            zipFormat("invalid ZIP64 locator");
+        }
+        const wideEnd = yield* zip64End(locator, physicalEnd - 20, size);
+        directoryEnd = wideEnd.at;
+        const record = wideEnd.record;
+        if (record.readUInt32LE(16) || record.readUInt32LE(20))
+            zipFormat("multi-disk ZIP64 archive");
+        count = zipUInt64(record, 32);
+        directorySize = zipUInt64(record, 40);
+        offset = zipUInt64(record, 48);
+        if (zipUInt64(record, 24) !== count)
+            zipFormat("ZIP64 disk count mismatch");
+        for (const [ordinary, sentinel, value] of [
+            [end.readUInt16LE(8), 0xffff, count], [end.readUInt16LE(10), 0xffff, count],
+            [end.readUInt32LE(12), 0xffffffff, directorySize], [end.readUInt32LE(16), 0xffffffff, offset],
+        ]) {
+            if (ordinary !== sentinel && ordinary !== value)
+                zipFormat("conflicting ZIP64 end values");
+        }
+        const base = directoryEnd - directorySize - offset;
+        if (zipUInt64(locator, 8) !== directoryEnd - base)
+            zipFormat("ZIP64 locator offset mismatch");
+    }
+    else if (end.readUInt16LE(8) !== count)
+        zipFormat("disk count mismatch");
+    const start = directoryEnd - directorySize;
+    const base = start - offset;
+    if (base < 0 || start < 0 || !Number.isSafeInteger(base))
+        zipFormat("invalid central directory offset");
+    return { count, start, end: directoryEnd, base };
+}
+function wideValues(header, extra, central) {
+    let compressed = header.readUInt32LE(central ? 20 : 18);
+    let uncompressed = header.readUInt32LE(central ? 24 : 22);
+    let offset = central ? header.readUInt32LE(42) : 0;
+    let disk = central ? header.readUInt16LE(34) : 0;
+    const field = extra.get(1);
+    if (field?.length === 0)
+        zipFormat("empty ZIP64 extra field");
+    let cursor = 0;
+    const value = () => {
+        if (!field)
+            return zipFormat("ZIP64 extra field missing");
+        const result = zipUInt64(field, cursor);
+        cursor += 8;
+        return result;
+    };
+    const wide = compressed === 0xffffffff || uncompressed === 0xffffffff;
+    if (uncompressed === 0xffffffff)
+        uncompressed = value();
+    if (compressed === 0xffffffff)
+        compressed = value();
+    if (offset === 0xffffffff)
+        offset = value();
+    if (disk === 0xffff) {
+        if (!field || cursor + 4 > field.length)
+            zipFormat("ZIP64 disk field missing");
+        disk = field.readUInt32LE(cursor);
+        cursor += 4;
+    }
+    if (field && cursor !== field.length) {
+        // Some writers repeat both local sizes even when the 32-bit fields fit.
+        if (central || cursor !== 0 || field.length !== 16 ||
+            zipUInt64(field, 0) !== uncompressed || zipUInt64(field, 8) !== compressed) {
+            zipFormat("inconsistent ZIP64 extra field");
+        }
+    }
+    if (disk)
+        zipFormat("multi-disk entry");
+    return { compressed, uncompressed, offset, wide };
+}
+function* descriptorEnd(at, bound, crc, compressed, uncompressed, wide) {
+    const length = wide ? 20 : 12;
+    const bytes = yield* read(at, Math.min(length + 4, bound - at), bound);
+    const matches = [];
+    for (const skip of [0, 4]) {
+        if (skip && (bytes.length < 4 || bytes.readUInt32LE(0) !== 0x08074b50))
+            continue;
+        if (bytes.length < length + skip || bytes.readUInt32LE(skip) !== crc)
+            continue;
+        const c = wide ? zipUInt64(bytes, skip + 4) : bytes.readUInt32LE(skip + 4);
+        const u = wide ? zipUInt64(bytes, skip + 12) : bytes.readUInt32LE(skip + 8);
+        if (c === compressed && u === uncompressed)
+            matches.push(at + length + skip);
+    }
+    if (matches.length !== 1)
+        zipFormat("invalid or ambiguous data descriptor");
+    return matches[0];
+}
+export function* scanZipDirectory(size, limits) {
+    const directory = yield* layout(size);
+    assertArchiveEntryCountWithinLimit(directory.count, limits);
+    const seen = new Set();
+    const spans = [];
+    let at = directory.start;
+    let count = 0;
+    while (at < directory.end) {
+        const central = yield* read(at, Math.min(46, directory.end - at), directory.end);
+        if (central.length >= 6 && central.readUInt32LE(0) === 0x05054b50) {
+            // The optional digital signature belongs to the directory size, not its
+            // entry count. It is opaque metadata, not an authenticity guarantee.
+            if (central.readUInt16LE(4) !== directory.end - at - 6)
+                zipFormat("invalid directory signature length");
+            at = directory.end;
+            break;
+        }
+        assertArchiveEntryCountWithinLimit(++count, limits);
+        if (central.length < 46 || central.readUInt32LE(0) !== 0x02014b50)
+            zipFormat("invalid central header");
+        const nameLength = central.readUInt16LE(28);
+        const extraLength = central.readUInt16LE(30);
+        const next = at + 46 + nameLength + extraLength + central.readUInt16LE(32);
+        if (next > directory.end)
+            zipFormat("central record exceeds directory");
+        const names = yield* read(at + 46, nameLength + extraLength, directory.end);
+        const centralName = names.subarray(0, nameLength);
+        const centralExtra = zipExtraFields(names.subarray(nameLength));
+        const values = wideValues(central, centralExtra, true);
+        const flags = central.readUInt16LE(8);
+        if (flags & ~0x080e)
+            zipFormat("unsupported entry flags");
+        const localAt = directory.base + values.offset;
+        if (localAt < directory.base)
+            zipFormat("local offset precedes archive base");
+        const local = yield* read(localAt, 30, directory.start);
+        if (local.readUInt32LE(0) !== 0x04034b50 || local.readUInt16LE(6) !== flags || local.readUInt16LE(8) !== central.readUInt16LE(10)) {
+            zipFormat("local and central framing disagree");
+        }
+        const localNameLength = local.readUInt16LE(26);
+        const localExtraLength = local.readUInt16LE(28);
+        const localNames = yield* read(localAt + 30, localNameLength + localExtraLength, directory.start);
+        const localExtra = zipExtraFields(localNames.subarray(localNameLength));
+        admitZipNames({ central: centralName, local: localNames.subarray(0, localNameLength), flags, centralExtra, localExtra, seen });
+        const localValues = wideValues(local, localExtra, false);
+        const crc = central.readUInt32LE(16);
+        if (!(flags & 8) && (local.readUInt32LE(14) !== crc || localValues.compressed !== values.compressed || localValues.uncompressed !== values.uncompressed)) {
+            zipFormat("local and central sizes or CRC disagree");
+        }
+        if ((flags & 8) && ((local.readUInt32LE(14) !== 0 && local.readUInt32LE(14) !== crc) ||
+            (localValues.compressed !== 0 && localValues.compressed !== values.compressed) ||
+            (localValues.uncompressed !== 0 && localValues.uncompressed !== values.uncompressed))) {
+            zipFormat("data descriptor placeholders disagree");
+        }
+        const dataStart = localAt + 30 + localNameLength + localExtraLength;
+        if (values.compressed > directory.start - dataStart)
+            zipFormat("entry data exceeds local area");
+        let dataEnd = dataStart + values.compressed;
+        if (flags & 8)
+            dataEnd = yield* descriptorEnd(dataEnd, directory.start, crc, values.compressed, values.uncompressed, values.wide || localValues.wide);
+        spans.push({ start: localAt, end: dataEnd });
+        at = next;
+    }
+    if (count !== directory.count)
+        zipFormat("physical and declared entry counts disagree");
+    spans.sort((a, b) => a.start - b.start);
+    for (let i = 1; i < spans.length; i++) {
+        if (spans[i].start < spans[i - 1].end)
+            zipFormat("overlapping local entries");
+    }
+    return count;
+}

package/dist/archive-zip-integrity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"archive-zip-integrity.d.ts","sourceRoot":"","sources":["../src/archive-zip-integrity.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC,OAAO,EAGL,KAAK,QAAQ,EACd,MAAM,wBAAwB,CAAC;AAkBhC,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,CAQhE;AAED,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,QAAQ,GAAG,SAAS,CAgCtE"}
+{"version":3,"file":"archive-zip-integrity.d.ts","sourceRoot":"","sources":["../src/archive-zip-integrity.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC,OAAO,EAGL,KAAK,QAAQ,EACd,MAAM,wBAAwB,CAAC;AAIhC,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,CAQhE;AAED,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,QAAQ,GAAG,SAAS,CAgCtE"}

package/dist/archive-zip-integrity.js

@@ -1,20 +1,7 @@
 import { Transform } from "node:stream";
 import { ArchiveFormatError } from "./archive-errors.js";
 import { hasDeferredEmptyZipData, zipEntryIntegrityMetadata, } from "./archive-zip-entry.js";
-const CRC32_TABLE = Array.from({ length: 256 }, (_, index) => {
-    let value = index;
-    for (let bit = 0; bit < 8; bit += 1) {
-        value = (value & 1) !== 0 ? 0xedb88320 ^ (value >>> 1) : value >>> 1;
-    }
-    return value >>> 0;
-});
-function updateCrc32(previous, buffer) {
-    let crc = previous ^ -1;
-    for (const byte of buffer) {
-        crc = (crc >>> 8) ^ (CRC32_TABLE[(crc ^ byte) & 0xff] ?? 0);
-    }
-    return (crc ^ -1) >>> 0;
-}
+import { updateCrc32 } from "./archive-crc32.js";
 export function normalizeZipIntegrityError(error) {
     if (error instanceof Error &&
         error.message.includes("uncompressed data size mismatch")) {

package/dist/archive-zip-names.d.ts

@@ -0,0 +1,12 @@
+export declare function zipFormat(message: string): never;
+export declare function zipUInt64(bytes: Buffer, offset: number): number;
+export declare function zipExtraFields(bytes: Buffer): Map<number, Buffer>;
+export declare function admitZipNames(params: {
+    central: Buffer;
+    local: Buffer;
+    flags: number;
+    centralExtra: Map<number, Buffer>;
+    localExtra: Map<number, Buffer>;
+    seen: Set<string>;
+}): void;
+//# sourceMappingURL=archive-zip-names.d.ts.map

package/dist/archive-zip-names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"archive-zip-names.d.ts","sourceRoot":"","sources":["../src/archive-zip-names.ts"],"names":[],"mappings":"AAIA,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,CAEhD;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAK/D;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAcjE;AA6BD,wBAAgB,aAAa,CAAC,MAAM,EAAE;IACpC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAC9C,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnE,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACnB,GAAG,IAAI,CA6BP"}

package/dist/archive-zip-names.js

@@ -0,0 +1,99 @@
+import { ArchiveFormatError, ArchiveSecurityError } from "./archive-errors.js";
+import { validateArchiveEntryPath } from "./archive-entry.js";
+import { updateCrc32 } from "./archive-crc32.js";
+export function zipFormat(message) {
+    throw new ArchiveFormatError(`invalid ZIP metadata: ${message}`);
+}
+export function zipUInt64(bytes, offset) {
+    if (offset + 8 > bytes.length)
+        zipFormat("truncated ZIP64 field");
+    const value = bytes.readBigUInt64LE(offset);
+    if (value > BigInt(Number.MAX_SAFE_INTEGER))
+        zipFormat("ZIP64 integer exceeds safe range");
+    return Number(value);
+}
+export function zipExtraFields(bytes) {
+    const critical = new Map();
+    for (let offset = 0; offset < bytes.length;) {
+        if (offset + 4 > bytes.length)
+            zipFormat("truncated extra field header");
+        const id = bytes.readUInt16LE(offset);
+        const length = bytes.readUInt16LE(offset + 2);
+        offset += 4;
+        if (length > bytes.length - offset)
+            zipFormat("truncated extra field value");
+        if (id === 1 || id === 0x7075) {
+            if (critical.has(id))
+                zipFormat("duplicate critical extra field");
+            critical.set(id, bytes.subarray(offset, offset + length));
+        }
+        offset += length;
+    }
+    return critical;
+}
+function utf8(bytes) {
+    try {
+        return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
+    }
+    catch {
+        return zipFormat("invalid UTF-8 name");
+    }
+}
+function key(name) {
+    return name.replaceAll("\\", "/").split("/").filter((part) => part && part !== ".").join("/");
+}
+function originalName(name, flags) {
+    // ASCII path syntax is encoding-independent. Do not reinterpret legacy bytes
+    // as UTF-8 (native ZIP uses CP437); the selected decoder still validates its name.
+    validateArchiveEntryPath(Array.from(name, (byte) => byte < 128 ? String.fromCharCode(byte) : "_").join(""));
+    if (!(flags & 0x800))
+        return undefined;
+    const decoded = utf8(name);
+    validateArchiveEntryPath(decoded);
+    return decoded;
+}
+function unicodeName(name, extra) {
+    const field = extra.get(0x7075);
+    if (!field)
+        return undefined;
+    if (field.length < 6 || field[0] !== 1)
+        zipFormat("invalid Unicode Path field");
+    if (field.readUInt32LE(1) !== updateCrc32(0, name))
+        zipFormat("Unicode Path CRC mismatch");
+    const decoded = utf8(field.subarray(5));
+    validateArchiveEntryPath(decoded);
+    return decoded;
+}
+export function admitZipNames(params) {
+    const { central, local, flags, centralExtra, localExtra, seen } = params;
+    if (!central.length || !local.length)
+        zipFormat("empty entry name");
+    const centralUtf8 = originalName(central, flags);
+    const localUtf8 = originalName(local, flags);
+    const centralUnicode = unicodeName(central, centralExtra);
+    const localUnicode = unicodeName(local, localExtra);
+    if (key(central.toString("latin1")) !== key(local.toString("latin1"))) {
+        zipFormat("central and local names disagree");
+    }
+    const interpretations = [centralUtf8, localUtf8, centralUnicode, localUnicode].filter((value) => value !== undefined);
+    if (interpretations.some((value) => key(value) !== key(interpretations[0]))) {
+        zipFormat("conflicting Unicode name interpretations");
+    }
+    // JSZip checks the central Unicode field against the local name. A slash-only
+    // spelling difference must not make one decoder ignore a meaningful override.
+    if (centralUnicode && !central.equals(local) &&
+        key(centralUnicode) !== key(local.toString("utf8"))) {
+        zipFormat("Unicode override disagrees with local decoder name");
+    }
+    if (!centralUnicode && localUnicode && key(localUnicode) !== key(local.toString("utf8"))) {
+        zipFormat("local-only Unicode override changes the name");
+    }
+    const identities = new Set([key(central.toString("latin1"))]);
+    if (centralUnicode !== undefined)
+        identities.add(key(Buffer.from(centralUnicode).toString("latin1")));
+    if ([...identities].some((identity) => seen.has(identity))) {
+        throw new ArchiveSecurityError("entry-path", "zip archive contains duplicate or colliding entry names");
+    }
+    for (const identity of identities)
+        seen.add(identity);
+}

package/dist/archive-zip-preflight.d.ts

@@ -1,7 +1,7 @@
 import { type ArchiveExtractLimits } from "./archive-limits.js";
+export { readZipCentralDirectoryEntryCount } from "./archive-zip-count.js";
 export type ZipArchiveWithFiles = {
     files: Record<string, unknown>;
 };
-export declare function readZipCentralDirectoryEntryCount(buffer: Buffer | Uint8Array): number | null;
 export declare function loadZipArchiveWithPreflight(buffer: Buffer | Uint8Array, limits?: ArchiveExtractLimits): Promise<ZipArchiveWithFiles>;
 //# sourceMappingURL=archive-zip-preflight.d.ts.map

package/dist/archive-zip-preflight.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"archive-zip-preflight.d.ts","sourceRoot":"","sources":["../src/archive-zip-preflight.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,oBAAoB,EAC1B,MAAM,qBAAqB,CAAC;AAG7B,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC,CAAC;AAiLF,wBAAgB,iCAAiC,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,GAAG,MAAM,GAAG,IAAI,CAU5F;AAED,wBAAsB,2BAA2B,CAC/C,MAAM,EAAE,MAAM,GAAG,UAAU,EAC3B,MAAM,CAAC,EAAE,oBAAoB,GAC5B,OAAO,CAAC,mBAAmB,CAAC,CA0B9B"}
+{"version":3,"file":"archive-zip-preflight.d.ts","sourceRoot":"","sources":["../src/archive-zip-preflight.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,oBAAoB,EAC1B,MAAM,qBAAqB,CAAC;AAI7B,OAAO,EAAE,iCAAiC,EAAE,MAAM,wBAAwB,CAAC;AAE3E,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC,CAAC;AAMF,wBAAsB,2BAA2B,CAC/C,MAAM,EAAE,MAAM,GAAG,UAAU,EAC3B,MAAM,CAAC,EAAE,oBAAoB,GAC5B,OAAO,CAAC,mBAAmB,CAAC,CAwB9B"}