@poe-platform/safe-bash 0.1.617 → 0.1.619

package/dist/safe-bash/core.browser.js

@@ -26688,6 +26688,30 @@ function stripZip64(bytes3) {
   }
   return result;
 }
+function zip64Extra(values, retained) {
+  if (retained.length + 4 + values.length * 8 > 65535) fail("ZIP64 extra field limit exceeded");
+  const bytes3 = new Uint8Array(4 + values.length * 8 + retained.length);
+  const view = new DataView(bytes3.buffer);
+  view.setUint16(0, 1, true);
+  view.setUint16(2, values.length * 8, true);
+  values.forEach((value2, index) => view.setBigUint64(4 + index * 8, BigInt(value2), true));
+  bytes3.set(retained, 4 + values.length * 8);
+  return bytes3;
+}
+function writeZip64End(view, offset, count2, size, start, recordOffset = offset) {
+  view.setUint32(offset, 101075792, true);
+  view.setBigUint64(offset + 4, 44n, true);
+  view.setUint16(offset + 12, 813, true);
+  view.setUint16(offset + 14, 45, true);
+  view.setBigUint64(offset + 24, BigInt(count2), true);
+  view.setBigUint64(offset + 32, BigInt(count2), true);
+  view.setBigUint64(offset + 40, BigInt(size), true);
+  view.setBigUint64(offset + 48, BigInt(start), true);
+  view.setUint32(offset + 56, 117853008, true);
+  view.setBigUint64(offset + 64, BigInt(recordOffset), true);
+  view.setUint32(offset + 72, 1, true);
+  return offset + 76;
+}
 
 // packages/safe-bash/src/commands/archive/zip-format.ts
 var encoder2 = new TextEncoder();
@@ -27031,11 +27055,43 @@ function timestampExtra(modified) {
   view.setInt32(5, seconds, true);
   return bytes3;
 }
