@poe-platform/safe-bash 0.1.79 → 0.1.80

package/dist/safe-bash/browser.js

@@ -5734,6 +5734,46 @@ init_platform();
 
 // packages/safe-bash/src/shell/pattern.ts
 init_platform();
+
+// packages/safe-bash/src/shell/string-operations.ts
+init_platform();
+function stringCheckpoint(work, units = 1) {
+  work.signal.throwIfAborted();
+  work.remaining -= units;
+  if (work.remaining < 0) work.exhausted();
+  work.steps = (work.steps ?? 0) + units;
+  if (work.steps < 128) return void 0;
+  work.steps %= 128;
+  return yieldTurn(work.signal);
+}
+function nextCodePointOffset(value2, offset) {
+  if (offset >= value2.length) return value2.length;
+  return offset + (value2.codePointAt(offset) > 65535 ? 2 : 1);
+}
+function previousCodePointOffset(value2, offset) {
+  if (offset <= 0) return 0;
+  const last = value2.charCodeAt(offset - 1);
+  const previous = value2.charCodeAt(offset - 2);
+  return offset - (last >= 56320 && last <= 57343 && previous >= 55296 && previous <= 56319 ? 2 : 1);
+}
+async function scanString(value2, work, start = 0, end = value2.length, maximum = Infinity) {
+  let position = start;
+  let count2 = 0;
+  let bytes2 = 0;
+  while (position < end && count2 < maximum) {
+    const pending = stringCheckpoint(work);
+    if (pending) await pending;
+    work.signal.throwIfAborted();
+    const point = position + 1 < end ? value2.codePointAt(position) : value2.charCodeAt(position);
+    position += point > 65535 ? 2 : 1;
+    bytes2 += point <= 127 ? 1 : point <= 2047 ? 2 : point <= 65535 ? 3 : 4;
+    count2++;
+  }
+  work.signal.throwIfAborted();
+  return { end: position, count: count2, bytes: bytes2 };
+}
+
+// packages/safe-bash/src/shell/pattern.ts
 var characterClasses = {
   alnum: "a-zA-Z0-9",
   alpha: "a-zA-Z",
@@ -5751,6 +5791,9 @@ var characterClasses = {
   xdigit: "a-fA-F0-9"
 };
 async function tokens(pattern, work) {
+  const admission = stringCheckpoint(work, pattern.length);
+  if (admission) await admission;
+  work.allocation?.reserve(128 + pattern.length * 64, 0);
   const result = [];
   const characters = Array.from(pattern);
   const lastClosingBracket = characters.lastIndexOf("]");
@@ -5818,37 +5861,36 @@ async function tokens(pattern, work) {
 async function compilePattern(pattern, work) {
   work.signal.throwIfAborted();
   const patternTokens = await tokens(pattern, work);
-  return (value2) => matchTokens(patternTokens, value2, work);
+  return (value2, start = 0, end = value2.length) => matchTokens(patternTokens, value2, work, start, end);
 }
 async function matchesPattern(pattern, value2, work) {
   return (await compilePattern(pattern, work))(value2);
 }
-async function matchTokens(patternTokens, value2, work) {
+async function matchTokens(patternTokens, value2, work, start, end) {
   work.signal.throwIfAborted();
-  const characters = Array.from(value2);
-  let position = 0;
+  let position = start;
   let tokenIndex = 0;
   let star = -1;
-  let retry = 0;
-  let steps = 0;
-  while (position < characters.length) {
-    if (--work.remaining < 0) work.exhausted();
-    if (++steps % 1024 === 0) {
-      await yieldTurn(work.signal);
-      work.signal.throwIfAborted();
-    }
+  let retry = start;
+  while (position < end) {
+    const pending = stringCheckpoint(work);
+    if (pending) await pending;
+    work.signal.throwIfAborted();
     const token = patternTokens[tokenIndex];
+    const point = value2.codePointAt(position);
     if (token?.kind === "star") {
       star = tokenIndex++;
       retry = position;
-    } else if (token && (token.kind === "any" || (token.kind === "literal" ? token.value === characters[position] : token.expression.test(characters[position])))) {
-      position++;
+    } else if (token && (token.kind === "any" || (token.kind === "literal" ? token.value.codePointAt(0) === point : token.expression.test(String.fromCodePoint(point))))) {
+      position += point > 65535 ? 2 : 1;
       tokenIndex++;
     } else if (star !== -1) {
       tokenIndex = star + 1;
-      position = ++retry;
+      retry = nextCodePointOffset(value2, retry);
+      position = retry;
     } else return false;
   }
+  work.signal.throwIfAborted();
   while (patternTokens[tokenIndex]?.kind === "star") tokenIndex++;
   return tokenIndex === patternTokens.length;
 }
@@ -6082,6 +6124,7 @@ var Lexer = class {
   documentLine;
   partial;
   position = 0;
+  operandDepth = 0;
   printedNewlineReduction = 0;
   unprintedWords = 0;
   delimiterOperator;
@@ -6464,7 +6507,7 @@ shell: command substitution: line ${line}: \`${sourceLine}'
       if (this.source[this.position] !== "`") this.error("Unterminated command substitution");
       this.position++;
       try {
-        parts.push({ kind: "substitution", script: parseSource(source, this.depth + 1, this.warnings, line - 1, this.byteLocale, this.budget), line, quoted });
+        parts.push({ kind: "substitution", script: parseSource(source, this.depth + this.operandDepth + 1, this.warnings, line - 1, this.byteLocale, this.budget), line, quoted });
       } catch (error) {
         if (this.documentLine === void 0 || !(error instanceof ShellSyntaxError) || /nesting|exceeds/u.test(error.reason)) throw error;
         this.budget.admit();
@@ -6486,7 +6529,7 @@ shell: command substitution: line ${line}: \`${sourceLine}'
       let script;
       try {
         this.budget.admit();
-        nested = new Parser(this.budget, this.source.slice(start), this.depth + 1, this.warnings, this.lineAt(start) - 1, void 0, this.byteLocale);
+        nested = new Parser(this.budget, this.source.slice(start), this.depth + this.operandDepth + 1, this.warnings, this.lineAt(start) - 1, void 0, this.byteLocale);
         script = nested.script(/* @__PURE__ */ new Set([")"]));
       } catch (error) {
         if (this.documentLine !== void 0 && error instanceof ShellSyntaxError && !/nesting|exceeds/u.test(error.reason)) throw this.documentSubstitutionError(this.source.slice(start), error);
@@ -6524,25 +6567,33 @@ shell: command substitution: line ${line}: \`${sourceLine}'
       let alternate;
       let replacement;
       let substring;
-      if (operator) {
-        if (length) this.error("Invalid length expansion");
-        this.position += operator.length;
-        alternate = this.word(operator.startsWith("/") ? "/}" : "}", quoted && !["#", "##", "%", "%%"].includes(operator) && !operator.startsWith("/"));
-        if (operator.startsWith("/") && this.source[this.position] === "/") {
-          this.position++;
-          replacement = this.word("}");
-        }
-      } else if (this.source[this.position] === ":") {
-        if (length || !/^(?:[a-zA-Z_][a-zA-Z_0-9]*|[0-9]+)$/u.test(name2)) this.error("Unsupported non-scalar substring expansion");
-        this.position++;
-        const offset = this.word(":}", true, false, true);
-        let substringLength;
-        if (this.source[this.position] === ":") {
-          this.position++;
-          substringLength = this.word("}", true, false, true);
+      if (operator || this.source[this.position] === ":") {
+        if (this.depth + this.operandDepth + 1 > 64) this.error("Syntax nesting exceeds 64");
+        this.operandDepth++;
+        try {
+          if (operator) {
+            if (length) this.error("Invalid length expansion");
+            this.position += operator.length;
+            alternate = this.word(operator.startsWith("/") ? "/}" : "}", quoted && !["#", "##", "%", "%%"].includes(operator) && !operator.startsWith("/"));
+            if (operator.startsWith("/") && this.source[this.position] === "/") {
+              this.position++;
+              replacement = this.word("}");
+            }
+          } else {
+            if (length || !/^(?:[a-zA-Z_][a-zA-Z_0-9]*|[0-9]+)$/u.test(name2)) this.error("Unsupported non-scalar substring expansion");
+            this.position++;
+            const offset = this.word(":}", true, false, true);
+            let substringLength;
+            if (this.source[this.position] === ":") {
+              this.position++;
+              substringLength = this.word("}", true, false, true);
+            }
+            this.budget.admit();
+            substring = { offset, ...substringLength ? { length: substringLength } : {}, source: this.source.slice(parameterStart, this.position + 1) };
+          }
+        } finally {
+          this.operandDepth--;
         }
-        this.budget.admit();
-        substring = { offset, ...substringLength ? { length: substringLength } : {}, source: this.source.slice(parameterStart, this.position + 1) };
       }
       if (this.source[this.position] !== "}") this.error("Unterminated or unsupported parameter expansion");
       this.position++;
@@ -14822,7 +14873,14 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
       holding?.release();
     }
   }
+  parameterOperandIO(word, state, io) {
+    this.signal.throwIfAborted();
+    const parameterDepth = (io.parameterDepth ?? 0) + 1;
+    if (state.depth + parameterDepth > 64) throw new ShellSyntaxError("Syntax nesting exceeds 64", word.offset);
+    return { ...io, parameterDepth };
+  }
   async partValue(part, state, io, hereString) {
+    this.signal.throwIfAborted();
     if (part.kind === "failed-substitution") {
       if (state.depth >= this.budget.limits.maxSubstitutionDepth) this.budget.fail("maxSubstitutionDepth");
       await writeText(io.stderr, part.diagnostic);
@@ -14848,6 +14906,8 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
     }
     if (part.kind === "substitution") {
       if (state.depth >= this.budget.limits.maxSubstitutionDepth) this.budget.fail("maxSubstitutionDepth");
+      const parameterDepth = io.parameterDepth ?? 0;
+      if (parameterDepth > 0 && state.depth + parameterDepth + 1 > 64) throw new ShellSyntaxError("Syntax nesting exceeds 64", 0);
       const capture = new Capture();
       const child = await cloneState(state, this.signal);
       child.isolated = true;
@@ -14898,7 +14958,7 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
         if (index === void 0) throw new ArrayFailure("index outside 0..2147483647");
         const value3 = binding ? binding.get(index) : index === 0 ? state.variables[part.name] : void 0;
         this.requireParameter(value3, `${part.name}[${selector.index}]`, state, io, part.line);
-        return part.length ? String(Array.from(value3 ?? "").length) : value3 ?? "";
+        return part.length ? this.parameterLength(value3 ?? "") : value3 ?? "";
       }
       if (part.length) return String(binding?.values.size ?? (state.variables[part.name] === void 0 ? 0 : 1));
       const values = await this.arrayMembers(part.name, state);
@@ -14927,17 +14987,18 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
       const missing = value2 === void 0 || part.operator.startsWith(":") && value2 === "";
       const operator = part.operator.at(-1);
       if (operator === "+" && !missing || operator !== "+" && missing) {
+        const operandIO = this.parameterOperandIO(part.alternate, state, io);
         let alternate;
         if (operator === "=" && arrayStore(state)?.get(part.name)) {
           alternate = "";
           await this.arrayZero(state, part.name, async () => {
-            alternate = await this.arrayJoin(requireArrays(state).owner, await this.word(part.alternate, state, io, false, false, hereString), "");
+            alternate = await this.arrayJoin(requireArrays(state).owner, await this.word(part.alternate, state, operandIO, false, false, hereString), "");
             return alternate;
           });
           value2 = alternate;
-          return part.length ? String(Array.from(value2).length) : value2;
+          return part.length ? this.parameterLength(value2) : value2;
         }
-        retained = concatShellValues(await this.valueWord(part.alternate, state, io, false, false, hereString), io[valueScope]);
+        retained = concatShellValues(await this.valueWord(part.alternate, state, operandIO, false, false, hereString), io[valueScope]);
         alternate = shellValueText(retained);
         if (operator === "?") throw new ParameterExpansionFailure(`${part.name}: ${alternate || (part.operator.startsWith(":") ? "parameter null or not set" : "parameter not set")}`, io.diagnosticLine ?? part.line);
         if (operator === "=") {
@@ -14950,7 +15011,14 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
         retained = "";
       }
     } else this.requireParameter(value2, part.name, state, io, part.line);
-    return part.length ? String(Array.from(value2 ?? "").length) : retained ?? "";
+    return part.length ? this.parameterLength(value2 ?? "") : retained ?? "";
+  }
+  async parameterLength(value2) {
+    const limit = this.budget.limits.maxExpansionBytes;
+    const work = { remaining: Math.min(Number.MAX_SAFE_INTEGER, limit * 4 + 1024), signal: this.signal, exhausted: () => this.budget.fail("maxExpansionBytes") };
+    const scanned = await scanString(value2, work);
+    if (scanned.bytes > limit) this.budget.fail("maxExpansionBytes");
+    return String(scanned.count);
   }
   async substring(part, value2, state, io) {
     const owner = arrayStore(state)?.get(part.name) ? requireArrays(state).owner : void 0;
@@ -14960,147 +15028,198 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
     if (value2 === void 0) return "";
     const limit = this.budget.limits.maxExpansionBytes;
     if (import_buffer.Buffer.byteLength(value2) > limit) this.budget.fail("maxExpansionBytes");
-    const variables = new Proxy(this.arithmeticVariables(state, line), { get: (target, key) => {
-      this.signal.throwIfAborted();
-      const value3 = Reflect.get(target, key);
-      if (typeof value3 === "string" && import_buffer.Buffer.byteLength(value3) > limit) this.budget.fail("maxExpansionBytes");
-      return value3;
-    } });
-    const arithmetic = async (word) => {
-      let source = "";
-      let bytes3 = 0;
-      for (const entry of word.parts) {
+    const scratch = this.budget.values.scope();
+    const work = { remaining: Math.min(Number.MAX_SAFE_INTEGER, limit * 4 + 1024), signal: this.signal, exhausted: () => this.budget.fail("maxExpansionBytes") };
+    try {
+      const variables = new Proxy(this.arithmeticVariables(state, line), { get: (target, key) => {
+        this.signal.throwIfAborted();
+        const value3 = Reflect.get(target, key);
+        if (typeof value3 === "string" && import_buffer.Buffer.byteLength(value3) > limit) this.budget.fail("maxExpansionBytes");
+        return value3;
+      } });
+      const arithmetic = async (word) => {
+        const operandIO = this.parameterOperandIO(word, state, io);
+        let source = "";
+        let bytes3 = 0;
+        let retained;
+        for (const entry of word.parts) {
+          this.signal.throwIfAborted();
+          const text = entry.kind === "text" ? entry.value : await this.part(entry, state, operandIO);
+          bytes3 += import_buffer.Buffer.byteLength(text);
+          if (bytes3 > limit) this.budget.fail("maxExpansionBytes");
+          owner?.reserve({ metadata: 32, payload: bytes3, work: text.length + 4 });
+          const pending = stringCheckpoint(work, text.length + 1);
+          if (pending) await pending;
+          const next = scratch.reserve((source.length + text.length) * 2, 0);
+          source += text;
+          retained?.release();
+          retained = next;
+        }
         this.signal.throwIfAborted();
-        const text = entry.kind === "text" ? entry.value : await this.part(entry, state, io);
-        bytes3 += import_buffer.Buffer.byteLength(text);
-        if (bytes3 > limit) this.budget.fail("maxExpansionBytes");
-        owner?.reserve({ metadata: 32, payload: bytes3, work: text.length + 4 });
-        source += text;
+        try {
+          return { value: evaluateArithmetic(prepareArithmetic(source, this.budget.parsing), variables, this.budget.parsing), source };
+        } catch (error) {
+          this.rethrowArithmeticControl(error);
+          throw new ExpansionFailure(`${part.name}: ${message(error)}`, line);
+        } finally {
+          retained?.release();
+        }
+      };
+      const offsetExpression = await arithmetic(expression.offset);
+      let bytes2;
+      if (byteLocale(state.variables)) {
+        scratch.reserve(import_buffer.Buffer.byteLength(value2), 0);
+        bytes2 = import_buffer.Buffer.from(value2);
+      }
+      const size = BigInt(bytes2?.byteLength ?? (await scanString(value2, work)).count);
+      const offset = offsetExpression.value < 0n ? size + offsetExpression.value : offsetExpression.value;
+      if (offset < 0n || offset > size) return "";
+      let end = size;
+      if (expression.length) {
+        const length = await arithmetic(expression.length);
+        end = length.value < 0n ? size + length.value : offset + length.value;
+        if (end < offset) throw new ExpansionFailure(`${length.source}: substring expression < 0`, line);
+        if (end > size) end = size;
       }
       this.signal.throwIfAborted();
+      if (!bytes2) {
+        const start = (await scanString(value2, work, 0, value2.length, Number(offset))).end;
+        const finish = (await scanString(value2, work, start, value2.length, Number(end - offset))).end;
+        if (finish > start) scratch.reserve((finish - start) * 2, 0);
+        return value2.slice(start, finish);
+      }
+      scratch.reserve(Number(end - offset) * 2, 0);
       try {
-        return { value: evaluateArithmetic(prepareArithmetic(source, this.budget.parsing), variables, this.budget.parsing), source };
-      } catch (error) {
-        this.rethrowArithmeticControl(error);
-        throw new ExpansionFailure(`${part.name}: ${message(error)}`, line);
+        return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes2.subarray(Number(offset), Number(end)));
+      } catch {
+        throw new ExpansionFailure("substring expansion splits a UTF-8 character in a byte locale", line);
       }
-    };
-    const offsetExpression = await arithmetic(expression.offset);
-    owner?.reserve({ metadata: 128 + value2.length * 64, payload: import_buffer.Buffer.byteLength(value2), allocatedSlots: value2.length, work: value2.length + 8 });
-    const characters = byteLocale(state.variables) ? void 0 : Array.from(value2);
-    const bytes2 = characters ? void 0 : import_buffer.Buffer.from(value2);
-    const size = BigInt(characters?.length ?? bytes2.byteLength);
-    const offset = offsetExpression.value < 0n ? size + offsetExpression.value : offsetExpression.value;
-    if (offset < 0n || offset > size) return "";
-    let end = size;
-    if (expression.length) {
-      const length = await arithmetic(expression.length);
-      end = length.value < 0n ? size + length.value : offset + length.value;
-      if (end < offset) throw new ExpansionFailure(`${length.source}: substring expression < 0`, line);
-      if (end > size) end = size;
-    }
-    this.signal.throwIfAborted();
-    owner?.reserve({ metadata: 96 + value2.length * 32, payload: import_buffer.Buffer.byteLength(value2) * 3, allocatedSlots: value2.length, work: value2.length + 7 });
-    if (characters) return characters.slice(Number(offset), Number(end)).join("");
-    try {
-      return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes2.subarray(Number(offset), Number(end)));
-    } catch {
-      throw new ExpansionFailure("substring expansion splits a UTF-8 character in a byte locale", line);
+    } finally {
+      scratch.close();
     }
   }
   async parameterPattern(part, text, state, io, hereString) {
-    const owner = arrayStore(state)?.get(part.name) ? requireArrays(state).owner : void 0;
     const limit = this.budget.limits.maxExpansionBytes;
     if (import_buffer.Buffer.byteLength(text) > limit) this.budget.fail("maxExpansionBytes");
-    const patternFields = await this.word(part.alternate, state, io, false, true, hereString);
-    const pattern = owner ? await this.arrayJoin(owner, patternFields, "") : patternFields.join("");
-    owner?.reserve({ metadata: 128 + text.length * 64, payload: import_buffer.Buffer.byteLength(text), allocatedSlots: text.length, work: text.length + 8 });
-    const characters = Array.from(text);
-    const slice = (start, end = characters.length) => {
-      owner?.reserve({ metadata: 96 + (end - start) * 32, payload: (end - start) * 4, allocatedSlots: end - start, work: end - start + 7 });
-      return characters.slice(start, end).join("");
-    };
-    const work = { remaining: Math.min(Number.MAX_SAFE_INTEGER, limit * 4 + 1024), signal: this.signal, exhausted: () => this.budget.fail("maxExpansionBytes") };
-    const matches = await compilePattern(pattern, work);
-    let attempts = 0;
-    const match = async (start, end) => {
-      work.remaining -= end - start + 1;
-      if (work.remaining < 0) work.exhausted();
-      if (++attempts % 256 === 0) await yieldTurn(this.signal);
-      this.signal.throwIfAborted();
-      if (owner) await owner.ledger.checkpoint(this.signal, end - start + 1);
-      return matches(slice(start, end));
-    };
-    const operator = part.operator;
-    if (!operator.startsWith("/")) {
-      const longest = operator.length === 2;
-      for (let length = longest ? characters.length : 0; longest ? length >= 0 : length <= characters.length; length += longest ? -1 : 1) {
+    const scratch = this.budget.values.scope();
+    const work = { remaining: Math.min(Number.MAX_SAFE_INTEGER, limit * 4 + 1024), signal: this.signal, exhausted: () => this.budget.fail("maxExpansionBytes"), allocation: scratch };
+    try {
+      const patternFields = await this.word(part.alternate, state, this.parameterOperandIO(part.alternate, state, io), false, true, hereString);
+      let patternUnits = 0;
+      for (const field of patternFields) {
+        const pending = stringCheckpoint(work, field.length + 1);
+        if (pending) await pending;
+        patternUnits += field.length;
+      }
+      scratch.reserve(patternUnits * 2, 0);
+      const pattern = patternFields.join("");
+      const size = (await scanString(text, work)).count;
+      const matches = await compilePattern(pattern, work);
+      const match = async (start, end, length) => {
+        const pending = stringCheckpoint(work, length + 1);
+        if (pending) await pending;
+        return matches(text, start, end);
+      };
+      const operator = part.operator;
+      if (!operator.startsWith("/")) {
+        const longest = operator.length === 2;
         const prefix2 = operator.startsWith("#");
-        if (await match(prefix2 ? 0 : characters.length - length, prefix2 ? length : characters.length)) return prefix2 ? slice(length) : slice(0, characters.length - length);
-      }
-      return text;
-    }
-    const replacements = [];
-    owner?.reserve({ metadata: 64, work: 3 });
-    let replacementBytes = 0;
-    for (const [index, entry] of (part.replacement?.parts ?? []).entries()) {
-      let value2 = entry.kind === "text" ? entry.value : await this.part(entry, state, io, hereString);
-      if (index === 0 && !entry.quoted && /^~(?:\/|$)/u.test(value2)) value2 = (state.variables.HOME ?? "~") + value2.slice(1);
-      replacementBytes += import_buffer.Buffer.byteLength(value2);
-      if (replacementBytes > limit) this.budget.fail("maxExpansionBytes");
-      owner?.reserve({ metadata: 64, payload: import_buffer.Buffer.byteLength(value2), allocatedSlots: 1, work: 5 });
-      replacements.push({ value: value2, quoted: entry.quoted });
-    }
-    if (!pattern && operator !== "/#" && operator !== "/%") return text;
-    let result = "";
-    let resultBytes = 0;
-    const append = (value2) => {
-      resultBytes += import_buffer.Buffer.byteLength(value2);
-      if (resultBytes > limit) this.budget.fail("maxExpansionBytes");
-      owner?.reserve({ metadata: 32, payload: resultBytes, work: value2.length + 4 });
-      result += value2;
-    };
-    let position = 0;
-    while (position <= characters.length) {
-      let found = false;
-      for (let start = position; start <= characters.length; start++) {
-        if (operator === "/#" && start !== 0) break;
-        for (let end = characters.length; end >= start; end--) {
-          if (operator === "/%" && end !== characters.length) break;
-          if (!await match(start, end)) continue;
-          append(slice(position, start));
-          const matched = slice(start, end);
-          for (const replacement of replacements) {
-            if (replacement.quoted) append(replacement.value);
-            else {
-              owner?.reserve({ metadata: 64 + replacement.value.length * 64, payload: import_buffer.Buffer.byteLength(replacement.value), allocatedSlots: replacement.value.length, work: replacement.value.length + 4 });
-              const pieces = replacement.value.split("&");
-              for (const [index, piece] of pieces.entries()) {
-                if (index) append(matched);
-                append(piece);
+        let boundary = longest === prefix2 ? text.length : 0;
+        for (let length = longest ? size : 0; longest ? length >= 0 : length <= size; length += longest ? -1 : 1) {
+          if (await match(prefix2 ? 0 : boundary, prefix2 ? boundary : text.length, length)) {
+            const start = prefix2 ? boundary : 0;
+            const end = prefix2 ? text.length : boundary;
+            scratch.reserve((end - start) * 2, 0);
+            return text.slice(start, end);
+          }
+          boundary = longest === prefix2 ? previousCodePointOffset(text, boundary) : nextCodePointOffset(text, boundary);
+        }
+        return text;
+      }
+      scratch.reserve(64, 0);
+      const replacements = [];
+      let replacementBytes = 0;
+      const replacementIO = part.replacement ? this.parameterOperandIO(part.replacement, state, io) : io;
+      for (const [index, entry] of (part.replacement?.parts ?? []).entries()) {
+        let value2 = entry.kind === "text" ? entry.value : await this.part(entry, state, replacementIO, hereString);
+        if (index === 0 && !entry.quoted && /^~(?:\/|$)/u.test(value2)) {
+          const home = state.variables.HOME ?? "~";
+          scratch.reserve((home.length + value2.length - 1) * 2, 0);
+          value2 = home + value2.slice(1);
+        }
+        replacementBytes += import_buffer.Buffer.byteLength(value2);
+        if (replacementBytes > limit) this.budget.fail("maxExpansionBytes");
+        const pending = stringCheckpoint(work, value2.length + 1);
+        if (pending) await pending;
+        scratch.reserve(64 + value2.length * 2, 0);
+        replacements.push({ value: value2, quoted: entry.quoted });
+      }
+      if (!pattern && operator !== "/#" && operator !== "/%") return text;
+      let result = "";
+      let resultBytes = 0;
+      let retained;
+      const append = async (value2, start = 0, end = value2.length) => {
+        resultBytes += (await scanString(value2, work, start, end)).bytes;
+        if (resultBytes > limit) this.budget.fail("maxExpansionBytes");
+        if (start === end) return;
+        const fragment = scratch.reserve((end - start) * 2, 0);
+        const next = scratch.reserve((result.length + end - start) * 2, 0);
+        result += value2.slice(start, end);
+        fragment.release();
+        retained?.release();
+        retained = next;
+      };
+      let position = 0;
+      let positionIndex = 0;
+      while (positionIndex <= size) {
+        let found = false;
+        for (let start = position, startIndex = positionIndex; startIndex <= size; startIndex++, start = nextCodePointOffset(text, start)) {
+          if (operator === "/#" && start !== 0) break;
+          for (let end = text.length, endIndex = size; endIndex >= startIndex; endIndex--, end = previousCodePointOffset(text, end)) {
+            if (operator === "/%" && end !== text.length) break;
+            if (!await match(start, end, endIndex - startIndex)) continue;
+            await append(text, position, start);
+            for (const replacement of replacements) {
+              if (replacement.quoted) await append(replacement.value);
+              else {
+                let fragment = 0;
+                for (let cursor = 0; cursor < replacement.value.length; cursor++) {
+                  const pending = stringCheckpoint(work);
+                  if (pending) await pending;
+                  if (replacement.value[cursor] !== "&") continue;
+                  await append(replacement.value, fragment, cursor);
+                  await append(text, start, end);
+                  fragment = cursor + 1;
+                }
+                await append(replacement.value, fragment);
               }
             }
+            position = end;
+            positionIndex = endIndex;
+            found = true;
+            if (operator !== "//" || end === text.length) {
+              await append(text, end);
+              return result;
+            }
+            if (end === start) {
+              position = nextCodePointOffset(text, end);
+              positionIndex++;
+              await append(text, end, position);
+            }
+            break;
           }
-          position = end;
-          found = true;
-          if (operator !== "//" || end === characters.length) {
-            append(slice(end));
-            return result;
-          }
-          if (end === start) {
-            append(characters[position]);
-            position++;
-          }
+          if (found) break;
+        }
+        if (!found) {
+          if (positionIndex === 0) return text;
+          await append(text, position);
           break;
         }
-        if (found) break;
-      }
-      if (!found) {
-        append(slice(position));
-        break;
       }
+      return result;
+    } finally {
+      scratch.close();
     }
-    return result;
   }
   async word(word, state, io, split = true, pattern = false, hereString = false, conditionalPattern = false, regexAppend) {
     return (await this.valueWord(word, state, io, split, pattern, hereString, conditionalPattern, regexAppend)).map(shellValueText);
@@ -15170,16 +15289,17 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
         }
         if (boundary) addField();
       };
-      const parts = word.parts.map((part) => ({ part, splitText: false }));
+      const parts = word.parts.map((part) => ({ part, splitText: false, io }));
       for (let index = 0; index < parts.length; index++) {
-        const { part, splitText } = parts[index];
+        const { part, splitText, io: partIO } = parts[index];
         const quotedPresence = part.quoted && !(arrayOwned && isQuoteMarker(part));
         if (part.kind === "variable" && ["-", "+", ":-", ":+"].includes(part.operator ?? "") && /^[a-zA-Z_][a-zA-Z_0-9]*$/u.test(part.name)) {
           const value2 = this.variable(state, part.name);
           const missing = value2 === void 0 || part.operator.startsWith(":") && value2 === "";
           if (part.operator.endsWith("+") ? !missing : missing) {
+            const operandIO = this.parameterOperandIO(part.alternate, state, partIO);
             scratch?.reserve(part.alternate.parts.length * 32, 0);
-            const alternate = part.alternate.parts.map((entry) => ({ part: copyArraySelector(entry, { ...entry, quoted: entry.quoted || part.quoted }), splitText: true }));
+            const alternate = part.alternate.parts.map((entry) => ({ part: copyArraySelector(entry, { ...entry, quoted: entry.quoted || part.quoted }), splitText: true, io: operandIO }));
             if (!alternate.length && part.quoted) append("", false, true);
             parts.splice(index + 1, 0, ...alternate);
             continue;
@@ -15205,7 +15325,7 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
           }
           if (state.positional.length === 0 && word.parts.every((entry) => entry.kind === "text" && entry.value === "" || entry === part)) fields[0].present = false;
         } else {
-          const value2 = part.kind === "text" ? part.byteValue ?? part.value : await this.valuePart(part, state, io, hereString);
+          const value2 = part.kind === "text" ? part.byteValue ?? part.value : await this.valuePart(part, state, partIO, hereString);
           if (part.quoted || !split || state.variables.IFS === "") append(value2, !part.quoted, quotedPresence || !split || shellValueByteLength(value2) > 0);
           else await appendSplit(value2);
         }