npm - @poe-platform/safe-bash - Versions diffs - 0.1.620 → 0.1.621 - Mend

@poe-platform/safe-bash 0.1.620 → 0.1.621

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (16) hide show

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

@@ -2127,9 +2127,9 @@ function streamCommands(maxTeeTargets = 64, maxTailFollowHandles = 64) {
       for (const name2 of names) {
         const counts = { l: 0, w: 0, m: 0, c: 0 };
         let inWord = false;
-        const word = (whitespace2) => {
-          if (!whitespace2 && !inWord) counts.w++;
-          inWord = !whitespace2;
+        const word = (whitespace3) => {
+          if (!whitespace3 && !inWord) counts.w++;
+          inWord = !whitespace3;
         };
         const utf82 = wcUtf8((point) => {
           if (point !== void 0) counts.m++;
@@ -2493,13 +2493,13 @@ function sortKey(specification) {
   };
 }
 async function keyBytes(line, key, separator, blanks, work) {
-  const fields3 = [];
+  const fields4 = [];
   if (separator !== void 0) {
     let start2 = 0;
     for (let offset = 0; offset <= line.length; offset++) {
       if (offset > 0 && offset % 1024 === 0) await work.charge(1024);
       if (offset === line.length || line[offset] === separator) {
-        fields3.push({ start: start2, end: offset });
+        fields4.push({ start: start2, end: offset });
         start2 = offset + 1;
       }
     }
@@ -2515,12 +2515,12 @@ async function keyBytes(line, key, separator, blanks, work) {
       while (offset < line.length && line[offset] !== 32 && line[offset] !== 9) {
         if (++offset % 1024 === 0) await work.charge(1024);
       }
-      fields3.push({ start: start2, end: offset });
+      fields4.push({ start: start2, end: offset });
     }
   }
   await work.charge(line.length % 1024);
-  const start = (fields3[key.start - 1]?.start ?? line.length) + key.startCharacter - 1;
-  const last = key.end === void 0 ? void 0 : fields3[key.end - 1];
+  const start = (fields4[key.start - 1]?.start ?? line.length) + key.startCharacter - 1;
+  const last = key.end === void 0 ? void 0 : fields4[key.end - 1];
   const end = key.end === void 0 ? line.length : last === void 0 ? line.length : key.endCharacter === void 0 ? last.end : Math.min(last.end, last.start + key.endCharacter);
   return line.subarray(Math.min(start, line.length), Math.max(start, end));
 }
@@ -12459,8 +12459,8 @@ function formatted(format3, values, text3, budget) {
       else if (conversion === "g" || conversion === "G") part = general2(amount, precision ?? 6, flags3.includes("#"));
       else {
         const radix = conversion === "o" ? 8 : conversion === "x" || conversion === "X" ? 16 : 10;
-        const integer9 = BigInt(Math.trunc(amount));
-        part = (/[uoxX]/u.test(conversion) ? BigInt.asUintN(32, integer9) : integer9).toString(radix);
+        const integer10 = BigInt(Math.trunc(amount));
+        part = (/[uoxX]/u.test(conversion) ? BigInt.asUintN(32, integer10) : integer10).toString(radix);
         if (precision !== void 0) {
           const negative = part.startsWith("-");
           admit2(amount === 0 && precision === 0 ? 0 : Math.max(part.length, precision + Number(negative)));
@@ -13320,9 +13320,9 @@ var AwkRuntime = class {
     if (name2 === "NF" && this.store(name2) === this.variables) {
       const length = Math.trunc(number(value2));
       if (!Number.isSafeInteger(length) || length < 0 || length > 1e5) throw new ProgramError("invalid or excessive NF");
-      const fields3 = this.fields.slice(0, length);
-      while (fields3.length < length) fields3.push(unset);
-      this.rebuild(fields3);
+      const fields4 = this.fields.slice(0, length);
+      while (fields4.length < length) fields4.push(unset);
+      this.rebuild(fields4);
       return;
     }
     this.storeScalar(this.store(name2), name2, value2);
@@ -13428,23 +13428,23 @@ var AwkRuntime = class {
   }
   async setRecord(record3) {
     this.budget.check(record3);
-    const fields3 = await this.split(record3, this.varText("FS"), this.varText("RS") === "");
-    this.replaceRecord(record3, fields3);
+    const fields4 = await this.split(record3, this.varText("FS"), this.varText("RS") === "");
+    this.replaceRecord(record3, fields4);
   }
-  replaceRecord(record3, fields3) {
+  replaceRecord(record3, fields4) {
     let fieldBytes = 0;
-    for (const field2 of fields3) {
+    for (const field2 of fields4) {
       if (field2.kind === "string" || field2.kind === "numeric") this.budget.check(field2.text);
       fieldBytes += textSize(field2);
     }
     const owned = this.retention.replace(this.record.length + this.fieldBytes, record3.length + fieldBytes, () => ({
       record: import_buffer.Buffer.from(record3, "latin1").toString("latin1"),
-      fields: fields3.map((field2, index) => field2 === this.fields[index] ? field2 : ownScalar(field2))
+      fields: fields4.map((field2, index) => field2 === this.fields[index] ? field2 : ownScalar(field2))
     }));
     this.record = owned.record;
     this.fields = owned.fields;
     this.fieldBytes = fieldBytes;
-    this.variables.set("NF", numeric(fields3.length));
+    this.variables.set("NF", numeric(fields4.length));
   }
   join(parts, separator, suffix2 = "") {
     this.budget.step(parts.length + 1);
@@ -13462,9 +13462,9 @@ var AwkRuntime = class {
     this.budget.step(this.budget.maxBufferBytes - remaining);
     return parts.join(separator) + suffix2;
   }
-  rebuild(fields3) {
-    const record3 = this.join(fields3.map((value2) => this.asText(value2)), this.varText("OFS"));
-    this.replaceRecord(record3, fields3);
+  rebuild(fields4) {
+    const record3 = this.join(fields4.map((value2) => this.asText(value2)), this.varText("OFS"));
+    this.replaceRecord(record3, fields4);
   }
   async key(items) {
     const pieces = [];
@@ -13480,10 +13480,10 @@ var AwkRuntime = class {
         get: () => index === 0 ? inputValue(this.record) : this.fields[index - 1] ?? unset,
         set: (value2) => {
           if (index === 0) return this.setRecord(this.asText(value2));
-          const fields3 = this.fields.slice();
-          while (fields3.length < index) fields3.push(unset);
-          fields3[index - 1] = value2;
-          this.rebuild(fields3);
+          const fields4 = this.fields.slice();
+          while (fields4.length < index) fields4.push(unset);
+          fields4[index - 1] = value2;
+          this.rebuild(fields4);
         }
       };
     }
@@ -21808,14 +21808,14 @@ function flags(args) {
   }
   return result;
 }
-async function comparisonLines(lines3, whitespace2, budget) {
-  if (whitespace2 === "exact") return lines3;
+async function comparisonLines(lines3, whitespace3, budget) {
+  if (whitespace3 === "exact") return lines3;
   const result = [];
   for (const line of lines3) {
     budget.step(1 + line.length);
     await budget.checkpoint();
     const body = line.endsWith("\n") ? line.slice(0, -1) : line;
-    const normalized = body.replace(/[ \t\v\f\r]+/gu, whitespace2 === "all" ? "" : " ");
+    const normalized = body.replace(/[ \t\v\f\r]+/gu, whitespace3 === "all" ? "" : " ");
     result.push(normalized.endsWith(" ") ? normalized.slice(0, -1) : normalized);
   }
   return result;
@@ -23382,8 +23382,8 @@ function timestamp2(milliseconds) {
   const value2 = available(milliseconds, "timestamp");
   if (Math.abs(value2) > 864e13) throw new FsError("EIO", { message: "invalid filesystem timestamp" });
   const [coefficient = "0", exponent = "0"] = Math.abs(value2).toString().split("e");
-  const [integer9 = "0", fraction = ""] = coefficient.split(".");
-  const digits = BigInt(integer9 + fraction);
+  const [integer10 = "0", fraction = ""] = coefficient.split(".");
+  const digits = BigInt(integer10 + fraction);
   const power2 = Number(exponent) - fraction.length + 6;
   const divisor = power2 < 0 ? 10n ** BigInt(-power2) : 1n;
   const magnitude = power2 < 0 ? (digits + divisor / 2n) / divisor : digits * 10n ** BigInt(power2);
@@ -23435,9 +23435,9 @@ function formatField(text3, code, flags3, width, precision, numeric4, epoch2) {
   if (epoch2 && precision) {
     const decimal4 = text3.indexOf(".");
     const integerWidth = width > precision + 2 && !flags3.includes("-") ? width - precision - 1 : 0;
-    const integer9 = formatField(text3.slice(0, decimal4), code, flags3, integerWidth, void 0, true, false);
-    const trailingWidth = integer9.length < width && 1 < width - integer9.length ? Math.abs(width - integer9.length - 1 - precision) : 0;
-    return import_buffer.Buffer.concat([integer9, import_buffer.Buffer.from(text3.slice(decimal4)), import_buffer.Buffer.alloc(trailingWidth, 32)]);
+    const integer10 = formatField(text3.slice(0, decimal4), code, flags3, integerWidth, void 0, true, false);
+    const trailingWidth = integer10.length < width && 1 < width - integer10.length ? Math.abs(width - integer10.length - 1 - precision) : 0;
+    return import_buffer.Buffer.concat([integer10, import_buffer.Buffer.from(text3.slice(decimal4)), import_buffer.Buffer.alloc(trailingWidth, 32)]);
   }
   const encoded2 = import_buffer.Buffer.from(text3);
   const bytes3 = !numeric4 && precision !== void 0 ? encoded2.subarray(0, precision) : encoded2;
@@ -23524,9 +23524,9 @@ async function render(context2, path, name2, stat, format3, escapes, limit) {
       const value2 = times[code.toUpperCase()];
       text3 = code === "w" && value2 === void 0 ? "-" : timestamp2(available(value2, code));
     } else {
-      const fields3 = { s: stat.size, a: stat.mode & 4095, f: stat.mode, i: stat.ino, h: stat.nlink, u: stat.uid, g: stat.gid, d: stat.dev, D: stat.dev };
-      if (!Object.hasOwn(fields3, code)) throw new FsError("ENOTSUP", { message: `unsupported stat format: %${code}` });
-      const value2 = available(fields3[code], code);
+      const fields4 = { s: stat.size, a: stat.mode & 4095, f: stat.mode, i: stat.ino, h: stat.nlink, u: stat.uid, g: stat.gid, d: stat.dev, D: stat.dev };
+      if (!Object.hasOwn(fields4, code)) throw new FsError("ENOTSUP", { message: `unsupported stat format: %${code}` });
+      const value2 = available(fields4[code], code);
       text3 = value2.toString(code === "a" ? 8 : code === "f" || code === "D" ? 16 : 10);
       numeric4 = true;
     }
@@ -26612,6 +26612,216 @@ async function readArchive(context2, source2, options2, budget) {
 // packages/safe-bash/src/commands/archive/zip.ts
 init_platform();
+// packages/safe-bash/src/commands/archive/zip/dates.ts
+init_platform();
+// packages/safe-bash/src/commands/archive/zip/options.ts
+init_platform();
+var ZipFailure = class extends Error {
+  constructor(status2, label, detail) {
+    super(detail);
+    this.status = status2;
+    this.label = label;
+  }
+  status;
+  label;
+};
+var longOptions = {
+  "recurse-paths": "r",
+  quiet: "q",
+  "junk-paths": "j",
+  "no-dir-entries": "D",
+  symlinks: "y",
+  test: "T",
+  "names-stdin": "@",
+  update: "u",
+  freshen: "f",
+  delete: "d",
+  include: "i",
+  exclude: "x",
+  suffixes: "n",
+  store: "0",
+  "compression-method": "Z",
+  "compress-1": "1",
+  "compress-2": "2",
+  "compress-3": "3",
+  "compress-4": "4",
+  "compress-5": "5",
+  "compress-6": "6",
+  "compress-7": "7",
+  "compress-8": "8",
+  "compress-9": "9",
+  "force-zip64": "fz",
+  "strip-extra": "X",
+  "force-descriptors": "fd",
+  "no-wild": "nw",
+  "wild-stop-dirs": "ws",
+  "recurse-patterns": "R",
+  "from-date": "t",
+  "before-date": "tt",
+  "copy-entries": "U",
+  "output-file": "O"
+};
+var reservedOptions = [
+  "adjust-sfx",
+  "temp-path",
+  "entry-comments",
+  "display-bytes",
+  "display-counts",
+  "display-dots",
+  "display-globaldots",
+  "dot-size",
+  "display-usize",
+  "display-volume",
+  "difference-archive",
+  "encrypt",
+  "fix",
+  "fixfix",
+  "fifo",
+  "filesync",
+  "grow",
+  "help",
+  "more-help",
+  "junk-sfx",
+  "DOS-names",
+  "to-crlf",
+  "from-crlf",
+  "logfile-path",
+  "log-append",
+  "log-info",
+  "license",
+  "move",
+  "must-match",
+  "latest-time",
+  "paths",
+  "password",
+  "regex",
+  "split-size",
+  "split-pause",
+  "split-verbose",
+  "split-bell",
+  "show-command",
+  "show-debug",
+  "show-files",
+  "show-options",
+  "unzip-command",
+  "verbose",
+  "version",
+  "archive-comment"
+];
+function normalizeZipOption(argument2) {
+  if (!argument2.startsWith("--") || argument2 === "--") return argument2;
+  const equal2 = argument2.indexOf("=");
+  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" && short !== "t" && short !== "tt" && short !== "O") {
+    throw new ZipFailure(16, "Invalid command arguments", `option '${matched}' does not allow a value`);
+  }
+  return `-${short}${negate2 ? "-" : ""}${equal2 < 0 ? "" : argument2.slice(equal2)}`;
+}
+// packages/safe-bash/src/commands/archive/zip/dates.ts
+function integer4(input3, start, width) {
+  let offset = start;
+  while (" 	\r\n\v\f".includes(input3[offset] ?? "\0")) offset++;
+  const end = offset + width;
+  let sign = 1;
+  if (input3[offset] === "+" || input3[offset] === "-") {
+    sign = input3[offset] === "-" ? -1 : 1;
+    offset++;
+  }
+  let digits = 0;
+  let value2 = 0;
+  while (offset < end && input3[offset] !== void 0 && input3[offset] >= "0" && input3[offset] <= "9") {
+    value2 = value2 * 10 + Number(input3[offset++]);
+    digits++;
+  }
+  return digits ? { value: value2 * sign, end: offset } : void 0;
+}
+function fields2(input3, iso) {
+  const first = integer4(input3, 0, iso ? 4 : 2);
+  if (!first || iso && input3[first.end] !== "-") return;
+  const second = integer4(input3, first.end + (iso ? 1 : 0), 2);
+  if (!second || iso && input3[second.end] !== "-") return;
+  const third = integer4(input3, second.end + (iso ? 1 : 0), iso ? 2 : 4);
+  if (!third) return;
+  return iso ? [first.value, second.value, third.value] : [third.value, first.value, second.value];
+}
+function parseZipDate(input3, option) {
+  const result = fields2(input3, true) ?? fields2(input3, false);
+  if (!result || result[1] < 1 || result[1] > 12 || result[2] < 1 || result[2] > 31) {
+    throw new ZipFailure(16, "Invalid command arguments", `invalid date entered for -${option} option - use mmddyyyy or yyyy-mm-dd`);
+  }
+  const [year, month, day] = result;
+  return year < 1980 ? 2162688 : (year - 1980) * 33554432 + month * 2097152 + day * 65536;
+}
+function zipDateMatches(modified, from, until) {
+  if (from === void 0 && until === void 0) return true;
+  const rounded2 = new Date(Math.ceil(Math.floor(modified.getTime() / 1e3) / 2) * 2e3);
+  const key = rounded2.getFullYear() < 1980 ? 2162688 : (rounded2.getFullYear() - 1980) * 33554432 + (rounded2.getMonth() + 1) * 2097152 + rounded2.getDate() * 65536 + rounded2.getHours() * 2048 + rounded2.getMinutes() * 32 + rounded2.getSeconds() / 2;
+  return (from === void 0 || key >= from) && (until === void 0 || key < until);
+}
+// packages/safe-bash/src/commands/archive/zip/environment.ts
+init_platform();
+function whitespace(character) {
+  return character === " " || character === "	" || character === "\n" || character === "\r" || character === "\v" || character === "\f";
+}
+function zipEnvironmentArguments(env, argv, limits) {
+  let value2 = "";
+  let selectedBytes = 0;
+  for (const key of ["ZIPOPT", "ZIP_OPTS"]) {
+    const candidate = env[key] ?? "";
+    if (import_buffer.Buffer.byteLength(candidate) > limits.maxArgumentBytes) fail("environment argument byte limit exceeded");
+    let start = 0;
+    while (whitespace(candidate[start])) start++;
+    if (start < candidate.length) {
+      value2 = candidate.slice(start);
+      selectedBytes = import_buffer.Buffer.byteLength(candidate);
+      break;
+    }
+  }
+  if (!value2) return argv;
+  if (value2.includes("\0") || import_buffer.Buffer.from(value2).toString("utf8") !== value2) fail("invalid environment argument text");
+  let bytes3 = selectedBytes;
+  for (const argument2 of argv) {
+    bytes3 += import_buffer.Buffer.byteLength(argument2);
+    if (bytes3 > limits.maxArgumentBytes) fail("argument byte limit exceeded");
+  }
+  const defaults = [];
+  let offset = 0;
+  while (offset < value2.length) {
+    let argument2 = "";
+    if (value2[offset] === '"') {
+      offset++;
+      while (offset < value2.length && value2[offset] !== '"') {
+        if (value2[offset] === "\\") {
+          offset++;
+          if (offset === value2.length) break;
+        }
+        argument2 += value2[offset++];
+      }
+      if (value2[offset] === '"') offset++;
+    } else {
+      const start = offset;
+      while (offset < value2.length && !whitespace(value2[offset])) offset++;
+      argument2 = value2.slice(start, offset);
+    }
+    if (defaults.length + argv.length >= limits.maxArgumentBytes) fail("argument count limit exceeded");
+    defaults.push(argument2);
+    while (whitespace(value2[offset])) offset++;
+  }
+  return [...defaults, ...argv];
+}
 // packages/safe-bash/src/commands/archive/zip-format.ts
 init_platform();
@@ -27059,7 +27269,7 @@ 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 = [];
+    const fields4 = [];
     let length = fresh.length;
     if (mode === "all" && original) {
       extras(original, previous.rawName ?? pathBytes(previous.name, limits), previous.comment ?? new Uint8Array(), central, limits);
@@ -27068,7 +27278,7 @@ function updateZipExtras(entry, previous, mode, limits) {
         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));
+          fields4.push(original.subarray(offset2, next));
           length += next - offset2;
         }
         offset2 = next;
@@ -27077,7 +27287,7 @@ function updateZipExtras(entry, previous, mode, limits) {
     number3(length, Math.min(limits.maxPaxBytes, 65535), "extra field");
     const bytes3 = new Uint8Array(length);
     let offset = 0;
-    for (const field2 of fields3) {
+    for (const field2 of fields4) {
       bytes3.set(field2, offset);
       offset += field2.length;
     }
@@ -27578,126 +27788,14 @@ var Answers = class {
   }
 };
-// packages/safe-bash/src/commands/archive/zip/options.ts
-init_platform();
-var ZipFailure = class extends Error {
-  constructor(status2, label, detail) {
-    super(detail);
-    this.status = status2;
-    this.label = label;
-  }
-  status;
-  label;
-};
-var longOptions = {
-  "recurse-paths": "r",
-  quiet: "q",
-  "junk-paths": "j",
-  "no-dir-entries": "D",
-  symlinks: "y",
-  test: "T",
-  "names-stdin": "@",
-  update: "u",
-  freshen: "f",
-  delete: "d",
-  include: "i",
-  exclude: "x",
-  suffixes: "n",
-  store: "0",
-  "compression-method": "Z",
-  "compress-1": "1",
-  "compress-2": "2",
-  "compress-3": "3",
-  "compress-4": "4",
-  "compress-5": "5",
-  "compress-6": "6",
-  "compress-7": "7",
-  "compress-8": "8",
-  "compress-9": "9",
-  "force-zip64": "fz",
-  "strip-extra": "X",
-  "force-descriptors": "fd",
-  "no-wild": "nw",
-  "wild-stop-dirs": "ws",
-  "recurse-patterns": "R"
-};
-var reservedOptions = [
-  "adjust-sfx",
-  "temp-path",
-  "entry-comments",
-  "display-bytes",
-  "display-counts",
-  "display-dots",
-  "display-globaldots",
-  "dot-size",
-  "display-usize",
-  "display-volume",
-  "difference-archive",
-  "encrypt",
-  "fix",
-  "fixfix",
-  "fifo",
-  "filesync",
-  "grow",
-  "help",
-  "more-help",
-  "junk-sfx",
-  "DOS-names",
-  "to-crlf",
-  "from-crlf",
-  "logfile-path",
-  "log-append",
-  "log-info",
-  "license",
-  "move",
-  "must-match",
-  "latest-time",
-  "output-file",
-  "paths",
-  "password",
-  "regex",
-  "split-size",
-  "split-pause",
-  "split-verbose",
-  "split-bell",
-  "show-command",
-  "show-debug",
-  "show-files",
-  "show-options",
-  "from-date",
-  "before-date",
-  "unzip-command",
-  "copy-entries",
-  "verbose",
-  "version",
-  "archive-comment"
-];
-function normalizeZipOption(argument2) {
-  if (!argument2.startsWith("--") || argument2 === "--") return argument2;
-  const equal2 = argument2.indexOf("=");
-  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}${negate2 ? "-" : ""}${equal2 < 0 ? "" : argument2.slice(equal2)}`;
-}
 // packages/safe-bash/src/commands/archive/zip.ts
 var defaultStoreSuffixes = [".Z", ".zip", ".zoo", ".arc", ".lzh", ".arj"];
 async function parse12(scope, limits) {
   const context2 = scope.context;
-  if (context2.args.length > limits.maxArgumentBytes) fail("argument count limit exceeded");
+  const args = zipEnvironmentArguments(context2.env, context2.args, limits);
+  if (args.length > limits.maxArgumentBytes) fail("argument count limit exceeded");
   let bytes3 = 0;
-  for (const argument2 of context2.args) {
+  for (const argument2 of args) {
     const size = import_buffer.Buffer.byteLength(argument2);
     if (size > limits.maxArgumentBytes - bytes3) fail("argument byte limit exceeded");
     bytes3 += size;
@@ -27713,6 +27811,7 @@ async function parse12(scope, limits) {
     for (const value2 of argumentsValue.values) text2(shellValueBytes(value2));
   }
   let archive;
+  let output2;
   let action = "add";
   let recursive = false;
   let recursivePatterns = false;
@@ -27723,6 +27822,8 @@ async function parse12(scope, limits) {
   let omitDirectories = false;
   let storeLinks = false;
   let test = false;
+  let fromDate;
+  let beforeDate;
   let descriptors = false;
   let zip64;
   let metadata3 = "default";
@@ -27735,8 +27836,8 @@ async function parse12(scope, limits) {
   const operands = [];
   const includes = [];
   const excludes = [];
-  for (let index = 0; index < context2.args.length; index++) {
-    const original = context2.args[index];
+  for (let index = 0; index < args.length; index++) {
+    const original = args[index];
     checkPath(original, limits);
     const argument2 = literal ? original : normalizeZipOption(original);
     if (!literal && argument2 === "--") {
@@ -27756,8 +27857,8 @@ async function parse12(scope, limits) {
         } 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";
+        } else if (flag === "d" || flag === "u" || flag === "f" || flag === "U") {
+          const next = flag === "d" ? "delete" : flag === "u" ? "update" : flag === "U" ? "copy" : "freshen";
           if (action !== "add" && action !== next) throw new ZipFailure(16, "Invalid command arguments", "specify just one action");
           action = next;
         } else if (flag === "n" && argument2[offset + 1] === "w" || flag === "w" && argument2[offset + 1] === "s") {
@@ -27777,10 +27878,26 @@ async function parse12(scope, limits) {
         else if (flag !== void 0 && flag >= "0" && flag <= "9") {
           level = Number(flag);
           if (level === 0) method = "store";
+        } else if (flag === "O") {
+          let value2 = argument2.slice(offset + 1) || args[++index];
+          if (value2?.startsWith("=")) value2 = value2.slice(1);
+          if (value2 === void 0) throw new ZipFailure(16, "Invalid command arguments", "option O requires a value");
+          output2 = value2;
+          break;
+        } else if (flag === "t") {
+          const option = argument2[offset + 1] === "t" ? "tt" : "t";
+          if (option === "tt") offset++;
+          let value2 = argument2.slice(offset + 1);
+          if (!value2) value2 = args[++index] ?? "";
+          if (value2.startsWith("=")) value2 = value2.slice(1);
+          const date2 = parseZipDate(value2, option);
+          if (option === "t") fromDate = date2;
+          else beforeDate = date2;
+          break;
         } else if (flag === "n" || flag === "Z") {
           let value2 = argument2.slice(offset + 1);
           if (!value2) {
-            const next = context2.args[index + 1];
+            const next = args[index + 1];
             if (next === void 0 || next.startsWith("-") && next !== "-") throw new ZipFailure(16, "Invalid command arguments", `option '${flag}' requires a value`);
             value2 = next;
             index++;
@@ -27810,8 +27927,8 @@ async function parse12(scope, limits) {
             const value2 = argument2.slice(offset + 1);
             append(value2.startsWith("=") ? value2.slice(1) : value2);
           }
-          while (!attached && index + 1 < context2.args.length) {
-            const next = context2.args[index + 1];
+          while (!attached && index + 1 < args.length) {
+            const next = args[index + 1];
             if (next === "@") {
               index++;
               break;
@@ -27832,12 +27949,19 @@ async function parse12(scope, limits) {
     }
   }
   if (archive === void 0) {
+    if (includes.length || excludes.length) throw new ZipFailure(16, "Invalid command arguments", "nothing to select from");
     if (action !== "add") throw new ZipFailure(16, "Invalid command arguments", "expected archive name");
     archive = "-";
     if (!stdinNames) operands.push("-");
   }
   if (archive !== "-" && !archive.slice(archive.lastIndexOf("/") + 1).includes(".")) archive += ".zip";
   checkPath(archive, limits);
+  if (output2 !== void 0) {
+    if (!output2.slice(output2.lastIndexOf("/") + 1).includes(".")) output2 += ".zip";
+    checkPath(output2, limits);
+    if (action === "add" && archive !== "-" && !operands.length && !stdinNames) action = "copy";
+  }
+  if (action === "copy" && output2 === void 0) throw new ZipFailure(16, "Invalid command arguments", "-U (--copy) requires -O (--out)");
   const names = [];
   if (stdinNames) {
     const input3 = await collectBytes(scope.stdin, { maxBytes: limits.maxFilesFromBytes, signal: context2.signal });
@@ -27860,7 +27984,7 @@ async function parse12(scope, limits) {
     }
   }
   if (recursivePatterns && !names.length && !operands.length) throw new ZipFailure(16, "Invalid command arguments", "nothing to select from");
-  return { action, archive, recursive, recursivePatterns, noWild, stopAtDirectories, quiet, junkPaths, omitDirectories, storeLinks, test, descriptors, zip64, metadata: metadata3, includes, excludes, level, method, suffixes, operands: [...names, ...operands], firstOperand };
+  return { args, action, archive, output: output2, recursive, recursivePatterns, noWild, stopAtDirectories, quiet, junkPaths, omitDirectories, storeLinks, test, fromDate, beforeDate, 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");
@@ -27905,7 +28029,7 @@ async function prepare(scope, parsed, budget) {
   if (parsed.archive === "-" && parsed.action !== "add") throw new ZipFailure(16, "Invalid command arguments", "can't use -d, -f, -u, -U, or -g on stdout\n");
   let publication;
   if (parsed.archive !== "-") {
-    const outputName = vfsPath(context2.cwd, parsed.archive);
+    const outputName = vfsPath(context2.cwd, parsed.output ?? parsed.archive);
     const parentName = dirname(outputName);
     const parent = await scope.operation(() => context2.fs.realpath(parentName, { signal: context2.signal }));
     const parentStat = await scope.operation(() => context2.fs.lstat(parent, { signal: context2.signal }));
@@ -27915,16 +28039,37 @@ async function prepare(scope, parsed, budget) {
     publication = { output: output3, parentName, parent, parentStat, existing: existing3 };
   }
   const output2 = publication?.output;
-  const existing2 = publication?.existing;
+  let input3 = publication?.output;
+  let existing2 = publication?.existing;
+  if (parsed.output !== void 0) {
+    if (parsed.archive === "-") {
+      input3 = void 0;
+      existing2 = void 0;
+    } else {
+      const name2 = vfsPath(context2.cwd, parsed.archive);
+      try {
+        const parent = await scope.operation(() => context2.fs.realpath(dirname(name2), { signal: context2.signal }));
+        input3 = `${parent === "/" ? "" : parent}/${name2.slice(name2.lastIndexOf("/") + 1)}`;
+        existing2 = await scope.stat(input3);
+      } catch (error) {
+        context2.signal.throwIfAborted();
+        if (typeof error === "object" && error !== null && "code" in error && (error.code === "ENOENT" || error.code === "EACCES")) throw new ZipFailure(18, "File not found or no read permission", parsed.archive);
+        throw error;
+      }
+      if (input3 === output2 || existing2 && publication?.existing && sameIdentity2(existing2, publication.existing)) throw new ZipFailure(16, "Invalid command arguments", `--out path must be different than in path: ${parsed.archive}`);
+    }
+  }
+  if ((parsed.action === "copy" || parsed.output !== void 0 && parsed.archive !== "-") && !existing2) throw new ZipFailure(18, "File not found or no read permission", parsed.archive);
+  if (publication?.existing && (publication.existing.type !== "file" || !hasIdentity(publication.existing) || publication.existing.nlink !== 1)) fail("output archive requires a regular, single-link file with known backing identity");
   if (parsed.archive === "-" && parsed.test && !parsed.quiet) await budget.output("	zip warning: can't use -T on stdout, -T ignored\n");
   if (existing2 && (existing2.type !== "file" || !hasIdentity(existing2) || existing2.nlink !== 1)) fail("updating archive requires a regular, single-link file with known backing identity; archive aliases are unsupported");
   let archive = { entries: [], comment: new Uint8Array() };
-  if (existing2 && publication) {
+  if (existing2 && input3) {
     if (!Number.isSafeInteger(existing2.size) || existing2.size < 0 || existing2.size > limits.maxArchiveBytes) fail("archive byte limit exceeded");
-    const bytes4 = await collectBytes(scope.input(publication.output), { maxBytes: limits.maxArchiveBytes, signal: context2.signal });
+    const bytes4 = await collectBytes(scope.input(input3), { maxBytes: limits.maxArchiveBytes, signal: context2.signal });
     if (bytes4.length !== existing2.size) fail("archive changed while reading");
     archive = await readZipArchive(bytes4, limits, context2.signal);
-    const current = await scope.stat(publication.output);
+    const current = await scope.stat(input3);
     if (!current || !unchanged4(existing2, current)) fail("archive changed while reading");
   }
   const old = new Map(archive.entries.map((entry) => [entry.name, entry]));
@@ -27964,6 +28109,7 @@ async function prepare(scope, parsed, budget) {
       if (previous || !await filterName(name2, selection, parsed.includes.length)) return;
       const prior2 = old.get(name2);
       const modified = /* @__PURE__ */ new Date();
+      if (!zipDateMatches(modified, parsed.fromDate, parsed.beforeDate)) return;
       if (parsed.action === "freshen" && !prior2 || prior2 && (parsed.action === "update" || parsed.action === "freshen") && Math.floor(modified.getTime() / 1e3) <= Math.floor(prior2.modified.getTime() / 1e3)) return;
       const bytes4 = await collectBytes(scope.stdin, { maxBytes: Math.min(limits.maxEntryBytes, limits.maxTotalBytes - budget.totalBytes), signal: context2.signal });
       await budget.member(bytes4.length);
@@ -27984,17 +28130,17 @@ async function prepare(scope, parsed, budget) {
       return;
     }
     checkPath(canonical, limits);
-    if (canonical === output2 || existing2 && sameIdentity2(existing2, stat)) return;
+    if (canonical === output2 || canonical === input3 || existing2 && sameIdentity2(existing2, stat) || publication?.existing && sameIdentity2(publication.existing, stat)) return;
     const symlink = parsed.storeLinks && stat.type === "symlink";
     if (stat.type !== "file" && stat.type !== "directory" && !symlink) {
       if (!parsed.quiet) await budget.output(`	zip warning: ignoring special file: ${source2}
 `);
       return;
     }
-    if (existing2 && !hasIdentity(stat)) fail("cannot exclude archive aliases when source backing identity is unknown");
+    if ((existing2 || publication?.existing) && !hasIdentity(stat)) fail("cannot exclude archive aliases when source backing identity is unknown");
     const directory2 = stat.type === "directory";
     if (directory2 && name2 && !name2.endsWith("/")) name2 += "/";
-    const included = await filterName(name2, selection, parsed.includes.length) && (!recursiveSelection || await recursiveSelection.matches(name2, true));
+    const included = zipDateMatches(new Date(stat.mtimeMs), parsed.fromDate, parsed.beforeDate) && await filterName(name2, selection, parsed.includes.length) && (!recursiveSelection || await recursiveSelection.matches(name2, true));
     const sourceName = name2;
     if (parsed.junkPaths) name2 = directory2 ? "" : name2.slice(name2.lastIndexOf("/") + 1);
     const prior = old.get(name2);
@@ -28041,14 +28187,22 @@ async function prepare(scope, parsed, budget) {
       }
     }
   };
-  if (parsed.action === "delete") {
+  if (parsed.action === "copy") {
+    const operands = new Selection(parsed.operands, limits, context2.signal, { noWild: parsed.noWild, stopAtDirectories: parsed.stopAtDirectories });
+    for (const entry of archive.entries) {
+      if (await operands.matches(entry.name) && await filterName(entry.name, selection, parsed.includes.length) && zipDateMatches(entry.modified, parsed.fromDate, parsed.beforeDate)) {
+        await budget.member(entry.size);
+        selected.set(entry.name, { entry, source: entry.name });
+      }
+    }
+  } else if (parsed.action === "delete") {
     if (!parsed.quiet && parsed.recursive) await budget.output("	zip warning: invalid option(s) used with -d; ignored.\n");
     if (!parsed.quiet && !archive.entries.length) await budget.output(`	zip warning: ${parsed.archive} not found or empty
 `);
     const operands = new Selection(parsed.recursivePatterns ? [] : parsed.operands, limits, context2.signal, { noWild: parsed.noWild, stopAtDirectories: parsed.stopAtDirectories });
     if (parsed.operands.length && !parsed.recursivePatterns) {
       for (const entry of archive.entries) {
-        if (await operands.matches(entry.name) && await filterName(entry.name, selection, parsed.includes.length)) deleted.add(entry.name);
+        if (await operands.matches(entry.name) && await filterName(entry.name, selection, parsed.includes.length) && zipDateMatches(entry.modified, parsed.fromDate, parsed.beforeDate)) deleted.add(entry.name);
       }
     }
     if (!parsed.quiet) {
@@ -28063,8 +28217,8 @@ async function prepare(scope, parsed, budget) {
     else for (const operand of operands) await visit(operand, memberName(operand, limits), 0);
   }
   if (!selected.size && (parsed.action === "freshen" || parsed.action === "update" && (existing2 || !parsed.includes.length))) return void 0;
-  if (!selected.size && !deleted.size && (parsed.action === "delete" || parsed.recursivePatterns || !parsed.includes.length)) {
-    const detail = parsed.action !== "delete" && parsed.recursive && parsed.firstOperand >= 0 ? `try: zip ${context2.args.slice(0, parsed.firstOperand).join(" ")} . -i ${context2.args.slice(parsed.firstOperand).join(" ")}` : parsed.archive;
+  if (!selected.size && !deleted.size && (parsed.action === "delete" || parsed.action === "copy" || parsed.recursivePatterns || parsed.fromDate !== void 0 || parsed.beforeDate !== void 0 || !parsed.includes.length)) {
+    const detail = parsed.action !== "delete" && parsed.recursive && parsed.firstOperand >= 0 ? `try: zip ${parsed.args.slice(0, parsed.firstOperand).join(" ")} . -i ${parsed.args.slice(parsed.firstOperand).join(" ")}` : parsed.archive;
     throw new ZipFailure(12, "Nothing to do!", detail);
   }
   const entries2 = [];
@@ -28090,6 +28244,15 @@ async function prepare(scope, parsed, budget) {
       continue;
     }
     const replacement = selected.get(entry.name);
+    if (parsed.action === "copy") {
+      if (replacement) {
+        entries2.push(replacement.entry);
+        queue(` copying: ${entry.name}
+`);
+        selected.delete(entry.name);
+      }
+      continue;
+    }
     if (replacement) {
       entries2.push(replacement.entry);
       append(replacement.entry, true);
@@ -28104,7 +28267,7 @@ async function prepare(scope, parsed, budget) {
     append(entry, false);
   }
   if (!entries2.length) queue("	zip warning: zip file empty\n");
-  if (parsed.archive === "-") return { kind: "stream", archive: { entries: entries2, comment: archive.comment }, progress };
+  if (!publication) 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);
@@ -29208,13 +29371,13 @@ function parse13(context2, budget) {
       }
       const values = value2.split(/[, \t]+/u);
       budget.check(values.length, budget.limits.maxFields, "field");
-      const fields3 = values.map((specification) => {
+      const fields4 = values.map((specification) => {
         if (specification === "0") return { file: 0, index: 0 };
         const match = /^([12])\.([0-9]+)$/u.exec(specification);
         if (!match) fail2(`invalid output field: ${specification}`);
         return { file: Number(match[1]), index: number4(match[2], "output field") - 1 };
       });
-      options2.format = [...Array.isArray(options2.format) ? options2.format : [], ...fields3];
+      options2.format = [...Array.isArray(options2.format) ? options2.format : [], ...fields4];
       budget.check(options2.format.length, budget.limits.maxFields, "field");
     }
   };
@@ -29267,10 +29430,10 @@ function parse13(context2, budget) {
 }
 function split3(bytes3, options2, budget) {
   if (options2.whole) return [bytes3];
-  const fields3 = [];
+  const fields4 = [];
   const add3 = (start, end) => {
-    budget.check(fields3.length + 1, budget.limits.maxFields, "field");
-    fields3.push(bytes3.subarray(start, end));
+    budget.check(fields4.length + 1, budget.limits.maxFields, "field");
+    fields4.push(bytes3.subarray(start, end));
   };
   if (options2.delimiter !== void 0) {
     let start = 0;
@@ -29289,7 +29452,7 @@ function split3(bytes3, options2, budget) {
       if (offset > start) add3(start, offset);
     }
   }
-  return fields3;
+  return fields4;
 }
 function createJoinCommand(factory = {}) {
   const limits = settings3(factory);
@@ -29304,36 +29467,36 @@ function createJoinCommand(factory = {}) {
       const next = async (file, reset = false) => {
         const bytes3 = await readers[file].next();
         if (bytes3 === void 0) return void 0;
-        const fields3 = split3(bytes3, options2, budget), key = fields3[options2.fields[file]] ?? empty;
+        const fields4 = split3(bytes3, options2, budget), key = fields4[options2.fields[file]] ?? empty;
         if (!reset) await order.check(previous[file], key, file + 1, options2.fold);
         previous[file] = key;
-        return { bytes: bytes3, fields: fields3, key };
+        return { bytes: bytes3, fields: fields4, key };
       };
       const rows2 = [await next(0), await next(1)];
       const counts = rows2.map((row) => row?.fields.length ?? 0);
       const emit2 = async (left, right) => {
-        const pair = [left, right], fields3 = [];
+        const pair = [left, right], fields4 = [];
         const key = (left ?? right)?.key ?? empty;
         if (Array.isArray(options2.format)) {
           for (const field2 of options2.format) {
             await budget.step();
-            fields3.push(field2.file === 0 ? key : pair[field2.file - 1]?.fields[field2.index] ?? empty);
+            fields4.push(field2.file === 0 ? key : pair[field2.file - 1]?.fields[field2.index] ?? empty);
           }
         } else {
-          fields3.push(key);
+          fields4.push(key);
           for (let file = 0; file < 2; file++) {
             const count2 = options2.format === "auto" ? counts[file] : pair[file]?.fields.length ?? 0;
             for (let index = 0; index < count2; index++) {
               await budget.step();
-              if (index !== options2.fields[file]) fields3.push(pair[file]?.fields[index] ?? empty);
+              if (index !== options2.fields[file]) fields4.push(pair[file]?.fields[index] ?? empty);
             }
           }
         }
         const parts = [];
-        for (let index = 0; index < fields3.length; index++) {
+        for (let index = 0; index < fields4.length; index++) {
           await budget.step();
           if (index) parts.push(delimiter);
-          parts.push(fields3[index].length ? fields3[index] : options2.replacement);
+          parts.push(fields4[index].length ? fields4[index] : options2.replacement);
         }
         parts.push(terminator);
         await budget.output(parts);
@@ -31249,10 +31412,10 @@ function millisecondsInstant(value2) {
   const scale = Number(match[4] ?? 0) - fraction.length + 6;
   return boundedInstant(scale >= 0 ? coefficient * 10n ** BigInt(scale) : floorDivide(coefficient, 10n ** BigInt(-scale)));
 }
-function utcMilliseconds(fields3) {
+function utcMilliseconds(fields4) {
   const date2 = /* @__PURE__ */ new Date(0);
-  date2.setUTCFullYear(fields3.year, fields3.month - 1, fields3.day);
-  date2.setUTCHours(fields3.hour, fields3.minute, fields3.second, 0);
+  date2.setUTCFullYear(fields4.year, fields4.month - 1, fields4.day);
+  date2.setUTCHours(fields4.hour, fields4.minute, fields4.second, 0);
   const value2 = date2.getTime();
   if (!Number.isFinite(value2)) throw new CommandFailure("date is outside the supported range");
   return value2;
@@ -31271,8 +31434,8 @@ function utcFields(milliseconds) {
 function sameFields(left, right) {
   return left.year === right.year && left.month === right.month && left.day === right.day && left.hour === right.hour && left.minute === right.minute && left.second === right.second;
 }
-function checkCalendar(fields3, restrictYear = true) {
-  if (restrictYear && (fields3.year < 0 || fields3.year > 9999) || fields3.month < 1 || fields3.month > 12 || fields3.day < 1 || fields3.day > 31 || fields3.hour < 0 || fields3.hour > 23 || fields3.minute < 0 || fields3.minute > 59 || fields3.second < 0 || fields3.second > 59 || !sameFields(fields3, utcFields(utcMilliseconds(fields3)))) throw new CommandFailure("invalid calendar date or time");
+function checkCalendar(fields4, restrictYear = true) {
+  if (restrictYear && (fields4.year < 0 || fields4.year > 9999) || fields4.month < 1 || fields4.month > 12 || fields4.day < 1 || fields4.day > 31 || fields4.hour < 0 || fields4.hour > 23 || fields4.minute < 0 || fields4.minute > 59 || fields4.second < 0 || fields4.second > 59 || !sameFields(fields4, utcFields(utcMilliseconds(fields4)))) throw new CommandFailure("invalid calendar date or time");
 }
 function signedOffset(text3) {
   const match = /^([+-])(\d{2})(?::?(\d{2}))?(?::(\d{2}))?$/.exec(text3);
@@ -31321,15 +31484,15 @@ var TimeZone = class {
     boundedInstant(instant);
     const seconds = floorDivide(instant, nanosecondsPerSecond);
     const milliseconds = Number(seconds * 1000n);
-    let fields3, offset, zone;
+    let fields4, offset, zone;
     if (this.fixedOffset !== void 0) {
-      fields3 = utcFields(milliseconds + this.fixedOffset * 1e3);
+      fields4 = utcFields(milliseconds + this.fixedOffset * 1e3);
       offset = this.fixedOffset;
       zone = this.label;
     } else {
       const parts = Object.fromEntries(this.formatter.formatToParts(new Date(milliseconds)).map((part) => [part.type, part.value]));
       const year = Number(parts.year);
-      fields3 = {
+      fields4 = {
         year: parts.era === "BC" ? 1 - year : year,
         month: Number(parts.month),
         day: Number(parts.day),
@@ -31337,22 +31500,22 @@ var TimeZone = class {
         minute: Number(parts.minute),
         second: Number(parts.second)
       };
-      offset = (utcMilliseconds(fields3) - milliseconds) / 1e3;
+      offset = (utcMilliseconds(fields4) - milliseconds) / 1e3;
       zone = parts.timeZoneName;
     }
-    checkCalendar(fields3, restrictYear);
-    return { ...fields3, offset, zone };
+    checkCalendar(fields4, restrictYear);
+    return { ...fields4, offset, zone };
   }
-  instant(fields3, fraction = 0n) {
-    checkCalendar(fields3);
-    const wall = utcMilliseconds(fields3);
+  instant(fields4, fraction = 0n) {
+    checkCalendar(fields4);
+    const wall = utcMilliseconds(fields4);
     if (this.fixedOffset !== void 0) return boundedInstant(BigInt(wall) * 1000000n - BigInt(this.fixedOffset) * nanosecondsPerSecond + fraction);
     const offsets = /* @__PURE__ */ new Set();
     for (const days of [-2, -1, 0, 1, 2]) offsets.add(this.observedFields(BigInt(wall + days * 864e5) * 1000000n, false).offset);
     const candidates = [];
     for (const offset of offsets) {
       const candidate = BigInt(wall) * 1000000n - BigInt(offset) * nanosecondsPerSecond + fraction;
-      if (sameFields(this.observedFields(candidate, false), fields3)) candidates.push(candidate);
+      if (sameFields(this.observedFields(candidate, false), fields4)) candidates.push(candidate);
     }
     if (candidates.length === 0) throw new CommandFailure("nonexistent local time in virtual TZ");
     if (candidates.length !== 1) throw new CommandFailure("ambiguous local time; specify an explicit UTC offset");
@@ -31378,8 +31541,8 @@ function parseDate(text3, zone, now) {
   if (["today", "yesterday", "tomorrow"].includes(value2)) {
     const current = now();
     if (value2 === "today") return current;
-    const fields3 = zone.fields(current);
-    const changed = utcFields(utcMilliseconds(fields3) + (value2 === "yesterday" ? -864e5 : 864e5));
+    const fields4 = zone.fields(current);
+    const changed = utcFields(utcMilliseconds(fields4) + (value2 === "yesterday" ? -864e5 : 864e5));
     return zone.instant(changed, current - floorDivide(current, nanosecondsPerSecond) * nanosecondsPerSecond);
   }
   const relative = /^(?:now\s+)?([+-]?\d+)\s+(seconds?|minutes?|hours?)(?:\s+(ago))?$/.exec(value2);
@@ -31391,7 +31554,7 @@ function parseDate(text3, zone, now) {
   }
   const iso = /^(\d{4})-(\d{2})-(\d{2})(?:[T ](\d{2}):(\d{2})(?::(\d{2})(?:[.,](\d{1,9}))?)?)?(?:\s*(Z|UTC|GMT|[+-]\d{2}(?::?\d{2})?(?::\d{2})?))?$/.exec(value2);
   if (iso) {
-    const fields3 = {
+    const fields4 = {
       year: Number(iso[1]),
       month: Number(iso[2]),
       day: Number(iso[3]),
@@ -31399,11 +31562,11 @@ function parseDate(text3, zone, now) {
       minute: Number(iso[5] ?? 0),
       second: Number(iso[6] ?? 0)
     };
-    return parsedZone(iso[8], zone).instant(fields3, BigInt((iso[7] ?? "").padEnd(9, "0")));
+    return parsedZone(iso[8], zone).instant(fields4, BigInt((iso[7] ?? "").padEnd(9, "0")));
   }
   const rfc = /^(?:(Sun|Mon|Tue|Wed|Thu|Fri|Sat),\s+)?(\d{1,2})\s+(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s+(\d{4})\s+(\d{2}):(\d{2}):(\d{2})\s+(GMT|UTC|[+-]\d{4})$/.exec(value2);
   if (rfc) {
-    const fields3 = {
+    const fields4 = {
       year: Number(rfc[4]),
       month: monthNames.findIndex((name2) => name2.startsWith(rfc[3])) + 1,
       day: Number(rfc[2]),
@@ -31411,8 +31574,8 @@ function parseDate(text3, zone, now) {
       minute: Number(rfc[6]),
       second: Number(rfc[7])
     };
-    if (rfc[1] && !weekdayNames[new Date(utcMilliseconds(fields3)).getUTCDay()].startsWith(rfc[1])) throw new CommandFailure("weekday does not match calendar date");
-    return parsedZone(rfc[8], zone).instant(fields3);
+    if (rfc[1] && !weekdayNames[new Date(utcMilliseconds(fields4)).getUTCDay()].startsWith(rfc[1])) throw new CommandFailure("weekday does not match calendar date");
+    return parsedZone(rfc[8], zone).instant(fields4);
   }
   throw new CommandFailure(`unsupported or invalid date: ${text3}`);
 }
@@ -31431,18 +31594,18 @@ function offsetText(offset, colons) {
   return { value: `${sign}${hours}`, width: 3 };
 }
 function formatDate(format3, instant, zone, limits) {
-  const fields3 = zone.fields(instant);
-  const midnight = utcMilliseconds({ ...fields3, hour: 0, minute: 0, second: 0 });
+  const fields4 = zone.fields(instant);
+  const midnight = utcMilliseconds({ ...fields4, hour: 0, minute: 0, second: 0 });
   const weekday = new Date(midnight).getUTCDay();
-  const ordinal = Math.floor((midnight - utcMilliseconds({ ...fields3, month: 1, day: 1, hour: 0, minute: 0, second: 0 })) / 864e5) + 1;
+  const ordinal = Math.floor((midnight - utcMilliseconds({ ...fields4, month: 1, day: 1, hour: 0, minute: 0, second: 0 })) / 864e5) + 1;
   const thursday = new Date(midnight + (3 - (weekday + 6) % 7) * 864e5);
   const isoYear = thursday.getUTCFullYear();
   const isoWeek = 1 + Math.floor((thursday.getTime() - utcMilliseconds({ year: isoYear, month: 1, day: 1, hour: 0, minute: 0, second: 0 })) / 6048e5);
   const nano = (instant - floorDivide(instant, nanosecondsPerSecond) * nanosecondsPerSecond).toString().padStart(9, "0");
   const number6 = (value2, width = 2, padding = "0") => value2.toString().padStart(width, padding);
-  const time = `${number6(fields3.hour)}:${number6(fields3.minute)}:${number6(fields3.second)}`;
-  const hour12 = fields3.hour % 12 || 12;
-  const meridian = fields3.hour < 12 ? "AM" : "PM";
+  const time = `${number6(fields4.hour)}:${number6(fields4.minute)}:${number6(fields4.second)}`;
+  const hour12 = fields4.hour % 12 || 12;
+  const meridian = fields4.hour < 12 ? "AM" : "PM";
   const pieces = [];
   let size = 0;
   const append = (value2) => {
@@ -31494,34 +31657,34 @@ function formatDate(format3, instant, zone, limits) {
         break;
       case "b":
       case "h":
-        value2 = monthNames[fields3.month - 1].slice(0, 3);
+        value2 = monthNames[fields4.month - 1].slice(0, 3);
         break;
       case "B":
-        value2 = monthNames[fields3.month - 1];
+        value2 = monthNames[fields4.month - 1];
         break;
       case "c":
-        value2 = `${weekdayNames[weekday].slice(0, 3)} ${monthNames[fields3.month - 1].slice(0, 3)} ${number6(fields3.day, 2, " ")} ${time} ${number6(fields3.year, 4)}`;
+        value2 = `${weekdayNames[weekday].slice(0, 3)} ${monthNames[fields4.month - 1].slice(0, 3)} ${number6(fields4.day, 2, " ")} ${time} ${number6(fields4.year, 4)}`;
         break;
       case "C":
-        value2 = String(Math.floor(fields3.year / 100));
+        value2 = String(Math.floor(fields4.year / 100));
         defaultWidth = 2;
         break;
       case "d":
       case "e":
-        value2 = String(fields3.day);
+        value2 = String(fields4.day);
         defaultWidth = 2;
         if (code === "e") defaultPadding = " ";
         break;
       case "D":
-        value2 = `${number6(fields3.month)}/${number6(fields3.day)}/${number6(fields3.year % 100, 2, padding ?? "0")}`;
+        value2 = `${number6(fields4.month)}/${number6(fields4.day)}/${number6(fields4.year % 100, 2, padding ?? "0")}`;
         break;
       case "x":
-        value2 = `${number6(fields3.month)}/${number6(fields3.day)}/${number6(fields3.year % 100)}`;
+        value2 = `${number6(fields4.month)}/${number6(fields4.day)}/${number6(fields4.year % 100)}`;
         break;
       case "F": {
         const yearWidth = width === void 0 && padding === void 0 ? 4 : Math.max(0, (width ?? 0) - 6);
-        const year = padding === "" ? String(fields3.year) : number6(fields3.year, yearWidth, padding ?? "0");
-        append(`${year}-${number6(fields3.month)}-${number6(fields3.day)}`);
+        const year = padding === "" ? String(fields4.year) : number6(fields4.year, yearWidth, padding ?? "0");
+        append(`${year}-${number6(fields4.month)}-${number6(fields4.day)}`);
         continue;
       }
       case "g":
@@ -31534,7 +31697,7 @@ function formatDate(format3, instant, zone, limits) {
         break;
       case "H":
       case "k":
-        value2 = String(fields3.hour);
+        value2 = String(fields4.hour);
         defaultWidth = 2;
         if (code === "k") defaultPadding = " ";
         break;
@@ -31549,11 +31712,11 @@ function formatDate(format3, instant, zone, limits) {
         defaultWidth = 3;
         break;
       case "m":
-        value2 = String(fields3.month);
+        value2 = String(fields4.month);
         defaultWidth = 2;
         break;
       case "M":
-        value2 = String(fields3.minute);
+        value2 = String(fields4.minute);
         defaultWidth = 2;
         break;
       case "n":
@@ -31574,21 +31737,21 @@ function formatDate(format3, instant, zone, limits) {
         value2 = meridian.toLowerCase();
         break;
       case "q":
-        value2 = String(Math.ceil(fields3.month / 3));
+        value2 = String(Math.ceil(fields4.month / 3));
         defaultWidth = 1;
         break;
       case "r":
-        value2 = `${number6(hour12)}:${number6(fields3.minute)}:${number6(fields3.second)} ${meridian}`;
+        value2 = `${number6(hour12)}:${number6(fields4.minute)}:${number6(fields4.second)} ${meridian}`;
         break;
       case "R":
-        value2 = `${number6(fields3.hour)}:${number6(fields3.minute)}`;
+        value2 = `${number6(fields4.hour)}:${number6(fields4.minute)}`;
         break;
       case "s":
         value2 = floorDivide(instant, nanosecondsPerSecond).toString();
         defaultWidth = 1;
         break;
       case "S":
-        value2 = String(fields3.second);
+        value2 = String(fields4.second);
         defaultWidth = 2;
         break;
       case "t":
@@ -31619,21 +31782,21 @@ function formatDate(format3, instant, zone, limits) {
         defaultWidth = 2;
         break;
       case "y":
-        value2 = String(fields3.year % 100);
+        value2 = String(fields4.year % 100);
         defaultWidth = 2;
         break;
       case "Y":
-        value2 = String(fields3.year);
+        value2 = String(fields4.year);
         defaultWidth = 4;
         break;
       case "z": {
-        const offset2 = offsetText(fields3.offset, colons);
+        const offset2 = offsetText(fields4.offset, colons);
         value2 = offset2.value;
         defaultWidth = offset2.width;
         break;
       }
       case "Z":
-        value2 = fields3.zone;
+        value2 = fields4.zone;
         break;
       default:
         throw new CommandFailure(`unsupported date format directive: %${code}`);
@@ -32439,13 +32602,13 @@ var Walker2 = class {
     const name2 = depth === 0 || this.args.full ? entry.display : entry.name;
     const annotation = entry.error ?? (entry.cycle ? "recursive, not followed" : void 0);
     if (this.args.json) {
-      const fields3 = {
+      const fields4 = {
         type: entry.stat?.type === "symlink" ? "link" : entry.stat?.type ?? "unknown",
         name: name2,
         ...entry.target === void 0 ? {} : { target: entry.target },
         ...annotation === void 0 ? {} : { error: annotation }
       };
-      await this.write(`${this.padding(depth + 1)}${serialized(fields3, this.budget).slice(0, -1)}`);
+      await this.write(`${this.padding(depth + 1)}${serialized(fields4, this.budget).slice(0, -1)}`);
       if (children.length) {
         await this.write(`,"contents":[${this.newline()}`);
         for (let index = 0; index < children.length; index++) {
@@ -32991,7 +33154,7 @@ init_platform();
 // packages/safe-bash/src/commands/column/display.ts
 init_platform();
-function whitespace(character) {
+function whitespace2(character) {
   return character === " " || character === "	" || character === "\r" || character === "\v" || character === "\f";
 }
 function widthOf(point) {
@@ -33029,7 +33192,7 @@ function decode2(bytes3) {
     throw new FsError("EINVAL", { message: "invalid UTF-8 input" });
   }
 }
-async function fields2(text3, separator, budget, remainingCells) {
+async function fields3(text3, separator, budget, remainingCells) {
   const result = [];
   let start = 0, offset = 0;
   const append = (end) => {
@@ -33039,7 +33202,7 @@ async function fields2(text3, separator, budget, remainingCells) {
   };
   for (const character of text3) {
     await budget.step();
-    if (separator ? separator.has(character) : whitespace(character)) {
+    if (separator ? separator.has(character) : whitespace2(character)) {
       if (separator || offset > start) append(offset);
       start = offset + character.length;
     }
@@ -33521,7 +33684,7 @@ function createColumnCommand(options2 = {}) {
               await budget.work(bytes3.length);
               const text3 = decode2(bytes3);
               if (!text3.length) continue;
-              const values = parsed.table ? await fields2(text3, parsed.separator, budget, limits.maxCells - cellCount) : [text3];
+              const values = parsed.table ? await fields3(text3, parsed.separator, budget, limits.maxCells - cellCount) : [text3];
               if (parsed.table && !values.length) continue;
               if (!parsed.table) {
                 let blank2 = true;
@@ -34345,21 +34508,21 @@ var Renderer = class {
       this.budget.work(1);
       await this.budget.checkpoint();
       if (child.tag !== "text") return false;
-      let whitespace2 = this.whitespace.get(child);
-      if (whitespace2 === void 0) {
-        whitespace2 = true;
+      let whitespace3 = this.whitespace.get(child);
+      if (whitespace3 === void 0) {
+        whitespace3 = true;
         for (const character of child.text) {
           this.budget.work(1);
           await this.budget.checkpoint();
           if (!htmlSpace(character)) {
-            whitespace2 = false;
+            whitespace3 = false;
             break;
           }
         }
         this.budget.work(1);
-        this.whitespace.set(child, whitespace2);
+        this.whitespace.set(child, whitespace3);
       }
-      if (!whitespace2) return false;
+      if (!whitespace3) return false;
     }
     return true;
   }
@@ -35496,13 +35659,13 @@ function numeric3(value2, budget) {
   budget.allocation(value2.length);
   return BigInt(new TextDecoder().decode(value2));
 }
-function integer4(value2, budget) {
+function integer5(value2, budget) {
   const result = numeric3(value2, budget);
   if (result === void 0) throw new ExprError("non-integer argument");
   return result;
 }
 function arithmetic(operator, left, right, budget) {
-  const first = integer4(left, budget), second = integer4(right, budget);
+  const first = integer5(left, budget), second = integer5(right, budget);
   if ((operator === "/" || operator === "%") && second === 0n) throw new ExprError("division by zero");
   const firstDigits = left instanceof Uint8Array ? left.length : left.text.length;
   const secondDigits = right instanceof Uint8Array ? right.length : right.text.length;
@@ -35516,7 +35679,7 @@ function arithmetic(operator, left, right, budget) {
 }
 function compare5(left, right, budget) {
   if (numericShape(left, budget) && numericShape(right, budget)) {
-    const first = integer4(left, budget), second = integer4(right, budget);
+    const first = integer5(left, budget), second = integer5(right, budget);
     return first < second ? -1 : first > second ? 1 : 0;
   }
   requireByteCollation(budget.context);
@@ -36105,7 +36268,7 @@ function parseDuration(token) {
   let sawPoint = false;
   let trailingDigits = 0;
   let integerDigits = 0;
-  let integer9 = 0;
+  let integer10 = 0;
   let place = 1;
   let placeOverflow = false;
   let integerOverflow = false;
@@ -36122,8 +36285,8 @@ function parseDuration(token) {
         fractionSticky ||= temporary % 10 !== 0;
       } else integerDigits++;
       if (digit3 !== 0) {
-        if (placeOverflow || digit3 > Math.floor((quotient - integer9) / place)) integerOverflow = true;
-        else integer9 += digit3 * place;
+        if (placeOverflow || digit3 > Math.floor((quotient - integer10) / place)) integerOverflow = true;
+        else integer10 += digit3 * place;
       }
       if (!placeOverflow) {
         if (place > Math.floor(quotient / 10)) placeOverflow = true;
@@ -36135,7 +36298,7 @@ function parseDuration(token) {
       if (sawPoint) invalid3 = true;
       else {
         sawPoint = true;
-        integer9 = 0;
+        integer10 = 0;
         place = 1;
         placeOverflow = false;
         integerOverflow = false;
@@ -36148,7 +36311,7 @@ function parseDuration(token) {
   if (invalid3) return { kind: "invalid" };
   if (integerOverflow) return { kind: "overflow" };
   const fraction = sawPoint ? fractionCarry + (fractionSticky ? 1 : 0) : 0;
-  const product = integer9 * millisecondsPerUnit;
+  const product = integer10 * millisecondsPerUnit;
   if (fraction > maximumMilliseconds - product) return { kind: "overflow" };
   return { kind: "value", milliseconds: product + fraction };
 }
@@ -37630,7 +37793,7 @@ var precedence = {
   "%": 13,
   "**": 14
 };
-function integer5(text3) {
+function integer6(text3) {
   if (/^0[xX][\da-fA-F]+$/u.test(text3)) return BigInt(text3);
   if (/^0[0-7]+$/u.test(text3)) return BigInt(`0o${text3.slice(1)}`);
   if (/^0\d+$/u.test(text3)) throw new PublicDiagnostic("Invalid octal constant");
@@ -37688,7 +37851,7 @@ function parseArithmetic(source2, offset = 0, budget = new ParseBudget()) {
     } else {
       budget.admit();
       try {
-        left = { kind: "literal", value: BigInt.asIntN(64, integer5(token)) };
+        left = { kind: "literal", value: BigInt.asIntN(64, integer6(token)) };
       } catch {
         error("Invalid arithmetic operand");
       }
@@ -38031,7 +38194,7 @@ async function patternAdmission(pattern, context2) {
   }
   if (bracket) unsupported2("unclosed bracket pattern");
 }
-async function integer6(value2, context2) {
+async function integer7(value2, context2) {
   await charge(context2, value2.length);
   const text3 = value2.trim();
   if (!text3) return 0n;
@@ -38125,7 +38288,7 @@ async function leaf(node, context2) {
     const order = import_buffer.Buffer.compare(import_buffer.Buffer.from(left), import_buffer.Buffer.from(right));
     return node.operator === "<" ? order < 0 : order > 0;
   }
-  const first = await integer6(left, context2), second = await integer6(right, context2);
+  const first = await integer7(left, context2), second = await integer7(right, context2);
   switch (node.operator) {
     case "-eq":
       return first === second;
@@ -39660,7 +39823,7 @@ import { scopeFileSystem } from "@poe-platform/safe-fs/core";
 init_platform();
 var BraceExpansionFailure = class extends Error {
 };
-async function integer7(text3, checkpoint) {
+async function integer8(text3, checkpoint) {
   let offset = text3.startsWith("-") || text3.startsWith("+") ? 1 : 0;
   if (offset === text3.length) return void 0;
   while (text3[offset] === "0") {
@@ -39734,8 +39897,8 @@ async function* expandBraces(word, budget, signal) {
     const first = pieces[0];
     const last = pieces[1];
     admit2(256);
-    let start = await integer7(first, checkpoint);
-    let end = await integer7(last, checkpoint);
+    let start = await integer8(first, checkpoint);
+    let end = await integer8(last, checkpoint);
     const numeric4 = start !== void 0 && end !== void 0;
     if (!numeric4) {
       const alphabetic = (value2) => value2.length === 1 && (value2 >= "a" && value2 <= "z" || value2 >= "A" && value2 <= "Z");
@@ -39743,7 +39906,7 @@ async function* expandBraces(word, budget, signal) {
       start = BigInt(first.charCodeAt(0));
       end = BigInt(last.charCodeAt(0));
     }
-    let step = pieces.length === 3 ? await integer7(pieces[2], checkpoint) : 1n;
+    let step = pieces.length === 3 ? await integer8(pieces[2], checkpoint) : 1n;
     if (step === void 0) return void 0;
     if (step < 0n) step = -step;
     if (step === 0n) step = 1n;
@@ -40569,7 +40732,7 @@ var GetoptsError = class extends Error {
 function record(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
 }
-function integer8(value2, minimum, name2) {
+function integer9(value2, minimum, name2) {
   if (typeof value2 !== "number" || !Number.isSafeInteger(value2) || value2 < minimum) {
     throw new GetoptsError("INVALID_INPUT", `${name2} must be a safe integer >= ${minimum}`);
   }
@@ -40579,16 +40742,16 @@ function createGetoptsState() {
 }
 function cloneGetoptsState(state) {
   if (!record(state)) throw new GetoptsError("INVALID_INPUT", "Invalid getopts state");
-  integer8(state.index, 0, "index");
+  integer9(state.index, 0, "index");
   if (state.active === void 0) return { index: state.index };
   if (!record(state.active)) throw new GetoptsError("INVALID_INPUT", "Invalid getopts active cursor");
-  integer8(state.active.argument, 0, "active.argument");
-  integer8(state.active.offset, 1, "active.offset");
+  integer9(state.active.argument, 0, "active.argument");
+  integer9(state.active.offset, 1, "active.offset");
   return { index: state.index, active: { argument: state.active.argument, offset: state.active.offset } };
 }
 function withGetoptsIndex(state, index) {
   const copy2 = cloneGetoptsState(state);
-  integer8(index, Number.MIN_SAFE_INTEGER, "index");
+  integer9(index, Number.MIN_SAFE_INTEGER, "index");
   return index <= 1 ? createGetoptsState() : { ...copy2, index };
 }
 var ScanWork = class {
@@ -40603,10 +40766,10 @@ var ScanWork = class {
   checkpoint;
   constructor(work) {
     if (!record(work)) throw new GetoptsError("INVALID_INPUT", "Explicit getopts work controls are required");
-    integer8(work.maxArguments, 0, "maxArguments");
-    integer8(work.maxBytes, 0, "maxBytes");
-    integer8(work.maxSteps, 0, "maxSteps");
-    integer8(work.yieldEvery, 1, "yieldEvery");
+    integer9(work.maxArguments, 0, "maxArguments");
+    integer9(work.maxBytes, 0, "maxBytes");
+    integer9(work.maxSteps, 0, "maxSteps");
+    integer9(work.yieldEvery, 1, "yieldEvery");
     if (typeof work.checkpoint !== "function") throw new GetoptsError("INVALID_INPUT", "A getopts checkpoint is required");
     if (work.signal !== void 0 && (!record(work.signal) || typeof work.signal.throwIfAborted !== "function" || typeof work.signal.addEventListener !== "function" || typeof work.signal.removeEventListener !== "function")) {
       throw new GetoptsError("INVALID_INPUT", "Invalid getopts signal");
@@ -41314,9 +41477,9 @@ var Admission = class {
   }
 };
 var ArrayLedger = class _ArrayLedger {
-  constructor(bytes3, fields3, initialTicket = 0) {
+  constructor(bytes3, fields4, initialTicket = 0) {
     this.bytes = bytes3;
-    this.fields = fields3;
+    this.fields = fields4;
     if (!Number.isSafeInteger(initialTicket) || initialTicket < 0) throw new RangeError("Invalid private initial ticket");
     this.#sequence.lastIssued = initialTicket;
   }
@@ -41373,8 +41536,8 @@ var ArrayLedger = class _ArrayLedger {
   }
   derive() {
     const bytes3 = BigInt(this.bytes);
-    const fields3 = BigInt(this.fields);
-    const values = [fields3, fields3, bytes3, 128n * fields3, 8n * bytes3 + 512n * fields3, 8n * fields3, 32n * bytes3 + 256n * fields3];
+    const fields4 = BigInt(this.fields);
+    const values = [fields4, fields4, bytes3, 128n * fields4, 8n * bytes3 + 512n * fields4, 8n * fields4, 32n * bytes3 + 256n * fields4];
     const result = [0, 0, 0, 0, 0, 0, 0];
     for (let index = 0; index < values.length; index++) {
       const value2 = values[index];
@@ -41927,8 +42090,8 @@ async function mapfileOptions(context2, work, allocation) {
   const numeric4 = async (text3, maximum) => {
     let value2 = 0;
     let index = 0;
-    const whitespace2 = (code) => code === 32 || code >= 9 && code <= 13;
-    while (index < text3.length && whitespace2(text3.charCodeAt(index))) {
+    const whitespace3 = (code) => code === 32 || code >= 9 && code <= 13;
+    while (index < text3.length && whitespace3(text3.charCodeAt(index))) {
       const pending = stringCheckpoint(work);
       if (pending) await pending;
       index++;
@@ -41948,7 +42111,7 @@ async function mapfileOptions(context2, work, allocation) {
     for (; index < text3.length; index++) {
       const pending = stringCheckpoint(work);
       if (pending) await pending;
-      if (!whitespace2(text3.charCodeAt(index))) throw new MapfileUsageError(`${text3}: invalid number`, 1);
+      if (!whitespace3(text3.charCodeAt(index))) throw new MapfileUsageError(`${text3}: invalid number`, 1);
     }
     if (!digits || negative && value2 !== 0) throw new MapfileUsageError(`${text3}: invalid number`, 1);
     return value2;
@@ -42599,12 +42762,12 @@ function* pathTargets(name2, path, limits, signal, fail4) {
     yield name2;
     return;
   }
-  let fields3 = 1;
+  let fields4 = 1;
   for (let separator = path.indexOf(":"); separator >= 0; separator = path.indexOf(":", separator + 1)) {
     signal.throwIfAborted();
-    if (++fields3 > limits.maxExpansionFields) fail4("maxExpansionFields");
+    if (++fields4 > limits.maxExpansionFields) fail4("maxExpansionFields");
   }
-  if (fields3 > limits.maxExpansionFields) fail4("maxExpansionFields");
+  if (fields4 > limits.maxExpansionFields) fail4("maxExpansionFields");
   let start = 0;
   let consulted = 0;
   while (start <= path.length) {
@@ -43529,8 +43692,8 @@ var DirectoryStackWork = class {
     for (let offset = 1; offset < token.length; offset++) {
       await this.charge(1);
       const code = token.charCodeAt(offset);
-      const whitespace2 = code === 32 || code >= 9 && code <= 13;
-      if (phase === "leading" && whitespace2) continue;
+      const whitespace3 = code === 32 || code >= 9 && code <= 13;
+      if (phase === "leading" && whitespace3) continue;
       if (phase === "leading" && (code === 43 || code === 45)) {
         negative = code === 45;
         phase = "sign";
@@ -43541,7 +43704,7 @@ var DirectoryStackWork = class {
         digits = true;
         value2 = value2 * 10n + BigInt(code - 48);
         if (value2 > (negative ? 9223372036854775808n : 9223372036854775807n)) this.fail("invalid directory stack index", 2);
-      } else if (phase === "digits" && whitespace2 || phase === "trailing" && whitespace2) phase = "trailing";
+      } else if (phase === "digits" && whitespace3 || phase === "trailing" && whitespace3) phase = "trailing";
       else this.fail("invalid directory stack index", 2);
     }
     if (!digits) this.fail("invalid directory stack index", 2);
@@ -44396,8 +44559,8 @@ var Runtime = class _Runtime {
       return number6;
     }
     const word = index.word ?? parseArraySubscript(index.source ?? index.decimal, this.budget.parsing, byteLocale(state.variables), state.depth);
-    const fields3 = await this.valueWord(word, state, io, false);
-    const value2 = fields3.length === 1 ? fields3[0] : concatShellValues(fields3, io[valueScope]);
+    const fields4 = await this.valueWord(word, state, io, false);
+    const value2 = fields4.length === 1 ? fields4[0] : concatShellValues(fields4, io[valueScope]);
     if (shellValueByteLength(value2) === 0) {
       await this.diagnostic(io, "associative array: bad array subscript");
       if (create) throw completedExit(1);
@@ -44481,8 +44644,8 @@ var Runtime = class _Runtime {
       const join = async (values) => values.every((value2) => typeof value2 === "string") ? this.arrayJoin(operation2, values, "") : concatShellValues(values, io[valueScope]);
       if (assignment.kind === "element") {
         const index = await this.arrayIndex(staged, assignment.index, state, io, operation2, true);
-        const fields3 = await this.valueWord(assignment.value, state, io, false);
-        let value2 = await join(fields3);
+        const fields4 = await this.valueWord(assignment.value, state, io, false);
+        let value2 = await join(fields4);
         if (assignment.append) value2 = await join([staged.values.get(index)?.text.rawValue ?? staged.get(index) ?? "", value2]);
         await insert(index, value2);
       } else for (const entry of assignment.entries) {
@@ -44500,12 +44663,12 @@ var Runtime = class _Runtime {
           }
           if (expandedEntry) continue;
         }
-        const fields3 = await this.valueWord(entry.value, state, io, entry.index === void 0);
+        const fields4 = await this.valueWord(entry.value, state, io, entry.index === void 0);
         if (entry.index) {
           const index = numericIndex(entry.index);
-          await insert(index, await join(fields3));
+          await insert(index, await join(fields4));
           cursor = index + 1;
-        } else for (const value2 of fields3) {
+        } else for (const value2 of fields4) {
           await insert(cursor, value2);
           cursor++;
         }
@@ -45520,8 +45683,8 @@ var Runtime = class _Runtime {
             throw new ArrayFailure("indexed binding cannot be a command prefix");
           }
           await this.arrayZero(state, assignment.name, async () => {
-            const fields3 = await this.valueWord(assignment.value, state, io, false);
-            return fields3.every((value3) => typeof value3 === "string") ? this.arrayJoin(requireArrays(state).owner, fields3, "") : concatShellValues(fields3, io[valueScope]);
+            const fields4 = await this.valueWord(assignment.value, state, io, false);
+            return fields4.every((value3) => typeof value3 === "string") ? this.arrayJoin(requireArrays(state).owner, fields4, "") : concatShellValues(fields4, io[valueScope]);
           }, assignment.append);
           continue;
         }
@@ -46860,7 +47023,7 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
   }
   async letBuiltin(context2, state) {
     this.signal.throwIfAborted();
-    const { maxExpansionBytes: bytes3, maxExpansionFields: fields3 } = this.budget.limits;
+    const { maxExpansionBytes: bytes3, maxExpansionFields: fields4 } = this.budget.limits;
     const admit2 = (value3) => {
       if (typeof value3 !== "string" || value3.includes("\0")) throw new CommandFailure2("let: arguments must be strings without NUL", 2);
       if (value3.length > bytes3 || import_buffer.Buffer.byteLength(value3) > bytes3) this.budget.fail("maxExpansionBytes");
@@ -46872,7 +47035,7 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
     };
     const { args } = context2;
     if (!Array.isArray(args)) throw new CommandFailure2("let: argument array required", 2);
-    if (args.length + 1 > fields3) this.budget.fail("maxExpansionFields");
+    if (args.length + 1 > fields4) this.budget.fail("maxExpansionFields");
     admit2(context2.command);
     for (let index = 0; index < args.length; index++) {
       this.signal.throwIfAborted();
@@ -46904,7 +47067,7 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
   }
   async getoptsBuiltin(context2, state) {
     this.signal.throwIfAborted();
-    const { maxExpansionBytes: bytes3, maxExpansionFields: fields3 } = this.budget.limits;
+    const { maxExpansionBytes: bytes3, maxExpansionFields: fields4 } = this.budget.limits;
     const admit2 = (value2) => {
       if (typeof value2 !== "string") throw new CommandFailure2("getopts: arguments must be strings without NUL", 2);
       if (value2.length > bytes3 || import_buffer.Buffer.byteLength(value2) > bytes3) this.budget.fail("maxExpansionBytes");
@@ -46916,7 +47079,7 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
       this.signal.throwIfAborted();
     };
     if (!Array.isArray(context2.args)) throw new CommandFailure2("getopts: argument array required", 2);
-    if (context2.args.length + 1 > fields3) this.budget.fail("maxExpansionFields");
+    if (context2.args.length + 1 > fields4) this.budget.fail("maxExpansionFields");
     admit2(context2.command);
     for (let index = 0; index < context2.args.length; index++) {
       this.signal.throwIfAborted();
@@ -46939,10 +47102,10 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
     const monitor = explicit ? void 0 : stateMonitor(state);
     const revision = monitor?.positionalRevision;
     const supplied = explicit ? context2.args.slice(offset + 2) : state.positional;
-    if (supplied.length > fields3) this.budget.fail("maxExpansionFields");
+    if (supplied.length > fields4) this.budget.fail("maxExpansionFields");
     const maxBytes = saturatedProduct(bytes3, saturatedSum(supplied.length, 1));
     const maxSteps = saturatedSum(saturatedProduct(maxBytes, 2), saturatedSum(supplied.length, 2));
-    const work = { maxArguments: fields3, maxBytes, maxSteps, yieldEvery: 128, signal: this.signal, checkpoint };
+    const work = { maxArguments: fields4, maxBytes, maxSteps, yieldEvery: 128, signal: this.signal, checkpoint };
     let input3 = monitor?.getoptsInput;
     let allocation;
     let result;
@@ -48023,27 +48186,27 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
         let position = 0;
         point = 0;
         const separator = () => position < end && !line.escaped.has(point) && separators.includes(String.fromCodePoint(line.value.codePointAt(position)));
-        const whitespace2 = () => separator() && " 	\n".includes(line.value[position]);
+        const whitespace3 = () => separator() && " 	\n".includes(line.value[position]);
         const advance = () => {
           position += line.value.codePointAt(position) > 65535 ? 2 : 1;
           point++;
         };
-        while (position < end && whitespace2()) advance();
-        const fields3 = [];
-        while (position < end && fields3.length < names.length) {
+        while (position < end && whitespace3()) advance();
+        const fields4 = [];
+        while (position < end && fields4.length < names.length) {
           const start = position;
           while (position < end && !separator()) advance();
-          fields3.push({ start, end: position });
-          while (position < end && whitespace2()) advance();
+          fields4.push({ start, end: position });
+          while (position < end && whitespace3()) advance();
           if (position < end && separator()) advance();
-          while (position < end && whitespace2()) advance();
+          while (position < end && whitespace3()) advance();
         }
         for (let index = 0; index < names.length; index++) {
           if (state.readonlyVariables?.has(names[index])) {
             await this.diagnostic(context2, `${names[index]}: readonly variable`);
             return index === names.length - 1 ? 1 : 2;
           }
-          const field2 = fields3[index];
+          const field2 = fields4[index];
           await this.assignVariable(state, names[index], field2 ? line.value.slice(field2.start, index === names.length - 1 && position < end ? end : field2.end) : "");
         }
       }
@@ -48087,13 +48250,13 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
     return (await this.valueWords(words, state, io, declaration)).map(shellValueText);
   }
   async valueWords(words, state, io, declaration = false) {
-    const fields3 = [];
+    const fields4 = [];
     for (const word of words) {
       const values = await this.valueWord(word, state, io, !(declaration && this.assignment(word)), false, false, false, void 0, true);
-      if (values.length > this.budget.limits.maxExpansionFields - fields3.length) this.budget.fail("maxExpansionFields");
-      for (const value2 of values) fields3.push(value2);
+      if (values.length > this.budget.limits.maxExpansionFields - fields4.length) this.budget.fail("maxExpansionFields");
+      for (const value2 of values) fields4.push(value2);
     }
-    return fields3;
+    return fields4;
   }
   async part(part, state, io, hereString = false) {
     return shellValueText(await this.valuePart(part, state, io, hereString));
@@ -48581,20 +48744,20 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
   }
   async valueWord(word, state, io, split4 = true, pattern = false, hereString = false, conditionalPattern = false, regexAppend, braces = split4 && !pattern && !hereString) {
     if (braces && state.braceexpand !== false && word.parts.some((part) => part.kind === "text" && !part.quoted && part.value.includes("{"))) {
-      const fields3 = [];
+      const fields4 = [];
       let bytes3 = 0;
       for await (const expanded of expandBraces(word, this.budget, this.signal)) {
         const values = await this.valueWord(expanded, state, io, split4, pattern, hereString, conditionalPattern, regexAppend, false);
-        if (values.length > this.budget.limits.maxExpansionFields - fields3.length) this.budget.fail("maxExpansionFields");
+        if (values.length > this.budget.limits.maxExpansionFields - fields4.length) this.budget.fail("maxExpansionFields");
         for (const value2 of values) {
           const size = shellValueByteLength(value2);
           if (size > this.budget.limits.maxExpansionBytes - bytes3) this.budget.fail("maxExpansionBytes");
           bytes3 += size;
           io[valueScope]?.reserve(32 + (typeof value2 === "string" ? value2.length * 2 : 0), 0);
-          fields3.push(value2);
+          fields4.push(value2);
         }
       }
-      return fields3;
+      return fields4;
     }
     const arrayOwned = word.parts.some((part) => part.kind === "variable" && !part.prefixNames && (getArraySelector(part) !== void 0 || arrayStore(state)?.get(part.name) !== void 0));
     const prefixOwned = word.parts.some((part) => part.kind === "variable" && (part.prefixNames === "@" || part.transform && part.name === "@"));
@@ -48605,14 +48768,14 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
       if (owner) await this.prepareArrayObservers(state, owner);
       owner?.reserve({ metadata: 128 + word.parts.length * 32, allocatedSlots: word.parts.length + 1, work: word.parts.length + 5 });
       scratch?.reserve(word.parts.length * 32, 0);
-      const fields3 = [];
+      const fields4 = [];
       let emptyNameGroups;
       let quoteGroup;
       const addField = () => {
-        if (fields3.length >= this.budget.limits.maxExpansionFields) this.budget.fail("maxExpansionFields");
+        if (fields4.length >= this.budget.limits.maxExpansionFields) this.budget.fail("maxExpansionFields");
         scratch?.reserve(32, 0);
         owner?.reserve({ metadata: 32, allocatedSlots: 1, work: 3 });
-        fields3.push({ fragments: [], bytes: false, patterns: void 0, present: false, independentPresence: false });
+        fields4.push({ fragments: [], bytes: false, patterns: void 0, present: false, independentPresence: false });
       };
       addField();
       let expansionBytes = 0;
@@ -48621,7 +48784,7 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
         const size = shellValueByteLength(value2);
         if (size > this.budget.limits.maxExpansionBytes - expansionBytes) this.budget.fail("maxExpansionBytes");
         expansionBytes += size;
-        const field2 = fields3.at(-1);
+        const field2 = fields4.at(-1);
         let escapes = 0;
         if (!glob) {
           const special = conditionalPattern ? "\\*?[]-^()|+!@" : "\\*?[]-^";
@@ -48684,9 +48847,9 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
             const point = typeof piece === "string" ? piece.codePointAt(0) : void 0;
             if (typeof piece === "string" && point !== void 0 && piece.length === (point > 65535 ? 2 : 1) && points.has(point)) {
               if (!" 	\n".includes(piece)) {
-                fields3.at(-1).present = true;
+                fields4.at(-1).present = true;
                 addField();
-              } else if (fields3.at(-1).present) boundary = true;
+              } else if (fields4.at(-1).present) boundary = true;
             } else {
               if (boundary) addField();
               boundary = false;
@@ -48750,18 +48913,18 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
             if (position > 0) addField();
             append(stateMonitor(state)?.positionals.get(String(position), state.positional[position]) ?? state.positional[position], false, true);
           }
-          if (state.positional.length === 0 && word.parts.every((entry) => entry.kind === "text" && entry.value === "" || entry === part)) fields3[0].present = false;
+          if (state.positional.length === 0 && word.parts.every((entry) => entry.kind === "text" && entry.value === "" || entry === part)) fields4[0].present = false;
         } else {
           const value2 = part.kind === "text" ? part.byteValue ?? part.value : await this.valuePart(part, state, partIO, hereString);
           if (part.quoted || !split4 || state.variables.IFS === "") append(value2, !part.quoted, quotedPresence || !split4 || shellValueByteLength(value2) > 0);
           else await appendSplit(value2);
         }
-        if (fields3.length > this.budget.limits.maxExpansionFields) this.budget.fail("maxExpansionFields");
+        if (fields4.length > this.budget.limits.maxExpansionFields) this.budget.fail("maxExpansionFields");
         if (owner) await owner.ledger.checkpoint(this.signal);
       }
       const result = [];
       let resultBytes = 0;
-      for (const field2 of fields3) {
+      for (const field2 of fields4) {
         if (!field2.present && split4) continue;
         if (split4 && !field2.independentPresence && field2.quoteGroups) {
           const work = { remaining: this.budget.limits.maxExpansionBytes, signal: this.signal, exhausted: () => this.budget.fail("maxExpansionBytes") };
@@ -52027,7 +52190,7 @@ function* entities2(text3) {
 }
 function* validDeclaration(content, expectedEncoding) {
   let offset = 0;
-  const whitespace2 = function* () {
+  const whitespace3 = function* () {
     const start = offset;
     while (offset < content.length && " 	\n\r".includes(content[offset])) {
       offset++;
@@ -52040,9 +52203,9 @@ function* validDeclaration(content, expectedEncoding) {
     if (content.slice(offset, offset + name2.length).toLowerCase() !== name2) return void 0;
     offset += name2.length;
     yield name2.length;
-    yield* whitespace2();
+    yield* whitespace3();
     if (content[offset++] !== "=") return void 0;
-    yield* whitespace2();
+    yield* whitespace3();
     const quote5 = content[offset++];
     if (quote5 !== "'" && quote5 !== '"') return void 0;
     const start = offset;
@@ -52054,20 +52217,20 @@ function* validDeclaration(content, expectedEncoding) {
     if (offset >= content.length) return void 0;
     return content.slice(start, offset++);
   };
-  if (!(yield* whitespace2()) || (yield* field2("version")) !== "1.0") return false;
-  let spacing = yield* whitespace2();
+  if (!(yield* whitespace3()) || (yield* field2("version")) !== "1.0") return false;
+  let spacing = yield* whitespace3();
   if (content.slice(offset, offset + 8).toLowerCase() === "encoding") {
     if (!spacing) return false;
     const encoding = yield* field2("encoding");
     if (encoding === void 0 || encoding.length > 8 || !["utf-8", "utf-16", "utf-16le", "utf-16be"].includes(encoding.toLowerCase())) return false;
     if (expectedEncoding !== void 0 && encoding.toLowerCase() !== expectedEncoding.toLowerCase()) return false;
-    spacing = yield* whitespace2();
+    spacing = yield* whitespace3();
   }
   if (content.slice(offset, offset + 10).toLowerCase() === "standalone") {
     if (!spacing) return false;
     const standalone = yield* field2("standalone");
     if (standalone === void 0 || standalone.length > 3 || !["yes", "no"].includes(standalone.toLowerCase())) return false;
-    yield* whitespace2();
+    yield* whitespace3();
   }
   return offset === content.length;
 }
@@ -52116,7 +52279,7 @@ function* parseXmlSteps(input3, limits = {}) {
   const admitContent = () => {
     if (++contentNodes > maxContentNodes) throw new XmlLimitError("maxContentNodes", "XML content node limit exceeded");
   };
-  const whitespace2 = function* () {
+  const whitespace3 = function* () {
     let work = 0;
     while (offset < source2.length && " 	\n\r".includes(source2[offset])) {
       offset++;
@@ -52211,7 +52374,7 @@ function* parseXmlSteps(input3, limits = {}) {
     } else if (source2.startsWith("</", offset)) {
       offset += 2;
       const name2 = yield* readName();
-      yield* whitespace2();
+      yield* whitespace3();
       if (source2[offset++] !== ">" || stack.pop()?.name !== name2) invalid("mismatched closing tag");
     } else {
       offset++;
@@ -52221,16 +52384,16 @@ function* parseXmlSteps(input3, limits = {}) {
       let ownsNamespaces = stack.length === 0;
       while (true) {
         const beforeSpace = offset;
-        yield* whitespace2();
+        yield* whitespace3();
         if (source2[offset] === "/" || source2[offset] === ">") break;
         if (offset === beforeSpace) invalid("attributes require whitespace");
         const attribute = yield* readName();
         if (attributes.has(attribute)) invalid("duplicate attribute");
         if (++attributeCount > maxAttributes) throw new XmlLimitError("maxAttributes", "XML attribute limit exceeded");
         if (attributes.size >= maxAttributesPerElement) throw new XmlLimitError("maxAttributesPerElement", "XML attribute limit exceeded");
-        yield* whitespace2();
+        yield* whitespace3();
         if (source2[offset++] !== "=") invalid("missing attribute equals");
-        yield* whitespace2();
+        yield* whitespace3();
         const quote5 = source2[offset++];
         if (quote5 !== '"' && quote5 !== "'") invalid("unquoted attribute");
         const end = yield* find2(source2, quote5, offset);