-async function writeZipArchive(archive, limits, signal, descriptors = false) {
+function updateZipExtras(entry, previous, mode, limits) {
+  const fresh = mode === "strip" ? new Uint8Array() : timestampExtra(entry.modified);
+  const retained = [];
+  for (const [original, central] of [[previous?.localExtra, false], [previous?.centralExtra, true]]) {
+    const fields3 = [];
+    let length = fresh.length;
+    if (mode === "all" && original) {
+      extras(original, previous.rawName ?? pathBytes(previous.name, limits), previous.comment ?? new Uint8Array(), central, limits);
+      const view = new DataView(original.buffer, original.byteOffset, original.byteLength);
+      for (let offset2 = 0; offset2 < original.length; ) {
+        const identifier = view.getUint16(offset2, true);
+        const next = offset2 + 4 + view.getUint16(offset2 + 2, true);
+        if (identifier !== 1 && identifier !== 21589 && identifier !== 28789 && identifier !== 25461) {
+          fields3.push(original.subarray(offset2, next));
+          length += next - offset2;
+        }
+        offset2 = next;
+      }
+    }
+    number3(length, Math.min(limits.maxPaxBytes, 65535), "extra field");
+    const bytes3 = new Uint8Array(length);
+    let offset = 0;
+    for (const field2 of fields3) {
+      bytes3.set(field2, offset);
+      offset += field2.length;
+    }
+    bytes3.set(fresh, offset);
+    retained.push(bytes3);
+  }
+  return { ...entry, localExtra: retained[0], centralExtra: retained[1] };
+}
+async function* streamZipArchive(archive, limits, signal, descriptors = false, forceZip64 = false) {
   const chunkSize2 = admit(limits, signal);
   number3(archive.entries.length, Math.min(limits.maxMembers, 65534), "member");
   number3(archive.comment.length, Math.min(limits.maxTextBytes, 65535), "archive comment");
-  let length = 22 + archive.comment.length;
+  const wideArchive = forceZip64 || archive.entries.some((entry) => entry.zip64);
+  let length = 22 + archive.comment.length + (wideArchive ? 76 : 0);
   let localLength = 0;
   let total = 0;
   const encoded2 = [];
@@ -27046,17 +27102,18 @@ async function writeZipArchive(archive, limits, signal, descriptors = false) {
     total += entry.size;
     number3(total, limits.maxTotalBytes, "total byte");
     const rawName = entry.rawName ?? pathBytes(entry.name, limits);
-    const descriptor = descriptors && !entry.directory;
+    const descriptor = (descriptors || entry.descriptors === true) && !entry.directory;
     const flags3 = (entry.flags ?? 2048) & ~8 | (descriptor ? 8 : 0);
     const comment2 = entry.comment ?? new Uint8Array();
     number3(comment2.length, Math.min(limits.maxTextBytes, 65535), "entry comment");
     if (flags3 & 2048) text2(comment2);
     const originalLocalExtra = entry.localExtra ?? timestampExtra(entry.modified);
     extras(originalLocalExtra, rawName, comment2, false, limits);
-    const localExtra = stripZip64(originalLocalExtra);
+    const wide2 = forceZip64 || entry.zip64 === true;
+    const localExtra = wide2 ? zip64Extra([descriptor ? 0 : entry.size, descriptor ? 0 : entry.data.length], stripZip64(originalLocalExtra)) : stripZip64(originalLocalExtra);
     const originalCentralExtra = entry.centralExtra ?? timestampExtra(entry.modified);
     extras(originalCentralExtra, rawName, comment2, true, limits);
-    const centralExtra = stripZip64(originalCentralExtra);
+    const centralExtra = wide2 ? zip64Extra([entry.size, entry.data.length, localLength], stripZip64(originalCentralExtra)) : stripZip64(originalCentralExtra);
     const localMetadata = extras(localExtra, rawName, comment2, false, limits);
     const centralMetadata = extras(centralExtra, rawName, comment2, true, limits);
     if (nameFrom(rawName, flags3, centralMetadata, limits) !== entry.name || localMetadata.name !== void 0 && nameFrom(rawName, flags3, localMetadata, limits) !== entry.name || entry.localName && !equal(rawName, entry.localName)) fail("ZIP retained filename metadata mismatch");
@@ -27078,71 +27135,101 @@ async function writeZipArchive(archive, limits, signal, descriptors = false) {
       const mode = unixMode || (entry.directory ? 16877 : 33188);
       if (mode !== entry.mode || Boolean(entry.externalAttributes & 16) && !entry.directory) fail("ZIP retained file attributes mismatch");
     }
-    encoded2.push({ entry, rawName, flags: flags3, localExtra, centralExtra, comment: comment2, date: date2, time, offset: localLength });
-    localLength += 30 + rawName.length + localExtra.length + entry.data.length + (descriptor ? 16 : 0);
-    length += 76 + 2 * rawName.length + localExtra.length + centralExtra.length + comment2.length + entry.data.length + (descriptor ? 16 : 0);
+    encoded2.push({ entry, rawName, wide: wide2, flags: flags3, localExtra, centralExtra, comment: comment2, date: date2, time, offset: localLength });
+    localLength += 30 + rawName.length + localExtra.length + entry.data.length + (descriptor ? wide2 ? 24 : 16 : 0);
+    length += 76 + 2 * rawName.length + localExtra.length + centralExtra.length + comment2.length + entry.data.length + (descriptor ? wide2 ? 24 : 16 : 0);
     number3(length, Math.min(limits.maxArchiveBytes, 4294967294), "archive byte");
   }
   number3(length, Math.min(limits.maxArchiveBytes, 4294967294), "archive byte");
-  const bytes3 = new Uint8Array(length);
-  const view = new DataView(bytes3.buffer);
-  let central = localLength;
   for (const item of encoded2) {
     await yieldTurn(signal);
-    const { entry, rawName, flags: flags3, localExtra, centralExtra, comment: comment2, date: date2, time, offset } = item;
-    const version = entry.method === 8 || flags3 & 8 ? 20 : 10;
-    view.setUint32(offset, 67324752, true);
-    view.setUint16(offset + 4, version, true);
-    view.setUint16(offset + 6, flags3, true);
-    view.setUint16(offset + 8, entry.method, true);
-    view.setUint16(offset + 10, time, true);
-    view.setUint16(offset + 12, date2, true);
-    view.setUint32(offset + 14, flags3 & 8 ? 0 : entry.crc32, true);
-    view.setUint32(offset + 18, flags3 & 8 ? 0 : entry.data.length, true);
-    view.setUint32(offset + 22, flags3 & 8 ? 0 : entry.size, true);
-    view.setUint16(offset + 26, rawName.length, true);
-    view.setUint16(offset + 28, localExtra.length, true);
-    bytes3.set(rawName, offset + 30);
-    bytes3.set(localExtra, offset + 30 + rawName.length);
-    await copyBytes(entry.data, bytes3, offset + 30 + rawName.length + localExtra.length, chunkSize2, signal);
+    const { entry, rawName, wide: wide2, flags: flags3, localExtra, date: date2, time } = item;
+    const offset = 0;
+    const bytes4 = new Uint8Array(30 + rawName.length + localExtra.length);
+    const view2 = new DataView(bytes4.buffer);
+    const version = wide2 ? 45 : entry.method === 8 || flags3 & 8 ? 20 : 10;
+    view2.setUint32(offset, 67324752, true);
+    view2.setUint16(offset + 4, version, true);
+    view2.setUint16(offset + 6, flags3, true);
+    view2.setUint16(offset + 8, entry.method, true);
+    view2.setUint16(offset + 10, time, true);
+    view2.setUint16(offset + 12, date2, true);
+    view2.setUint32(offset + 14, flags3 & 8 ? 0 : entry.crc32, true);
+    view2.setUint32(offset + 18, wide2 ? 4294967295 : flags3 & 8 ? 0 : entry.data.length, true);
+    view2.setUint32(offset + 22, wide2 ? 4294967295 : flags3 & 8 ? 0 : entry.size, true);
+    view2.setUint16(offset + 26, rawName.length, true);
+    view2.setUint16(offset + 28, localExtra.length, true);
+    bytes4.set(rawName, offset + 30);
+    bytes4.set(localExtra, offset + 30 + rawName.length);
+    yield* wireChunks(bytes4, chunkSize2, signal);
+    yield* wireChunks(entry.data, chunkSize2, signal);
     if (flags3 & 8) {
-      const descriptor = offset + 30 + rawName.length + localExtra.length + entry.data.length;
-      view.setUint32(descriptor, 134695760, true);
-      view.setUint32(descriptor + 4, entry.crc32, true);
-      view.setUint32(descriptor + 8, entry.data.length, true);
-      view.setUint32(descriptor + 12, entry.size, true);
-    }
-    view.setUint32(central, 33639248, true);
-    view.setUint16(central + 4, entry.versionMadeBy ?? 798, true);
-    view.setUint16(central + 6, version, true);
-    view.setUint16(central + 8, flags3, true);
-    view.setUint16(central + 10, entry.method, true);
-    view.setUint16(central + 12, time, true);
-    view.setUint16(central + 14, date2, true);
-    view.setUint32(central + 16, entry.crc32, true);
-    view.setUint32(central + 20, entry.data.length, true);
-    view.setUint32(central + 24, entry.size, true);
-    view.setUint16(central + 28, rawName.length, true);
-    view.setUint16(central + 30, centralExtra.length, true);
-    view.setUint16(central + 32, comment2.length, true);
-    view.setUint16(central + 36, entry.internalAttributes ?? 0, true);
-    const mode = entry.mode & 61440 ? entry.mode : entry.mode | (entry.directory ? 16384 : entry.symlink ? 40960 : 32768);
-    view.setUint32(central + 38, entry.externalAttributes ?? mode * 65536 + (entry.directory ? 16 : 0), true);
-    view.setUint32(central + 42, offset, true);
-    bytes3.set(rawName, central + 46);
-    bytes3.set(centralExtra, central + 46 + rawName.length);
-    bytes3.set(comment2, central + 46 + rawName.length + centralExtra.length);
-    central += 46 + rawName.length + centralExtra.length + comment2.length;
+      const descriptor = 0;
+      const bytes5 = new Uint8Array(wide2 ? 24 : 16);
+      const view3 = new DataView(bytes5.buffer);
+      view3.setUint32(descriptor, 134695760, true);
+      view3.setUint32(descriptor + 4, entry.crc32, true);
+      if (wide2) {
+        view3.setBigUint64(descriptor + 8, BigInt(entry.data.length), true);
+        view3.setBigUint64(descriptor + 16, BigInt(entry.size), true);
+      } else {
+        view3.setUint32(descriptor + 8, entry.data.length, true);
+        view3.setUint32(descriptor + 12, entry.size, true);
+      }
+      yield* wireChunks(bytes5, chunkSize2, signal);
+    }
   }
+  let centralSize = 0;
+  for (const item of encoded2) {
+    await yieldTurn(signal);
+    const { entry, rawName, wide: wide2, flags: flags3, centralExtra, comment: comment2, date: date2, time, offset } = item;
+    const version = wide2 ? 45 : entry.method === 8 || flags3 & 8 ? 20 : 10;
+    const central2 = 0;
+    const bytes4 = new Uint8Array(46 + rawName.length + centralExtra.length + comment2.length);
+    const view2 = new DataView(bytes4.buffer);
+    view2.setUint32(central2, 33639248, true);
+    view2.setUint16(central2 + 4, entry.versionMadeBy ?? 798, true);
+    view2.setUint16(central2 + 6, version, true);
+    view2.setUint16(central2 + 8, flags3, true);
+    view2.setUint16(central2 + 10, entry.method, true);
+    view2.setUint16(central2 + 12, time, true);
+    view2.setUint16(central2 + 14, date2, true);
+    view2.setUint32(central2 + 16, entry.crc32, true);
+    view2.setUint32(central2 + 20, wide2 ? 4294967295 : entry.data.length, true);
+    view2.setUint32(central2 + 24, wide2 ? 4294967295 : entry.size, true);
+    view2.setUint16(central2 + 28, rawName.length, true);
+    view2.setUint16(central2 + 30, centralExtra.length, true);
+    view2.setUint16(central2 + 32, comment2.length, true);
+    view2.setUint16(central2 + 36, entry.internalAttributes ?? 0, true);
+    const mode = entry.mode & 61440 ? entry.mode : entry.mode | (entry.directory ? 16384 : entry.symlink ? 40960 : 32768);
+    view2.setUint32(central2 + 38, entry.externalAttributes ?? mode * 65536 + (entry.directory ? 16 : 0), true);
+    view2.setUint32(central2 + 42, wide2 ? 4294967295 : offset, true);
+    bytes4.set(rawName, central2 + 46);
+    bytes4.set(centralExtra, central2 + 46 + rawName.length);
+    bytes4.set(comment2, central2 + 46 + rawName.length + centralExtra.length);
+    centralSize += bytes4.length;
+    yield* wireChunks(bytes4, chunkSize2, signal);
+  }
+  const bytes3 = new Uint8Array((wideArchive ? 76 : 0) + 22 + archive.comment.length);
+  const view = new DataView(bytes3.buffer);
+  const central = wideArchive ? writeZip64End(view, 0, encoded2.length, centralSize, localLength, localLength + centralSize) : 0;
   view.setUint32(central, 101010256, true);
   view.setUint16(central + 8, encoded2.length, true);
   view.setUint16(central + 10, encoded2.length, true);
-  view.setUint32(central + 12, central - localLength, true);
-  view.setUint32(central + 16, localLength, true);
+  view.setUint32(central + 12, centralSize, true);
+  view.setUint32(central + 16, wideArchive ? 4294967295 : localLength, true);
   view.setUint16(central + 20, archive.comment.length, true);
   bytes3.set(archive.comment, central + 22);
-  signal.throwIfAborted();
-  return bytes3;
+  yield* wireChunks(bytes3, chunkSize2, signal);
+}
+async function* wireChunks(bytes3, chunkSize2, signal) {
+  for (let offset = 0; offset < bytes3.length; offset += chunkSize2) {
+    await yieldTurn(signal);
+    yield new Uint8Array(bytes3.subarray(offset, Math.min(bytes3.length, offset + chunkSize2)));
+  }
+}
+async function writeZipArchive(archive, limits, signal, descriptors = false, forceZip64 = false) {
+  return collectBytes(streamZipArchive(archive, limits, signal, descriptors, forceZip64), { maxBytes: limits.maxArchiveBytes, signal });
 }
 
 // packages/safe-bash/src/commands/archive/zip/safety.ts
