@poe-platform/safe-bash 0.1.799 → 0.1.800

package/dist/safe-bash/command-chunks/chunk-LE5LZNHE.js

@@ -0,0 +1,204 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-zip-engine/src/zip/zip64.ts
+init_buffer();
+import { fail } from "../../safe-bash-io-engine/commands/archive/internal.js";
+function wide(view, offset) {
+  if (offset < 0 || offset + 8 > view.byteLength) fail("ZIP64 truncated numeric field");
+  const value = view.getBigUint64(offset, true);
+  if (value > BigInt(Number.MAX_SAFE_INTEGER)) fail("ZIP64 unsafe numeric field");
+  return Number(value);
+}
+function zipDiskRecord(disks, start, end) {
+  if (!disks) return;
+  let disk = disks.starts.length - 1;
+  while (disk >= 0 && disks.starts[disk] > start) disk--;
+  if (disk < 0 || end > disks.starts[disk] + disks.lengths[disk]) fail("ZIP record straddles volume boundary");
+}
+function zipDiskOffset(disks, disk, offset) {
+  if (!Number.isSafeInteger(disk) || disk < 0 || !Number.isSafeInteger(offset) || offset < 0) fail("ZIP invalid disk offset");
+  if (!disks) {
+    if (disk) fail("ZIP multi-disk archive requires a volume resolver");
+    return offset;
+  }
+  if (disk >= disks.starts.length || offset >= disks.lengths[disk]) fail("ZIP disk offset outside volume");
+  return disks.starts[disk] + offset;
+}
+function zip64Directory(view, end, limits, disks, displacement = 0) {
+  zipDiskRecord(disks, end, view.byteLength);
+  let members = view.getUint16(end + 10, true);
+  let centralSize = view.getUint32(end + 12, true);
+  let centralStart = view.getUint32(end + 16, true);
+  let centralEnd = end;
+  let zip64Disk = -1, zip64DiskMembers = -1;
+  let diskMembers = view.getUint16(end + 8, true);
+  const disk = view.getUint16(end + 4, true);
+  if (!disks && disk) fail("ZIP multi-disk archive requires a volume resolver");
+  const centralDisk = view.getUint16(end + 6, true);
+  if (disks && disk !== disks.starts.length - 1) fail("ZIP final disk number mismatch");
+  if (centralStart !== 4294967295) centralStart = zipDiskOffset(disks, centralDisk, centralStart);
+  if (centralStart !== 4294967295) centralStart += displacement;
+  const locator = end >= 20 && view.getUint32(end - 20, true) === 117853008;
+  if (locator) {
+    zipDiskRecord(disks, end - 20, end);
+    const recordDisk = view.getUint32(end - 16, true);
+    if (view.getUint32(end - 4, true) !== (disks?.starts.length ?? 1)) fail("ZIP64 multi-disk locator count mismatch");
+    centralEnd = zipDiskOffset(disks, recordDisk, wide(view, end - 12)) + displacement;
+    if (centralEnd > end - 76 || view.getUint32(centralEnd, true) !== 101075792) fail("ZIP64 invalid end-record span");
+    const length = wide(view, centralEnd + 4);
+    if (length < 44 || length - 44 > limits.maxPaxBytes || length !== end - 32 - centralEnd) fail("ZIP64 invalid end-record length");
+    zipDiskRecord(disks, centralEnd, centralEnd + 12 + length);
+    const version = view.getUint16(centralEnd + 14, true);
+    if (version < 45 || version > 46) fail("ZIP64 unsupported end-record extraction version");
+    if (view.getUint32(centralEnd + 16, true) !== recordDisk || view.getUint32(centralEnd + 20, true) !== centralDisk) fail("ZIP64 inconsistent disk numbers");
+    const count = wide(view, centralEnd + 32);
+    const wideDiskMembers = wide(view, centralEnd + 24);
+    if (wideDiskMembers > count || recordDisk === disk && wideDiskMembers !== diskMembers && diskMembers !== 65535 || members !== 65535 && members !== count || !disks && wideDiskMembers !== count) fail("ZIP64 inconsistent member count");
+    if (recordDisk === disk) diskMembers = wideDiskMembers;
+    zip64Disk = recordDisk;
+    zip64DiskMembers = wideDiskMembers;
+    const size = wide(view, centralEnd + 40);
+    const start = zipDiskOffset(disks, centralDisk, wide(view, centralEnd + 48)) + displacement;
+    if (centralSize !== 4294967295 && centralSize !== size || centralStart !== 4294967295 && centralStart !== start) fail("ZIP64 inconsistent central directory");
+    members = count;
+    centralSize = size;
+    centralStart = start;
+  } else if (centralSize === 4294967295 || centralStart === 4294967295) fail("ZIP64 missing end record and locator");
+  else if (!disks && diskMembers !== members) fail("ZIP inconsistent member count");
+  if (members > limits.maxMembers) fail("ZIP member limit exceeded");
+  if (centralStart > limits.maxArchiveBytes || centralSize > limits.maxArchiveBytes || centralSize !== centralEnd - centralStart) fail("ZIP invalid central directory span");
+  return { members, centralStart, centralSize, centralEnd, diskMembers, disk, zip64Disk, zip64DiskMembers };
+}
+function zip64Fields(data, values) {
+  let offset = 0;
+  const view = data && new DataView(data.buffer, data.byteOffset, data.byteLength);
+  return values.map((value, index) => {
+    if (value !== 4294967295) return value;
+    if (!view) fail("ZIP64 missing required extra field");
+    const width = index === 3 ? 4 : 8;
+    if (offset + width > view.byteLength) fail("ZIP64 truncated extra field");
+    const resolved = width === 4 ? view.getUint32(offset, true) : wide(view, offset);
+    offset += width;
+    return resolved;
+  });
+}
+function stripZip64(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const retained = [];
+  let length = 0;
+  for (let offset2 = 0; offset2 < bytes.length; ) {
+    if (offset2 + 4 > bytes.length) fail("ZIP truncated extra field");
+    const next = offset2 + 4 + view.getUint16(offset2 + 2, true);
+    if (next > bytes.length) fail("ZIP truncated extra field payload");
+    if (view.getUint16(offset2, true) !== 1) {
+      retained.push(bytes.subarray(offset2, next));
+      length += next - offset2;
+    }
+    offset2 = next;
+  }
+  const result = new Uint8Array(length);
+  let offset = 0;
+  for (const field of retained) {
+    result.set(field, offset);
+    offset += field.length;
+  }
+  return result;
+}
+function zip64Extra(values, retained) {
+  values.forEach(counter);
+  if (retained.length + 4 + values.length * 8 > 65535) fail("ZIP64 extra field limit exceeded");
+  const bytes = new Uint8Array(4 + values.length * 8 + retained.length);
+  const view = new DataView(bytes.buffer);
+  view.setUint16(0, 1, true);
+  view.setUint16(2, values.length * 8, true);
+  values.forEach((value, index) => view.setBigUint64(4 + index * 8, BigInt(value), true));
+  bytes.set(retained, 4 + values.length * 8);
+  return bytes;
+}
+function writeZip64End(view, offset, count, size, start, recordOffset = offset) {
+  [offset, count, size, start, recordOffset].forEach(counter);
+  if (offset > view.byteLength - 76) fail("ZIP64 truncated end-record destination");
+  view.setUint32(offset, 101075792, true);
+  view.setBigUint64(offset + 4, 44n, true);
+  view.setUint16(offset + 12, 813, true);
+  view.setUint16(offset + 14, 45, true);
+  view.setUint32(offset + 16, 0, true);
+  view.setUint32(offset + 20, 0, true);
+  view.setBigUint64(offset + 24, BigInt(count), true);
+  view.setBigUint64(offset + 32, BigInt(count), true);
+  view.setBigUint64(offset + 40, BigInt(size), true);
+  view.setBigUint64(offset + 48, BigInt(start), true);
+  view.setUint32(offset + 56, 117853008, true);
+  view.setUint32(offset + 60, 0, true);
+  view.setBigUint64(offset + 64, BigInt(recordOffset), true);
+  view.setUint32(offset + 72, 1, true);
+  return offset + 76;
+}
+function counter(value) {
+  if (!Number.isSafeInteger(value) || value < 0) fail("ZIP64 unsafe or invalid numeric field");
+}
+function zip64Member(size, compressed, offset, force = false, allowed = true, forceSizes = false) {
+  [size, compressed, offset].forEach(counter);
+  const widths = [size, compressed, offset].map((value, index) => force || forceSizes && index < 2 || value >= 4294967295);
+  if (!allowed && widths.some(Boolean)) fail("ZIP64 required but disabled");
+  return {
+    size: widths[0] ? 4294967295 : size,
+    compressed: widths[1] ? 4294967295 : compressed,
+    offset: widths[2] ? 4294967295 : offset,
+    values: [size, compressed, offset].filter((_, index) => widths[index]),
+    wide: widths.some(Boolean)
+  };
+}
+function zipEnd(count, size, start, comment, force = false, allowed = true) {
+  [count, size, start].forEach(counter);
+  if (size > Number.MAX_SAFE_INTEGER - start) fail("ZIP64 unsafe directory sum");
+  if (comment.length > 65535) fail("ZIP archive comment limit exceeded");
+  const wide2 = force || count >= 65535 || size >= 4294967295 || start >= 4294967295;
+  if (wide2 && !allowed) fail("ZIP64 required but disabled");
+  const length = (wide2 ? 76 : 0) + 22 + comment.length;
+  if (start + size > Number.MAX_SAFE_INTEGER - length) fail("ZIP64 unsafe archive sum");
+  const bytes = new Uint8Array(length);
+  const view = new DataView(bytes.buffer);
+  const end = wide2 ? writeZip64End(view, 0, count, size, start, start + size) : 0;
+  view.setUint32(end, 101010256, true);
+  view.setUint16(end + 8, Math.min(count, 65535), true);
+  view.setUint16(end + 10, Math.min(count, 65535), true);
+  view.setUint32(end + 12, size >= 4294967295 ? 4294967295 : size, true);
+  view.setUint32(end + 16, start >= 4294967295 ? 4294967295 : start, true);
+  view.setUint16(end + 20, comment.length, true);
+  bytes.set(comment, end + 22);
+  return bytes;
+}
+function zipDescriptor(checksum, compressed, size, wide2, signed = true) {
+  [checksum, compressed, size].forEach(counter);
+  if (checksum > 4294967295) fail("ZIP invalid descriptor checksum");
+  if (!wide2 && (compressed >= 4294967295 || size >= 4294967295)) fail("ZIP64 descriptor required");
+  const bytes = new Uint8Array((signed ? 4 : 0) + (wide2 ? 20 : 12));
+  const view = new DataView(bytes.buffer);
+  const base = signed ? 4 : 0;
+  if (signed) view.setUint32(0, 134695760, true);
+  view.setUint32(base, checksum, true);
+  if (wide2) {
+    view.setBigUint64(base + 4, BigInt(compressed), true);
+    view.setBigUint64(base + 12, BigInt(size), true);
+  } else {
+    view.setUint32(base + 4, compressed, true);
+    view.setUint32(base + 8, size, true);
+  }
+  return bytes;
+}
+
+export {
+  zipDiskRecord,
+  zipDiskOffset,
+  zip64Directory,
+  zip64Fields,
+  stripZip64,
+  zip64Extra,
+  writeZip64End,
+  zip64Member,
+  zipEnd,
+  zipDescriptor
+};

