@poe-platform/safe-bash 0.1.619 → 0.1.621

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

@@ -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;
     }
@@ -27437,18 +27647,23 @@ function parseArguments(context2, limits) {
   checkPath(archive, limits);
   return { list: list && !pipe, pipe, overwrite, destination: destination2, archive, patterns: patterns2 };
 }
-function tokenize2(pattern) {
+function tokenize2(pattern, noWild, stopAtDirectories) {
   const characters = Array.from(pattern);
   const tokens2 = [];
   for (let index = 0; index < characters.length; index++) {
     const character = characters[index];
-    if (character === "*") {
-      if (tokens2.at(-1)?.kind !== "star") tokens2.push({ kind: "star" });
+    if (character === "*" && !noWild) {
+      let count2 = 1;
+      while (characters[index + 1] === "*") {
+        count2++;
+        index++;
+      }
+      tokens2.push({ kind: "star", crossDirectories: !stopAtDirectories || count2 > 1 });
     } else if (character === "?") tokens2.push({ kind: "any" });
-    else if (character === "\\") {
+    else if (character === "\\" && !noWild) {
       const escaped3 = characters[++index];
       tokens2.push(escaped3 === void 0 ? { kind: "never" } : { kind: "literal", value: escaped3 });
-    } else if (character === "[") {
+    } else if (character === "[" && !noWild) {
       const negative = characters[index + 1] === "!" || characters[index + 1] === "^";
       if (negative) index++;
       const ranges = [];
@@ -27474,35 +27689,43 @@ function tokenize2(pattern) {
   return tokens2;
 }
 var Selection = class {
-  constructor(patterns2, limits, signal) {
+  constructor(patterns2, limits, signal, options2 = {}) {
     this.limits = limits;
     this.signal = signal;
-    this.patterns = patterns2.map(tokenize2);
+    this.options = options2;
+    this.patterns = patterns2.map((pattern) => tokenize2(pattern, options2.noWild === true, options2.stopAtDirectories === true));
+    this.tailComponents = patterns2.map((pattern) => pattern.split("/").length);
+    this.emptyTailMatch = patterns2.map((pattern) => !options2.noWild && (pattern === "*" || options2.stopAtDirectories === true && pattern === "**"));
   }
   limits;
   signal;
+  options;
   work = 0;
   patterns;
+  tailComponents;
+  emptyTailMatch;
   matched = /* @__PURE__ */ new Set();
   step() {
     if (++this.work > this.limits.maxPatternSteps) fail("pattern work limit exceeded");
   }
   async matches(name2, firstMatchOnly = false) {
     if (!this.patterns.length) return true;
-    const characters = Array.from(name2);
+    const fullCharacters = Array.from(name2);
     let selected = false;
     for (let pattern = 0; pattern < this.patterns.length; pattern++) {
       this.step();
+      const characters = this.options.trailingComponents ? Array.from(name2.split("/").slice(-this.tailComponents[pattern]).join("/")) : fullCharacters;
+      if (this.options.trailingComponents && !characters.length && !this.emptyTailMatch[pattern]) continue;
       let states = new Uint8Array(characters.length + 1);
       states[0] = 1;
       for (const token of this.patterns[pattern]) {
         const next = new Uint8Array(states.length);
         for (let index = 0; index < states.length; index++) {
           this.step();
-          if (token.kind === "star") next[index] = states[index] || (index > 0 ? next[index - 1] : 0);
+          if (token.kind === "star") next[index] = states[index] || (index > 0 && (token.crossDirectories || characters[index - 1] !== "/") ? next[index - 1] : 0);
           else if (states[index] && index < characters.length) {
             const character = characters[index];
-            let match = token.kind === "any" || token.kind === "literal" && token.value === character;
+            let match = token.kind === "any" && (!this.options.stopAtDirectories || character !== "/") || token.kind === "literal" && token.value === character;
             if (token.kind === "class") {
               let inRange = false;
               for (const [first, last] of token.ranges) {
@@ -27565,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"
-};
-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",
-  "no-wild",
-  "latest-time",
-  "output-file",
-  "paths",
-  "password",
-  "recurse-patterns",
-  "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",
-  "wild-stop-dirs",
-  "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;
@@ -27700,13 +27811,19 @@ 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;
+  let noWild = false;
+  let stopAtDirectories = false;
   let quiet = false;
   let junkPaths = false;
   let omitDirectories = false;
   let storeLinks = false;
   let test = false;
+  let fromDate;
+  let beforeDate;
   let descriptors = false;
   let zip64;
   let metadata3 = "default";
@@ -27719,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 === "--") {
@@ -27729,18 +27846,26 @@ async function parse12(scope, limits) {
     } else if (!literal && argument2.startsWith("-") && argument2 !== "-") {
       for (let offset = 1; offset < argument2.length; offset++) {
         const flag = argument2[offset];
-        if (flag === "r") recursive = true;
-        else if (flag === "f" && argument2[offset + 1] === "d") {
+        if (flag === "r" || flag === "R") {
+          if (flag === "r") recursive = true;
+          else recursivePatterns = true;
+          if (recursive && recursivePatterns) throw new ZipFailure(16, "Invalid command arguments", "do not specify both -r and -R");
+        } else if (flag === "f" && argument2[offset + 1] === "d") {
           if (argument2[offset + 2] === "-") throw new ZipFailure(16, "Invalid command arguments", "option fd is not negatable");
           descriptors = true;
           offset++;
         } else if (flag === "f" && argument2[offset + 1] === "z") {
           zip64 = argument2[offset + 2] !== "-";
           offset += zip64 ? 1 : 2;
-        } else if (flag === "d" || flag === "u" || flag === "f") {
-          const next = flag === "d" ? "delete" : flag === "u" ? "update" : "freshen";
+        } 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") {
+          if (argument2[offset + 2] === "-") throw new ZipFailure(16, "Invalid command arguments", "wildcard control is not negatable");
+          if (flag === "n") noWild = true;
+          else stopAtDirectories = true;
+          offset++;
         } else if (flag === "q") quiet = true;
         else if (flag === "j") junkPaths = true;
         else if (flag === "X") {
@@ -27753,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++;
@@ -27786,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;
@@ -27808,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 });
@@ -27835,7 +27983,8 @@ async function parse12(scope, limits) {
       start = end + 1;
     }
   }
-  return { action, archive, recursive, quiet, junkPaths, omitDirectories, storeLinks, test, descriptors, zip64, metadata: metadata3, includes, excludes, level, method, suffixes, operands: [...names, ...operands], firstOperand };
+  if (recursivePatterns && !names.length && !operands.length) throw new ZipFailure(16, "Invalid command arguments", "nothing to select from");
+  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");
@@ -27880,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 }));
@@ -27890,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]));
@@ -27907,7 +28077,8 @@ async function prepare(scope, parsed, budget) {
 `);
   const selected = /* @__PURE__ */ new Map();
   const deleted = /* @__PURE__ */ new Set();
-  const selection = new Selection([...parsed.includes, ...parsed.excludes], limits, context2.signal);
+  const selection = new Selection([...parsed.includes, ...parsed.excludes], limits, context2.signal, { noWild: parsed.noWild, stopAtDirectories: parsed.stopAtDirectories });
+  const recursiveSelection = parsed.recursivePatterns ? new Selection(parsed.operands, limits, context2.signal, { noWild: parsed.noWild, stopAtDirectories: parsed.stopAtDirectories, trailingComponents: true }) : void 0;
   const ancestors = [];
   let visits = 0;
   let work = 0;
@@ -27938,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);
@@ -27958,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);
+    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);
@@ -27999,7 +28171,7 @@ async function prepare(scope, parsed, budget) {
         await encodeSelected(source2, name2, bytes4, { modified: new Date(stat.mtimeMs), mode: stat.mode, directory: directory2, symlink });
       }
     }
-    if (directory2 && parsed.recursive) {
+    if (directory2 && (parsed.recursive || parsed.recursivePatterns)) {
       if (ancestors.some((ancestor) => ancestor.path === canonical || sameIdentity2(ancestor.stat, stat))) fail(`directory cycle while archiving: ${source2}`);
       ancestors.push({ path: canonical, stat });
       try {
@@ -28015,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.operands, limits, context2.signal);
-    if (parsed.operands.length) {
+    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) {
@@ -28033,11 +28213,12 @@ async function prepare(scope, parsed, budget) {
     }
   } else {
     const operands = parsed.operands.length || parsed.action === "add" ? parsed.operands : archive.entries.map((entry) => entry.name);
-    for (const operand of operands) await visit(operand, memberName(operand, limits), 0);
+    if (parsed.recursivePatterns) await visit(".", "", 0);
+    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.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 = [];
@@ -28063,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);
@@ -28077,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);
@@ -29181,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");
     }
   };
@@ -29240,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;
@@ -29262,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);
@@ -29277,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);
@@ -31222,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;
@@ -31244,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);
@@ -31294,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),
@@ -31310,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");
@@ -31351,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);
@@ -31364,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]),
@@ -31372,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]),
@@ -31384,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}`);
 }
@@ -31404,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) => {
@@ -31467,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":
@@ -31507,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;
@@ -31522,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":
@@ -31547,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":
@@ -31592,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}`);
@@ -32412,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++) {
@@ -32964,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) {
@@ -33002,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) => {
@@ -33012,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;
     }
@@ -33494,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;
@@ -34318,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;
   }
@@ -35469,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;
@@ -35489,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);
@@ -36078,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;
@@ -36095,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;
@@ -36108,7 +36298,7 @@ function parseDuration(token) {
       if (sawPoint) invalid3 = true;
       else {
         sawPoint = true;
-        integer9 = 0;
+        integer10 = 0;
         place = 1;
         placeOverflow = false;
         integerOverflow = false;
@@ -36121,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 };
 }
@@ -37603,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");
@@ -37661,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");
       }
@@ -38004,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;
@@ -38098,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;
@@ -39633,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") {
@@ -39707,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");
@@ -39716,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;
@@ -40542,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}`);
   }
@@ -40552,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 {
@@ -40576,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");
@@ -41287,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;
   }
@@ -41346,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];
@@ -41900,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++;
@@ -41921,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;
@@ -42572,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) {
@@ -43502,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";
@@ -43514,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);
@@ -44369,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);
@@ -44454,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) {
@@ -44473,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++;
         }
@@ -45493,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;
         }
@@ -46833,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");
@@ -46845,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();
@@ -46877,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");
@@ -46889,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();
@@ -46912,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;
@@ -47996,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) : "");
         }
       }
@@ -48060,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));
@@ -48554,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 === "@"));
@@ -48578,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;
@@ -48594,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 ? "\\*?[]-^()|+!@" : "\\*?[]-^";
@@ -48657,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;
@@ -48723,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") };
@@ -52000,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++;
@@ -52013,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;
@@ -52027,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;
 }
@@ -52089,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++;
@@ -52184,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++;
@@ -52194,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);