@poe-platform/safe-bash 0.1.523 → 0.1.525

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

@@ -33508,8 +33508,8 @@ async function entities(text3, budget) {
       const name2 = match[1];
       if (name2[0] !== "#") result2.append(Object.hasOwn(named, name2) ? named[name2] : match[0]);
       else {
-        const hexadecimal = name2[1]?.toLowerCase() === "x";
-        const value2 = Number.parseInt(name2.slice(hexadecimal ? 2 : 1), hexadecimal ? 16 : 10);
+        const hexadecimal2 = name2[1]?.toLowerCase() === "x";
+        const value2 = Number.parseInt(name2.slice(hexadecimal2 ? 2 : 1), hexadecimal2 ? 16 : 10);
         result2.append(value2 === 0 || value2 > 1114111 || value2 >= 55296 && value2 <= 57343 ? "\uFFFD" : String.fromCodePoint(value2));
       }
       offset += match[0].length;
@@ -38126,7 +38126,8 @@ shell: command substitution: line ${line}: \`${sourceLine}'
           } else if (!literal && (inner === "$" || inner === "`")) {
             this.expansion(parts, true);
             const part = parts.at(-1);
-            nameListing ||= part.kind === "variable" && part.prefixNames === "@";
+            const selector = getArraySelector(part);
+            nameListing ||= part.kind === "variable" && (part.prefixNames === "@" || !!part.transform && (part.name === "@" || selector?.kind === "members" && selector.separator === "@"));
           } else if (inner === "\\" && /[$`"\\\n]/u.test(this.source[this.position + 1] ?? "")) {
             const escaped3 = this.source[this.position + 1];
             if (escaped3 !== "\n") text3(escaped3, true, false, this.position, this.position + 2);
@@ -38329,7 +38330,14 @@ shell: command substitution: line ${line}: \`${sourceLine}'
         if (end < 0) this.error("Unterminated indexed-array subscript");
         selector = arraySelector(this.source.slice(start, end), start, this.budget);
         this.position = end + 1;
-        if (this.source[this.position] !== "}") this.error("Unsupported indexed-array operator");
+        if (this.source[this.position] !== "}" && this.source[this.position] !== "@") this.error("Unsupported indexed-array operator");
+      }
+      let transform2;
+      if (this.source[this.position] === "@") {
+        const operation2 = this.source[this.position + 1];
+        if (length || prefixNames || operation2 !== "Q" && operation2 !== "E" || this.source[this.position + 2] !== "}") this.error("Unsupported parameter transform");
+        transform2 = operation2;
+        this.position += 2;
       }
       const operator = /^(?::[-=+?]|##|%%|\/\/|\/[#%]?|[-=+?#%])/u.exec(this.source.slice(this.position))?.[0];
       let alternate;
@@ -38373,7 +38381,7 @@ shell: command substitution: line ${line}: \`${sourceLine}'
         parts.push({ kind: "failed-parameter", source: this.source.slice(parameterStart, this.position), line, quoted: quoted2 });
       } else {
         this.position++;
-        const part = { kind: "variable", name: name2, quoted: quoted2, line, ...prefixNames ? { prefixNames } : {}, ...length ? { length } : {}, ...operator ? { operator, alternate } : {}, ...replacement ? { replacement } : {}, ...substring ? { substring } : {} };
+        const part = { kind: "variable", name: name2, quoted: quoted2, line, ...prefixNames ? { prefixNames } : {}, ...transform2 ? { transform: transform2 } : {}, ...length ? { length } : {}, ...operator ? { operator, alternate } : {}, ...replacement ? { replacement } : {}, ...substring ? { substring } : {} };
         if (selector) setArraySelector(part, selector);
         parts.push(part);
       }
@@ -41609,6 +41617,138 @@ function* pathTargets(name2, path, limits, signal, fail4) {
   }
 }
 
+// packages/safe-bash/src/shell/parameter-transforms.ts
+init_platform();
+function hexadecimal(byte) {
+  return byte >= 48 && byte <= 57 ? byte - 48 : byte >= 65 && byte <= 70 ? byte - 55 : byte >= 97 && byte <= 102 ? byte - 87 : -1;
+}
+function utf8Unit(bytes3, offset) {
+  const first = bytes3[offset];
+  if (first < 128) return { point: first, size: 1 };
+  const size = first >= 194 && first <= 223 ? 2 : first >= 224 && first <= 239 ? 3 : first >= 240 && first <= 244 ? 4 : 0;
+  if (!size || offset + size > bytes3.length) return { point: -1, size: 1 };
+  let point = first & 127 >> size;
+  for (let index = 1; index < size; index++) {
+    const byte = bytes3[offset + index];
+    if (byte < 128 || byte > 191) return { point: -1, size: 1 };
+    point = point * 64 + (byte & 63);
+  }
+  if (point < (size === 2 ? 128 : size === 3 ? 2048 : 65536) || point > 1114111 || point >= 55296 && point <= 57343) return { point: -1, size: 1 };
+  return { point, size };
+}
+var controlEscapes = { 7: 97, 8: 98, 9: 116, 10: 110, 11: 118, 12: 102, 13: 114, 27: 69 };
+var decodedEscapes = { 97: 7, 98: 8, 116: 9, 110: 10, 118: 11, 102: 12, 114: 13, 101: 27, 69: 27, 92: 92, 39: 39, 34: 34, 63: 63 };
+async function transformParameter(value2, operator, options3) {
+  const { work, allocation, maximumBytes } = options3;
+  work.signal.throwIfAborted();
+  if (typeof value2 === "string") {
+    if (value2.length > maximumBytes) work.exhausted();
+    if ((await scanString(value2, work)).bytes > maximumBytes) work.exhausted();
+  } else if (shellValueByteLength(value2) > maximumBytes) work.exhausted();
+  const input3 = shellValueBytes(value2, allocation);
+  let ansi = false;
+  if (operator === "Q") {
+    for (let offset = 0; offset < input3.length; ) {
+      const pending = stringCheckpoint(work);
+      if (pending) await pending;
+      const unit2 = options3.byteLocale ? { point: input3[offset], size: 1 } : utf8Unit(input3, offset);
+      const printable = unit2.point >= 32 && unit2.point < 127 || !options3.byteLocale && unit2.point >= 128 && !/[\p{Cc}\p{Cf}\p{Cn}]/u.test(String.fromCodePoint(unit2.point));
+      if (!printable) ansi = true;
+      offset += unit2.size;
+    }
+  }
+  let output2 = void 0;
+  let size = 0;
+  const emit2 = (byte) => {
+    if (size >= maximumBytes) work.exhausted();
+    if (output2) output2[size] = byte;
+    size++;
+  };
+  const ascii2 = (text3) => {
+    for (let index = 0; index < text3.length; index++) emit2(text3.charCodeAt(index));
+  };
+  const scan = async () => {
+    size = 0;
+    if (operator === "Q") {
+      ascii2(ansi ? "$'" : "'");
+      for (let offset = 0; offset < input3.length; ) {
+        const pending = stringCheckpoint(work);
+        if (pending) await pending;
+        const unit2 = options3.byteLocale ? { point: input3[offset], size: 1 } : utf8Unit(input3, offset);
+        const printable = unit2.point >= 32 && unit2.point < 127 || !options3.byteLocale && unit2.point >= 128 && !/[\p{Cc}\p{Cf}\p{Cn}]/u.test(String.fromCodePoint(unit2.point));
+        if (ansi && !printable) {
+          if (unit2.size === 1 && controlEscapes[input3[offset]] !== void 0) {
+            emit2(92);
+            emit2(controlEscapes[input3[offset]]);
+          } else for (let index = 0; index < unit2.size; index++) ascii2("\\" + input3[offset + index].toString(8).padStart(3, "0"));
+        } else if (unit2.point === 39) ascii2(ansi ? "\\'" : "'\\''");
+        else if (ansi && unit2.point === 92) ascii2("\\\\");
+        else for (let index = 0; index < unit2.size; index++) emit2(input3[offset + index]);
+        offset += unit2.size;
+      }
+      emit2(39);
+      return;
+    }
+    for (let offset = 0; offset < input3.length; ) {
+      const pending = stringCheckpoint(work);
+      if (pending) await pending;
+      let byte = input3[offset++];
+      if (byte === 92 && offset < input3.length) {
+        const escape = input3[offset++];
+        if (decodedEscapes[escape] !== void 0) byte = decodedEscapes[escape];
+        else if (escape >= 48 && escape <= 55) {
+          byte = escape - 48;
+          for (let count2 = 1; count2 < 3 && offset < input3.length && input3[offset] >= 48 && input3[offset] <= 55; count2++) byte = byte * 8 + input3[offset++] - 48;
+          byte &= 255;
+        } else if (escape === 120 || escape === 117 || escape === 85) {
+          const maximum = escape === 120 ? 2 : escape === 117 ? 4 : 8;
+          let point = 0;
+          let count2 = 0;
+          while (count2 < maximum && offset < input3.length && hexadecimal(input3[offset]) >= 0) {
+            point = point * 16 + hexadecimal(input3[offset++]);
+            count2++;
+          }
+          if (!count2) {
+            emit2(92);
+            emit2(escape);
+            continue;
+          }
+          if (escape === 120) byte = point;
+          else {
+            if (!point || point >= 2147483648) return;
+            if (options3.byteLocale && point >= 55296 && point <= 57343) ascii2(`\\u${point.toString(16).toUpperCase().padStart(4, "0")}`);
+            else {
+              const width = point < 128 ? 1 : point < 2048 ? 2 : point < 65536 ? 3 : point < 2097152 ? 4 : point < 67108864 ? 5 : 6;
+              if (width === 1) emit2(point);
+              else {
+                const divisor = 64 ** (width - 1);
+                emit2(256 - 2 ** (8 - width) + Math.floor(point / divisor));
+                for (let shift = width - 2; shift >= 0; shift--) emit2(128 + Math.floor(point / 64 ** shift) % 64);
+              }
+            }
+            continue;
+          }
+        } else if (escape === 99 && offset < input3.length) {
+          const control = input3[offset++];
+          if (control === 92 && input3[offset] === 92) offset++;
+          byte = control === 63 ? 127 : control & 31;
+        } else {
+          emit2(92);
+          byte = escape;
+        }
+      }
+      if (!byte) return;
+      emit2(byte);
+    }
+  };
+  await scan();
+  allocation.reserve(size + 64, 1);
+  output2 = new Uint8Array(size);
+  await scan();
+  work.signal.throwIfAborted();
+  return shellValueFromBytes(output2, allocation);
+}
+
 // packages/safe-bash/src/shell/runtime.ts
 var defaultLimits = {
   maxParseUnits: defaultMaxParseUnits,
@@ -43815,6 +43955,7 @@ var Runtime = class _Runtime {
   async document(document, state, io, line = document.endLine) {
     this.signal.throwIfAborted();
     let value2 = "";
+    let fragments;
     let size = 0;
     let words = 0;
     const warnings = [];
@@ -43824,16 +43965,25 @@ var Runtime = class _Runtime {
         for (const warning of warnings.splice(0)) await writeDiagnostic(io.stderr, `shell: warning: ${warning}
 `);
         if (++words % 128 === 0) await yieldTurn(this.signal);
-        const part = (await this.word(word, state, { ...io, nameExpansionContext: "document" }, false)).join("");
-        size += import_buffer.Buffer.byteLength(part);
+        const part = concatShellValues(await this.valueWord(word, state, { ...io, nameExpansionContext: "document" }, false), io[valueScope]);
+        size += shellValueByteLength(part);
         if (size > this.budget.limits.maxExpansionBytes) this.budget.fail("maxExpansionBytes");
-        value2 += part;
+        if (!fragments && typeof part === "string") value2 += part;
+        else {
+          if (!fragments) {
+            io[valueScope]?.reserve(64 + value2.length * 2, 0);
+            fragments = [value2];
+            value2 = "";
+          }
+          io[valueScope]?.reserve(32 + (typeof part === "string" ? part.length * 2 : 0), 0);
+          fragments.push(part);
+        }
       }
     } finally {
       for (const warning of warnings.splice(0)) await writeDiagnostic(io.stderr, `shell: warning: ${warning}
 `);
     }
-    return value2;
+    return fragments ? concatShellValues(fragments, io[valueScope]) : value2;
   }
   async redirect(redirects, state, io, inputs2, outputs, isolatedInlineInput = false, persistMoves = false, fileShortcut = false, line) {
     this.signal.throwIfAborted();
@@ -43862,6 +44012,7 @@ var Runtime = class _Runtime {
       const stdinIsDefault = descriptor2?.input ? descriptor2.stdinIsDefault : false;
       return {
         [invocationScope]: io[invocationScope],
+        ...io[valueScope] === void 0 ? {} : { [valueScope]: io[valueScope] },
         ...io.execution === void 0 ? {} : { execution: io.execution },
         ...io.diagnosticLine === void 0 ? {} : { diagnosticLine: io.diagnosticLine },
         ...io.diagnosticOffset === void 0 ? {} : { diagnosticOffset: io.diagnosticOffset },
@@ -43882,7 +44033,7 @@ var Runtime = class _Runtime {
           const hereString = redirect.operator === "<<<";
           let value2;
           try {
-            value2 = redirect.document ? await this.document(redirect.document, state, currentIO(), line) : (await this.word(redirect.target, state, currentIO(), false, false, hereString)).join("");
+            value2 = redirect.document ? await this.document(redirect.document, state, currentIO(), line) : concatShellValues(await this.valueWord(redirect.target, state, currentIO(), false, false, hereString), io[valueScope]);
           } catch (error) {
             if (error instanceof NounsetFailure) throw error;
             if (error instanceof ParameterExpansionFailure && !isolatedInlineInput) throw error;
@@ -43891,10 +44042,10 @@ var Runtime = class _Runtime {
             throw error;
           }
           if (hereString) {
-            if (import_buffer.Buffer.byteLength(value2) >= this.budget.limits.maxExpansionBytes) this.budget.fail("maxExpansionBytes");
-            value2 += "\n";
+            if (shellValueByteLength(value2) >= this.budget.limits.maxExpansionBytes) this.budget.fail("maxExpansionBytes");
+            value2 = concatShellValues([value2, "\n"], io[valueScope]);
           }
-          const input3 = new ShellInput(toByteSource(value2), this.budget, this.signal);
+          const input3 = new ShellInput(toByteSource(typeof value2 === "string" ? value2 : shellValueBytes(value2, io[valueScope])), this.budget, this.signal);
           inputs2.add(input3);
           descriptors.set(redirect.descriptor, { input: input3, stdinIsDefault: false });
           continue;
@@ -44241,6 +44392,7 @@ var Runtime = class _Runtime {
   }
   async dispatchScoped(name2, values, state, io, assignments2, bypassFunctions) {
     const { [invocationScope]: scope, ...publicIO } = io;
+    Reflect.deleteProperty(publicIO, valueScope);
     const allocation = this.budget.values.scope();
     scope.register(() => allocation.close());
     const argumentValues = this.admitArguments(values, allocation);
@@ -44289,7 +44441,13 @@ var Runtime = class _Runtime {
       scope.assertOpen();
       const forwardedValues = getCommandArguments(forwarded);
       const admitted = forwardedValues === argumentValues ? argumentValues : this.admitArguments(forwardedValues.values, allocation);
-      const context3 = { ...forwarded, args: admitted.args, argumentValues: admitted, [invocationScope]: scope };
+      const context3 = {
+        ...forwarded,
+        args: admitted.args,
+        argumentValues: admitted,
+        [invocationScope]: scope,
+        ...io[valueScope] === void 0 ? {} : { [valueScope]: io[valueScope] }
+      };
       const previous = /* @__PURE__ */ new Map();
       const cwd = state.cwd;
       const directoryStackCwdPublication = state.directoryStackCwdPublication;
@@ -44886,6 +45044,8 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
           return invocation2;
         }
       };
+      Reflect.deleteProperty(context2, invocationScope);
+      Reflect.deleteProperty(context2, valueScope);
       bindCommandIO(context2);
       bindFileOutputBudget(context2, (sink) => this.budget.sink(sink, runtime.signal));
       if (argumentValues.values.every((value2) => typeof value2 === "string")) Reflect.deleteProperty(context2, "argumentValues");
@@ -46447,6 +46607,31 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
     }
   }
   async valuePart(part, state, io, hereString = false) {
+    if (part.kind === "variable" && part.transform) {
+      const selector2 = getArraySelector(part);
+      if (selector2?.kind === "members" || part.name === "@" || part.name === "*") {
+        const members = selector2 ? await this.arrayMembers(part.name, state) : this.positionalValues(state);
+        const ifs = state.variables.IFS ?? " ";
+        const separator = ifs.length ? String.fromCodePoint(ifs.codePointAt(0)) : "";
+        const fragments = [];
+        let bytes3 = 0;
+        for (const member2 of members) {
+          const value3 = await this.transformValue(member2, part.transform, state, io);
+          bytes3 += shellValueByteLength(value3) + (fragments.length ? import_buffer.Buffer.byteLength(separator) : 0);
+          if (bytes3 > this.budget.limits.maxExpansionBytes) this.budget.fail("maxExpansionBytes");
+          io[valueScope]?.reserve(32, 0);
+          if (fragments.length) fragments.push(separator);
+          fragments.push(value3);
+        }
+        return concatShellValues(fragments, io[valueScope]);
+      }
+      const base = { ...part };
+      delete base.transform;
+      copyArraySelector(part, base);
+      const existing2 = selector2?.kind === "element" ? arrayStore(state)?.get(part.name)?.get(numericIndex(selector2.index) ?? -1) ?? (numericIndex(selector2.index) === 0 ? this.variable(state, part.name) : void 0) : /^[a-zA-Z_][a-zA-Z_0-9]*$/u.test(part.name) ? this.variable(state, part.name) : /^[1-9][0-9]*$/u.test(part.name) ? state.positional[Number(part.name) - 1] : "";
+      const value2 = await this.valuePart(base, state, io, hereString);
+      return existing2 === void 0 ? "" : this.transformValue(value2, part.transform, state, io);
+    }
     if (part.kind === "variable" && part.prefixNames) {
       const ifs = state.variables.IFS ?? " ";
       const separator = io.nameExpansionContext === "document" || io.nameExpansionContext === "conditional" && part.prefixNames === "@" ? " " : ifs.length ? String.fromCodePoint(ifs.codePointAt(0)) : "";
@@ -46483,6 +46668,19 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
     if (state.depth + parameterDepth > 64) throw new ShellSyntaxError("Syntax nesting exceeds 64", word.offset);
     return { ...io, parameterDepth };
   }
+  async transformValue(value2, operator, state, io) {
+    const allocation = io[valueScope] ?? this.budget.values.scope();
+    try {
+      return await transformParameter(value2, operator, {
+        maximumBytes: this.budget.limits.maxExpansionBytes,
+        byteLocale: byteLocale(state.variables),
+        allocation,
+        work: { remaining: Math.min(Number.MAX_SAFE_INTEGER, this.budget.limits.maxExpansionBytes * 8 + 1024), signal: this.signal, exhausted: () => this.budget.fail("maxExpansionBytes") }
+      });
+    } finally {
+      if (!io[valueScope]) allocation.close();
+    }
+  }
   async partValue(part, state, io, hereString) {
     this.signal.throwIfAborted();
     if (part.kind === "compound-substitution-eof") {
@@ -46852,7 +47050,7 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
       return fields3;
     }
     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 === "@");
+    const prefixOwned = word.parts.some((part) => part.kind === "variable" && (part.prefixNames === "@" || part.transform && part.name === "@"));
     const owner = arrayOwned ? requireArrays(state).owner : void 0;
     const holding = owner?.hold();
     const scratch = !owner && split4 && state.variables.IFS !== "" && word.parts.some((part) => !part.quoted && part.kind !== "text") ? this.budget.values.scope() : void 0;
@@ -46982,19 +47180,25 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
             emptyNameGroups ??= /* @__PURE__ */ new Set();
             emptyNameGroups.add(quoteGroup);
           }
-        } else if (part.kind === "variable" && selector?.kind === "members" && !part.length && split4 && (!part.quoted || selector.separator === "@")) {
-          const members = await this.arrayMembers(part.name, state);
+        } else if (part.kind === "variable" && split4 && (selector?.kind === "members" && !part.length && (!part.quoted || selector.separator === "@") || part.transform && part.name === "@")) {
+          const members = selector?.kind === "members" ? await this.arrayMembers(part.name, state) : this.positionalValues(state);
           for (let position = 0; position < members.length; position++) {
             if (position > 0) addField();
-            const value2 = members[position];
-            if (part.quoted || state.variables.IFS === "") append(value2, !part.quoted, part.quoted || value2.length > 0);
+            const original = members[position];
+            const value2 = part.transform ? await this.transformValue(original, part.transform, state, partIO) : original;
+            if (part.quoted || state.variables.IFS === "") append(value2, !part.quoted, part.quoted || shellValueByteLength(value2) > 0);
             else await appendSplit(value2);
           }
+          if (part.transform && members.length === 0 && quoteGroup) {
+            io[valueScope]?.reserve(32, 0);
+            emptyNameGroups ??= /* @__PURE__ */ new Set();
+            emptyNameGroups.add(quoteGroup);
+          }
         } else if (part.kind === "text" && !splitText) {
           let value2 = invokedValues.get(part) ?? part.byteValue ?? part.value;
           if (typeof value2 === "string" && index === 0 && !part.quoted && /^~(?:\/|$)/u.test(value2)) value2 = (state.variables.HOME ?? "~") + value2.slice(1);
           append(value2, !part.quoted, quotedPresence || shellValueByteLength(value2) > 0);
-        } else if (part.kind === "variable" && part.name === "@" && part.quoted && !part.operator && split4) {
+        } else if (part.kind === "variable" && part.name === "@" && part.quoted && !part.operator && !part.transform && split4) {
           for (let position = 0; position < state.positional.length; position++) {
             if (position > 0) addField();
             append(stateMonitor(state)?.positionals.get(String(position), state.positional[position]) ?? state.positional[position], false, true);
@@ -49994,15 +50198,15 @@ function* entities2(text3) {
     const predefined = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
     if (Object.hasOwn(predefined, entity)) result2 += predefined[entity];
     else {
-      const hexadecimal = entity.startsWith("#x");
-      const digits = entity.slice(hexadecimal ? 2 : 1);
+      const hexadecimal2 = entity.startsWith("#x");
+      const digits = entity.slice(hexadecimal2 ? 2 : 1);
       if (!entity.startsWith("#") || !digits.length) invalid("undeclared entity");
       let point = 0;
       for (let index = 0; index < digits.length; index++) {
         const code = digits.charCodeAt(index);
-        const digit3 = code >= 48 && code <= 57 ? code - 48 : hexadecimal && code >= 65 && code <= 70 ? code - 55 : hexadecimal && code >= 97 && code <= 102 ? code - 87 : -1;
+        const digit3 = code >= 48 && code <= 57 ? code - 48 : hexadecimal2 && code >= 65 && code <= 70 ? code - 55 : hexadecimal2 && code >= 97 && code <= 102 ? code - 87 : -1;
         if (digit3 < 0) invalid("undeclared entity");
-        point = point * (hexadecimal ? 16 : 10) + digit3;
+        point = point * (hexadecimal2 ? 16 : 10) + digit3;
         if (point > 1114111) invalid("invalid character reference");
         if ((index + 1) % 512 === 0) yield 512;
       }