package/dist/safe-bash/command-chunks/chunk-MDH5T4OS.js

@@ -0,0 +1,41 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-network-engine/src/private-address.ts
+init_buffer();
+function privateIPv4(first, second) {
+  return first === 10 || first === 127 || first === 0 || first === 169 && second === 254 || first === 192 && second === 168 || first === 172 && second >= 16 && second <= 31 || first === 100 && second >= 64 && second <= 127 || first === 198 && second >= 18 && second <= 19 || first >= 224;
+}
+function privateHostname(input) {
+  const hostname = input.toLowerCase().replace(/\.$/u, "").replace(/^\[|\]$/gu, "");
+  if (hostname === "localhost" || hostname.endsWith(".localhost") || hostname === "::1") return true;
+  if (hostname.includes(":")) {
+    const [prefix, suffix] = hostname.split("::");
+    const leading = prefix ? prefix.split(":") : [];
+    const trailing = suffix ? suffix.split(":") : [];
+    const hextets = new Array(8).fill(0);
+    for (let index = 0; index < leading.length; index++) hextets[index] = Number.parseInt(leading[index], 16);
+    for (let index = 0; index < trailing.length; index++) hextets[8 - trailing.length + index] = Number.parseInt(trailing[index], 16);
+    if (hextets.every((value) => value === 0)) return true;
+    const mappedIPv4 = hextets.slice(0, 5).every((value) => value === 0) && hextets[5] === 65535;
+    const translatedIPv4 = hextets.slice(0, 4).every((value) => value === 0) && hextets[4] === 65535 && hextets[5] === 0;
+    const nat64IPv4 = hextets[0] === 100 && hextets[1] === 65435 && hextets.slice(2, 6).every((value) => value === 0);
+    const compatibleIPv4 = hextets.slice(0, 6).every((value) => value === 0);
+    if (mappedIPv4 || translatedIPv4 || nat64IPv4 || compatibleIPv4) {
+      return privateIPv4(hextets[6] >>> 8, hextets[6] & 255);
+    }
+    if (hextets[0] === 8194) return privateIPv4(hextets[1] >>> 8, hextets[1] & 255);
+    return (hextets[0] & 65024) === 64512 || (hextets[0] & 65472) === 65152 || (hextets[0] & 65472) === 65216 || (hextets[0] & 65280) === 65280 || hextets[0] === 100 && hextets[1] === 65435 && hextets[2] === 1;
+  }
+  const parts = hostname.split(".");
+  if (parts.length !== 4 || parts.some((part) => !part || Array.from(part).some((character) => character < "0" || character > "9"))) return false;
+  const octets = parts.map(Number);
+  if (octets.some((value) => value < 0 || value > 255)) return false;
+  const [first, second] = octets;
+  return privateIPv4(first, second);
+}
+
+export {
+  privateHostname
+};