@@ -27513,7 +27600,10 @@ var longOptions = {
   "compress-6": "6",
   "compress-7": "7",
   "compress-8": "8",
-  "compress-9": "9"
+  "compress-9": "9",
+  "force-zip64": "fz",
+  "strip-extra": "X",
+  "force-descriptors": "fd"
 };
 var reservedOptions = [
   "adjust-sfx",
@@ -27532,8 +27622,6 @@ var reservedOptions = [
   "fixfix",
   "fifo",
   "filesync",
-  "force-descriptors",
-  "force-zip64",
   "grow",
   "help",
   "more-help",
@@ -27569,23 +27657,25 @@ var reservedOptions = [
   "verbose",
   "version",
   "wild-stop-dirs",
-  "strip-extra",
   "archive-comment"
 ];
 function normalizeZipOption(argument2) {
   if (!argument2.startsWith("--") || argument2 === "--") return argument2;
   const equal2 = argument2.indexOf("=");
-  const name2 = argument2.slice(2, equal2 < 0 ? void 0 : equal2);
+  const rawName = argument2.slice(2, equal2 < 0 ? void 0 : equal2);
+  const negate2 = rawName.endsWith("-");
+  const name2 = negate2 ? rawName.slice(0, -1) : rawName;
   const names = [...Object.keys(longOptions), ...reservedOptions];
   const matches2 = names.includes(name2) ? [name2] : names.filter((option) => option.startsWith(name2));
   if (matches2.length > 1) throw new ZipFailure(16, "Invalid command arguments", `long option '${name2}' ambiguous`);
   const matched = matches2[0];
   const short = matched === void 0 ? void 0 : longOptions[matched];
   if (!short) throw new ZipFailure(16, "Invalid command arguments", `unsupported option: ${argument2}`);
+  if (negate2 && short !== "fz" && short !== "X") throw new ZipFailure(16, "Invalid command arguments", `option ${matched} is not negatable`);
   if (equal2 >= 0 && short !== "i" && short !== "x" && short !== "n" && short !== "Z") {
     throw new ZipFailure(16, "Invalid command arguments", `option '${matched}' does not allow a value`);
   }
-  return `-${short}${equal2 < 0 ? "" : argument2.slice(equal2)}`;
+  return `-${short}${negate2 ? "-" : ""}${equal2 < 0 ? "" : argument2.slice(equal2)}`;
 }
 
 // packages/safe-bash/src/commands/archive/zip.ts
@@ -27617,6 +27707,9 @@ async function parse12(scope, limits) {
   let omitDirectories = false;
   let storeLinks = false;
   let test = false;
+  let descriptors = false;
+  let zip64;
+  let metadata3 = "default";
   let level = 6;
   let method = "deflate";
   let suffixes = defaultStoreSuffixes;
@@ -27637,13 +27730,23 @@ async function parse12(scope, limits) {
       for (let offset = 1; offset < argument2.length; offset++) {
         const flag = argument2[offset];
         if (flag === "r") recursive = true;
-        else if (flag === "d" || flag === "u" || flag === "f") {
+        else if (flag === "f" && argument2[offset + 1] === "d") {
+          if (argument2[offset + 2] === "-") throw new ZipFailure(16, "Invalid command arguments", "option fd is not negatable");
+          descriptors = true;
+          offset++;
+        } else if (flag === "f" && argument2[offset + 1] === "z") {
+          zip64 = argument2[offset + 2] !== "-";
+          offset += zip64 ? 1 : 2;
+        } else if (flag === "d" || flag === "u" || flag === "f") {
           const next = flag === "d" ? "delete" : flag === "u" ? "update" : "freshen";
           if (action !== "add" && action !== next) throw new ZipFailure(16, "Invalid command arguments", "specify just one action");
           action = next;
         } else if (flag === "q") quiet = true;
         else if (flag === "j") junkPaths = true;
-        else if (flag === "D") omitDirectories = true;
+        else if (flag === "X") {
+          metadata3 = argument2[offset + 1] === "-" ? "all" : "strip";
+          if (metadata3 === "all") offset++;
+        } else if (flag === "D") omitDirectories = true;
         else if (flag === "y") storeLinks = true;
         else if (flag === "T") test = true;
         else if (flag === "@") stdinNames = true;
@@ -27732,7 +27835,7 @@ async function parse12(scope, limits) {
       start = end + 1;
     }
   }
-  return { action, archive, recursive, quiet, junkPaths, omitDirectories, storeLinks, test, includes, excludes, level, method, suffixes, operands: [...names, ...operands], firstOperand };
+  return { action, archive, recursive, quiet, junkPaths, omitDirectories, storeLinks, test, descriptors, zip64, metadata: metadata3, includes, excludes, level, method, suffixes, operands: [...names, ...operands], firstOperand };
 }
 function memberName(path, limits) {
   if (path.startsWith("//") && !path.startsWith("///")) fail("UNC source paths are unsupported");
@@ -27813,9 +27916,12 @@ async function prepare(scope, parsed, budget) {
     const store = parsed.method === "store" || parsed.level !== 9 && parsed.suffixes.some((suffix2) => name2.endsWith(suffix2));
     if (!store && parsed.level === 0 && bytes4.length && !attributes.directory && !attributes.symlink) throw new ZipFailure(5, "Internal logic error", "bad pack level");
     const level = store ? 0 : parsed.level;
-    let entry = await makeZipEntry(name2, bytes4, attributes, limits, context2.signal, level, parsed.archive === "-" && !store);
+    let entry = await makeZipEntry(name2, bytes4, attributes, limits, context2.signal, level, !store && (parsed.archive === "-" || parsed.descriptors && bytes4.length > 0));
+    if (parsed.descriptors) entry.descriptors = true;
+    if (parsed.zip64 === true || parsed.zip64 === void 0 && source2 === "-") entry.zip64 = true;
     const prior = old.get(name2);
     if (prior?.comment) entry = { ...entry, comment: prior.comment };
+    if (parsed.metadata !== "default") entry = updateZipExtras(entry, prior, parsed.metadata, limits);
     if (entry.data.length > limits.maxArchiveBytes - compressedBytes) fail("archive byte limit exceeded");
     compressedBytes += entry.data.length;
     selected.set(name2, { entry, source: source2 });
@@ -27971,7 +28077,8 @@ async function prepare(scope, parsed, budget) {
     append(entry, false);
   }
   if (!entries2.length) queue("	zip warning: zip file empty\n");
-  const bytes3 = await writeZipArchive({ entries: entries2, comment: archive.comment }, limits, context2.signal, parsed.archive === "-");
+  if (parsed.archive === "-") return { kind: "stream", archive: { entries: entries2, comment: archive.comment }, progress };
+  const bytes3 = await writeZipArchive({ entries: entries2, comment: archive.comment }, limits, context2.signal, false, parsed.zip64 === true);
   if (parsed.test && parsed.archive !== "-") {
     for (const message3 of progress) await budget.output(message3);
     progress.length = 0;
@@ -27997,7 +28104,7 @@ async function prepare(scope, parsed, budget) {
 `);
     }
   }
-  return { publication, bytes: bytes3, progress };
+  return { kind: "file", publication, bytes: bytes3, progress };
 }
 function createZipCommand(options2 = {}) {
   const limits = settings2(options2);
@@ -28011,15 +28118,18 @@ function createZipCommand(options2 = {}) {
       if (parsed.archive === "-") budget = new Budget14({ ...context2, stdout: context2.stderr }, limits);
       const prepared = await prepare(scope, parsed, budget);
       if (!prepared) return { exitCode: 12 };
-      const publication = prepared.publication;
-      if (publication) {
+      if (prepared.kind === "file") {
+        const publication = prepared.publication;
+        if (!publication) fail("ZIP missing file publication");
         await writeFileOutput(context2, prepared.bytes, () => scope.operation(() => publishZip(scope, { ...publication, bytes: prepared.bytes })));
         for (const message3 of prepared.progress) await budget.output(message3);
       } else {
         for (const message3 of prepared.progress) await budget.output(message3);
         const output2 = createOutputOperation(context2, context2.stdout);
         try {
-          await writeBytes(output2.output, prepared.bytes, output2.signal);
+          for await (const chunk of streamZipArchive(prepared.archive, limits, output2.signal, true, parsed.zip64 === true)) {
+            await writeBytes(output2.output, chunk, output2.signal);
+          }
         } finally {
           await output2.close();
         }