package/dist/safe-bash/command-chunks/chunk-MM6HU6CX.js

@@ -0,0 +1,20 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-xz/src/options.ts
+init_buffer();
+import { createOptionsParser, formats } from "../../safe-bash-compression-engine/options.js";
+var xzProfile = { ...formats.xz, format: "xz", names: ["xz", "unxz", "xzcat"] };
+var lzmaProfile = { ...formats.xz, format: "xz", names: ["lzma", "unlzma", "lzcat"] };
+var parse = createOptionsParser([xzProfile, lzmaProfile]);
+function parseOptions(command, args) {
+  const legacy = lzmaProfile.names.some((name) => name === command);
+  return parse(command, legacy ? ["--format=lzma", ...args] : args);
+}
+
+export {
+  xzProfile,
+  lzmaProfile,
+  parseOptions
+};

package/dist/safe-bash/command-chunks/{chunk-MYJAZ3U2.js → chunk-MPL2466A.js}

@@ -1,9 +1,9 @@
 import {
   pipeRow
-} from "./chunk-G4PNVO6Z.js";
+} from "./chunk-KP7AO66M.js";
 import {
   normalizeLabel
-} from "./chunk-2ENZ6JGA.js";
+} from "./chunk-KEV7C3KH.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/{chunk-VZHRZMS7.js → chunk-NAY27PXB.js}

@@ -5,7 +5,7 @@ import {
   outputFailure,
   removeManagedAbortWaiter,
   writeBytes
-} from "./chunk-TYVCKQDH.js";
+} from "./chunk-J5SN3PZ3.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/chunk-NCD7PEWH.js

@@ -0,0 +1,298 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-unzip/src/sync.ts
+init_buffer();
+import { inflateRaw as inflateRawSync } from "pako";
+import { crc32 } from "../../safe-bash-zip-engine/zip-format.js";
+import { DEFAULT_ARCHIVE_LIMITS } from "../../safe-bash-io-engine/commands/archive/internal.js";
+var syncTextDecoder = new TextDecoder();
+function filteredZipName(name) {
+  let output = "";
+  for (const character of name) {
+    const code = character.charCodeAt(0);
+    output += code < 32 ? `^${String.fromCharCode(code + 64)}` : character;
+  }
+  return output;
+}
+function evalSyncUnzip(args, readFile, writeFile, mkdir) {
+  if (!readFile || args.length === 0) return void 0;
+  let zipinfoNames = false;
+  let pipe = false;
+  let list = false;
+  let testMode = false;
+  let caseInsensitive = false;
+  let overwrite = false;
+  let destDir;
+  let quiet = 0;
+  let archive;
+  const patterns = [];
+  const excludePatterns = [];
+  let inExclude = false;
+  let ended = false;
+  const zipGlobToRe = (pat) => {
+    let re = "^";
+    for (let idx = 0; idx < pat.length; idx++) {
+      const ch = pat[idx];
+      if (ch === "*") re += ".*";
+      else if (ch === "?") re += ".";
+      else if (ch === "[") {
+        const close = pat.indexOf("]", idx + 1);
+        if (close > idx + 1) {
+          re += pat.slice(idx, close + 1);
+          idx = close;
+        } else re += "\\[";
+      } else re += ch.replace(/[.+^$(){}|\\]/g, "\\$&");
+    }
+    return new RegExp(re + "$", caseInsensitive ? "iu" : "u");
+  };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (!ended && a === "--") {
+      ended = true;
+      continue;
+    }
+    if (!ended && archive !== void 0 && a === "-x") {
+      inExclude = true;
+      continue;
+    }
+    if (!ended && (a === "-d" || a.startsWith("-d"))) {
+      const d = a === "-d" ? args[++i] : a.slice(2);
+      if (!d) return void 0;
+      destDir = d;
+      continue;
+    }
+    if (!ended && archive === void 0 && a.startsWith("-") && a !== "-") {
+      if (a === "-Z1" && i === 0) {
+        zipinfoNames = true;
+        continue;
+      }
+      for (let c = 1; c < a.length; c++) {
+        const ch = a[c];
+        if (ch === "p") pipe = true;
+        else if (ch === "l") list = true;
+        else if (ch === "t") testMode = true;
+        else if (ch === "C") caseInsensitive = true;
+        else if (ch === "o") overwrite = true;
+        else if (ch === "q") quiet++;
+        else return void 0;
+      }
+    } else if (archive === void 0) {
+      archive = a;
+    } else if (inExclude) {
+      excludePatterns.push(a);
+    } else {
+      patterns.push(a);
+    }
+  }
+  void overwrite;
+  if (!archive) return void 0;
+  const modeCount = (zipinfoNames ? 1 : 0) + (pipe ? 1 : 0) + (list ? 1 : 0) + (testMode ? 1 : 0);
+  if (modeCount > 1) return void 0;
+  const extractMode = modeCount === 0;
+  if (extractMode && (!writeFile || !mkdir)) return void 0;
+  let chosenArchive = archive;
+  let bytes = readFile(archive);
+  if (!bytes) {
+    bytes = readFile(archive + ".zip");
+    if (bytes) chosenArchive = archive + ".zip";
+  }
+  if (!bytes) {
+    bytes = readFile(archive + ".ZIP");
+    if (bytes) chosenArchive = archive + ".ZIP";
+  }
+  if (!bytes || bytes.byteLength < 22) return void 0;
+  try {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    let eocdOffset = -1;
+    const lower = Math.max(0, bytes.byteLength - 22 - 65535);
+    for (let off = bytes.byteLength - 22; off >= lower; off--) {
+      if (view.getUint32(off, true) === 101010256 && off + 22 + view.getUint16(off + 20, true) === bytes.byteLength) {
+        eocdOffset = off;
+        break;
+      }
+    }
+    if (eocdOffset === -1) return void 0;
+    const diskNum = view.getUint16(eocdOffset + 4, true);
+    const cdDisk = view.getUint16(eocdOffset + 6, true);
+    const totalEntries = view.getUint16(eocdOffset + 10, true);
+    const cdSize = view.getUint32(eocdOffset + 12, true);
+    const cdOffset = view.getUint32(eocdOffset + 16, true);
+    const commentLen = view.getUint16(eocdOffset + 20, true);
+    if (diskNum !== 0 || cdDisk !== 0 || totalEntries === 0 || totalEntries === 65535 || cdSize === 4294967295 || cdOffset === 4294967295 || commentLen !== 0) {
+      return void 0;
+    }
+    if (cdOffset + cdSize > eocdOffset) return void 0;
+    const members = [];
+    let ptr = cdOffset;
+    for (let idx = 0; idx < totalEntries; idx++) {
+      if (ptr + 46 > eocdOffset || view.getUint32(ptr, true) !== 33639248) return void 0;
+      const flags = view.getUint16(ptr + 8, true);
+      if (flags & 1) return void 0;
+      const method = view.getUint16(ptr + 10, true);
+      const dosTime = view.getUint16(ptr + 12, true);
+      const dosDate = view.getUint16(ptr + 14, true);
+      const crc = view.getUint32(ptr + 16, true);
+      const compSize = view.getUint32(ptr + 20, true);
+      const uncompSize = view.getUint32(ptr + 24, true);
+      const nameLen = view.getUint16(ptr + 28, true);
+      const extraLen = view.getUint16(ptr + 30, true);
+      const entryCommentLen = view.getUint16(ptr + 32, true);
+      const localOffset = view.getUint32(ptr + 42, true);
+      if (entryCommentLen !== 0 || compSize === 4294967295 || uncompSize === 4294967295 || localOffset === 4294967295) return void 0;
+      if (ptr + 46 + nameLen + extraLen > eocdOffset) return void 0;
+      const nameBytes = bytes.subarray(ptr + 46, ptr + 46 + nameLen);
+      const name = syncTextDecoder.decode(nameBytes);
+      members.push({ name, method, flags, crc, compSize, uncompSize, dosTime, dosDate, localOffset, extraLen });
+      ptr += 46 + nameLen + extraLen + entryCommentLen;
+    }
+    const matchedPatterns = /* @__PURE__ */ new Set();
+    const patRegexes = patterns.map(zipGlobToRe);
+    const exRegexes = excludePatterns.map(zipGlobToRe);
+    const selectedMembers = [];
+    for (const m of members) {
+      if (exRegexes.some((re) => re.test(m.name))) continue;
+      if (patterns.length === 0) {
+        selectedMembers.push(m);
+      } else {
+        let hit = false;
+        for (let pIdx = 0; pIdx < patRegexes.length; pIdx++) {
+          if (patRegexes[pIdx].test(m.name)) {
+            hit = true;
+            matchedPatterns.add(pIdx);
+          }
+        }
+        if (hit) selectedMembers.push(m);
+      }
+    }
+    if (selectedMembers.length === 0 || patterns.length > 0 && matchedPatterns.size !== patterns.length) {
+      return void 0;
+    }
+    if (zipinfoNames) {
+      let out = "";
+      for (const m of selectedMembers) {
+        out += `${filteredZipName(m.name)}
+`;
+      }
+      return out;
+    }
+    if (list) {
+      for (const m of selectedMembers) {
+        if (m.extraLen !== 0) return void 0;
+      }
+      let out = quiet === 0 ? `Archive:  ${filteredZipName(chosenArchive)}
+` : "";
+      out += "  Length      Date    Time    Name\n---------  ---------- -----   ----\n";
+      let totalSize = 0;
+      const pad2 = (v) => String(v).padStart(2, "0");
+      for (const m of selectedMembers) {
+        totalSize += m.uncompSize;
+        const year = (m.dosDate >> 9 & 127) + 1980;
+        const month = m.dosDate >> 5 & 15;
+        const day = m.dosDate & 31;
+        const hour = m.dosTime >> 11 & 31;
+        const minute = m.dosTime >> 5 & 63;
+        const dStr = `${year}-${pad2(month)}-${pad2(day)} ${pad2(hour)}:${pad2(minute)}`;
+        out += `${String(m.uncompSize).padStart(9)}  ${dStr}   ${filteredZipName(m.name)}
+`;
+      }
+      out += `---------                     -------
+${String(totalSize).padStart(9)}                     ${selectedMembers.length} file${selectedMembers.length === 1 ? "" : "s"}
+`;
+      return out;
+    }
+    if (testMode || extractMode) {
+      let out = quiet === 0 ? `Archive:  ${filteredZipName(chosenArchive)}
+` : "";
+      const staged = [];
+      for (const m of selectedMembers) {
+        if (m.localOffset + 30 > bytes.byteLength || view.getUint32(m.localOffset, true) !== 67324752) return void 0;
+        const lNameLen = view.getUint16(m.localOffset + 26, true);
+        const lExtraLen = view.getUint16(m.localOffset + 28, true);
+        const dataStart = m.localOffset + 30 + lNameLen + lExtraLen;
+        const dataEnd = dataStart + m.compSize;
+        if (dataEnd > bytes.byteLength) return void 0;
+        const compSlice = bytes.subarray(dataStart, dataEnd);
+        let decoded;
+        if (m.method === 0) {
+          decoded = compSlice;
+        } else if (m.method === 8) {
+          decoded = inflateRawSync(compSlice);
+        } else {
+          return void 0;
+        }
+        if (decoded.byteLength !== m.uncompSize || crc32(decoded) !== m.crc) return void 0;
+        if (testMode) {
+          if (quiet === 0) {
+            const fn = filteredZipName(m.name);
+            const pad = fn + " ".repeat(Math.max(0, 22 - new TextEncoder().encode(fn).byteLength));
+            out += `    testing: ${pad} OK
+`;
+          }
+        } else {
+          const isDir = m.name.endsWith("/");
+          const clean = m.name.replace(/\/+$/u, "");
+          if (!clean || clean.startsWith("/") || clean.split("/").includes("..")) return void 0;
+          const targetPath = destDir ? `${destDir.replace(/\/+$/u, "")}/${clean}` : clean;
+          const shown = destDir === void 0 ? m.name : `${destDir.endsWith("/") ? destDir : `${destDir}/`}${m.name}`;
+          staged.push({ isDir, path: targetPath, shown, method: m.method, bytes: decoded });
+        }
+      }
+      if (testMode) {
+        if (quiet < 2) out += `No errors detected in compressed data of ${filteredZipName(chosenArchive)}.
+`;
+        return out;
+      }
+      for (const item of staged) {
+        if (item.isDir) {
+          if (!mkdir(item.path, 493)) return void 0;
+          if (quiet === 0) out += `   creating: ${filteredZipName(item.shown)}
+`;
+        } else {
+          const slash = item.path.lastIndexOf("/");
+          if (slash > 0 && !mkdir(item.path.slice(0, slash), 493)) return void 0;
+          if (!writeFile(item.path, item.bytes, 420)) return void 0;
+          if (quiet === 0) {
+            const fn = filteredZipName(item.shown);
+            const pad = fn + " ".repeat(Math.max(0, 22 - new TextEncoder().encode(fn).byteLength));
+            out += `${item.method === 0 ? " extracting" : "  inflating"}: ${pad}  
+`;
+          }
+        }
+      }
+      return out;
+    }
+    if (pipe) {
+      let out = "";
+      for (const m of selectedMembers) {
+        if (m.localOffset + 30 > bytes.byteLength || view.getUint32(m.localOffset, true) !== 67324752) return void 0;
+        const lNameLen = view.getUint16(m.localOffset + 26, true);
+        const lExtraLen = view.getUint16(m.localOffset + 28, true);
+        const dataStart = m.localOffset + 30 + lNameLen + lExtraLen;
+        const dataEnd = dataStart + m.compSize;
+        if (dataEnd > bytes.byteLength) return void 0;
+        const compSlice = bytes.subarray(dataStart, dataEnd);
+        let decoded;
+        if (m.method === 0) {
+          decoded = compSlice;
+        } else if (m.method === 8) {
+          decoded = new Uint8Array(inflateRawSync(compSlice));
+        } else {
+          return void 0;
+        }
+        if (decoded.byteLength !== m.uncompSize || crc32(decoded) !== m.crc) return void 0;
+        out += syncTextDecoder.decode(decoded);
+      }
+      return out;
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+export {
+  evalSyncUnzip,
+  DEFAULT_ARCHIVE_LIMITS
+};