@poe-platform/safe-bash 0.1.524 → 0.1.526

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

@@ -38650,10 +38650,10 @@ var Parser4 = class {
       const body = this.nonemptyScript(/* @__PURE__ */ new Set(["done"]));
       this.expect("done", true);
       command7 = { kind, condition, body, redirects: [] };
-    } else if (this.is("for")) {
-      this.advance();
+    } else if (this.is("for") || this.is("select")) {
+      const kind = this.advance().value;
       const name2 = this.advance().value;
-      if (!/^[a-zA-Z_][a-zA-Z_0-9]*$/u.test(name2)) this.error("Invalid for variable");
+      if (!/^[a-zA-Z_][a-zA-Z_0-9]*$/u.test(name2)) this.error(`Invalid ${kind} variable`);
       this.newlines();
       let words;
       if (this.is("in")) {
@@ -38662,12 +38662,12 @@ var Parser4 = class {
         while (this.current.kind === "word") words.push(this.advance().word);
       }
       if (this.is(";") || this.is("\n")) this.advance();
-      else if (words) this.error("Expected for separator", true);
+      else if (words) this.error(`Expected ${kind} separator`, true);
       this.newlines();
       this.expect("do", true);
       const body = this.nonemptyScript(/* @__PURE__ */ new Set(["done"]));
       this.expect("done", true);
-      command7 = { kind: "for", name: name2, ...words ? { words } : {}, body, redirects: [] };
+      command7 = { kind, name: name2, ...words ? { words } : {}, body, redirects: [] };
     } else if (this.is("function")) {
       this.advance();
       if (this.current.kind !== "word" || !/^[a-zA-Z_][a-zA-Z_0-9]*$/u.test(this.current.value)) this.error("Invalid function name");
@@ -38685,7 +38685,7 @@ var Parser4 = class {
       this.expect("(");
       this.expect(")");
       this.newlines();
-      if (!["{", "(", "if", "case", "while", "until", "for", "[["].includes(this.current.value)) this.error("Expected function body");
+      if (!["{", "(", "if", "case", "while", "until", "for", "select", "[["].includes(this.current.value)) this.error("Expected function body");
       command7 = { kind: "function", name: name2, body: this.command(), redirects: [] };
     } else {
       if (["!", "then", "else", "elif", "fi", "do", "done", "}", "case", "esac", "select", "function", "[[", "]]"].includes(this.current.value)) this.error(`Unexpected or unsupported keyword ${this.current.value}`);
@@ -39540,6 +39540,94 @@ function evaluatePositionalArithmetic(program, options3, evaluate) {
   }
 }
 
+// packages/safe-bash/src/shell/select-menu.ts
+init_platform();
+async function selectMenu(values, columns, byteLocale2, sink, work, allocation) {
+  allocation.reserve(64 + values.length * 32, 0);
+  const items = [];
+  let maximum = 0;
+  for (const value2 of values) {
+    const bytes3 = shellValueBytes(value2, allocation);
+    allocation.reserve(bytes3.length * 2 + 64, 0);
+    const decoder2 = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+    let text3 = "";
+    for (let offset = 0; offset < bytes3.length; offset += 1024) {
+      const end = Math.min(offset + 1024, bytes3.length);
+      const pending = stringCheckpoint(work, end - offset);
+      if (pending) await pending;
+      if (text3 !== void 0) try {
+        text3 += decoder2.decode(bytes3.subarray(offset, end), { stream: end < bytes3.length });
+      } catch (error) {
+        if (!(error instanceof TypeError) || "code" in error && error.code !== "ERR_ENCODING_INVALID_ENCODED_DATA") throw error;
+        text3 = void 0;
+      }
+    }
+    let width = 0;
+    if (text3 !== void 0) for (const character of text3) {
+      const pending = stringCheckpoint(work);
+      if (pending) await pending;
+      const point = character.codePointAt(0);
+      if (byteLocale2 && point >= 128) {
+        width = 0;
+        break;
+      }
+      if (point < 32 || point === 127) {
+        width = bytes3.length;
+        break;
+      }
+      if (/[\p{Mn}\p{Me}\p{Cf}]/u.test(character)) continue;
+      width += point >= 4352 && (point <= 4447 || point === 9001 || point === 9002 || point >= 11904 && point <= 42191 && point !== 12351 || point >= 44032 && point <= 55203 || point >= 63744 && point <= 64255 || point >= 65040 && point <= 65049 || point >= 65072 && point <= 65135 || point >= 65280 && point <= 65376 || point >= 65504 && point <= 65510 || point >= 127744 && point <= 129791 || point >= 131072 && point <= 262141) ? 2 : 1;
+    }
+    maximum = Math.max(maximum, byteLocale2 ? bytes3.length : width);
+    items.push({ bytes: bytes3, width });
+  }
+  let screen = 0;
+  if (columns) {
+    let started = false;
+    for (const character of columns) {
+      const pending = stringCheckpoint(work);
+      if (pending) await pending;
+      if (!started && " 	\r\n\v\f".includes(character)) continue;
+      if (!started && character === "+") {
+        started = true;
+        continue;
+      }
+      if (character < "0" || character > "9") break;
+      started = true;
+      screen = Math.min(2147483647, screen * 10 + Number(character));
+    }
+  }
+  screen ||= 80;
+  const digits = String(values.length).length;
+  const cell2 = maximum + digits + 4;
+  let rows2 = Math.ceil(values.length / Math.max(1, Math.floor(screen / cell2)));
+  if (rows2 === 1) rows2 = values.length;
+  for (let row = 0; row < rows2; row++) {
+    let position = 0;
+    for (let index = row; index < items.length; index += rows2) {
+      const pending = stringCheckpoint(work);
+      if (pending) await pending;
+      const item = items[index];
+      const indexWidth = position ? digits : String(rows2).length;
+      await writeText(sink, `${String(index + 1).padStart(indexWidth)}) `);
+      await sink.write(item.bytes);
+      if (index + rows2 < items.length) {
+        let from = position + indexWidth + 2 + item.width;
+        const to = position + cell2;
+        while (from < to) {
+          const pending2 = stringCheckpoint(work);
+          if (pending2) await pending2;
+          const tab = Math.floor(to / 8) > Math.floor(from / 8);
+          await writeText(sink, tab ? "	" : " ");
+          from += tab ? 8 - from % 8 : 1;
+        }
+        position += cell2;
+      }
+    }
+    await writeText(sink, "\n");
+  }
+}
+
 // packages/safe-bash/src/shell/locale.ts
 init_platform();
 function byteLocale(variables) {
@@ -39598,7 +39686,8 @@ ${nested}${scriptText(command7.body, nested)};
 ${indent}done`;
       break;
     case "for":
-      text3 = `for ${command7.name}${command7.words ? ` in ${command7.words.map(spelling).join(" ")}` : ""};
+    case "select":
+      text3 = `${command7.kind} ${command7.name}${command7.words ? ` in ${command7.words.map(spelling).join(" ")}` : ""};
 do
 ${nested}${scriptText(command7.body, nested)};
 ${indent}done`;
@@ -43857,6 +43946,64 @@ var Runtime = class _Runtime {
               status3 = result2.status;
               if (result2.stop) break;
             }
+          } else if (command7.kind === "select") {
+            const values = command7.words ? await this.valueWords(command7.words, state, io) : this.positionalValues(state);
+            if (!values.length) return 0;
+            const input3 = io.stdin instanceof ShellInput ? io.stdin : new ShellInput(io.stdin, this.budget, this.signal);
+            const work = { remaining: this.budget.limits.maxExpansionBytes * 8, signal: this.signal, exhausted: () => this.budget.fail("maxExpansionBytes") };
+            let showMenu = true;
+            while (true) {
+              this.budget.loop();
+              if (showMenu) await selectMenu(values, state.variables.COLUMNS, byteLocale(state.variables), io.stderr, work, allocation);
+              const prompt = stateMonitor(state)?.values.get("PS3", state.variables.PS3 ?? "#? ") ?? state.variables.PS3 ?? "#? ";
+              await io.stderr.write(shellValueBytes(prompt, allocation));
+              const line = await input3.selectLine(allocation);
+              if (state.readonlyVariables?.has("REPLY")) {
+                await this.diagnostic(io, "REPLY: readonly variable");
+                await writeText(io.stdout, "\n");
+                return 1;
+              }
+              this.writeVariable(state, "REPLY", line.value);
+              if (!line.terminated) {
+                await writeText(io.stdout, "\n");
+                return 1;
+              }
+              const bytes3 = shellValueBytes(line.value, allocation);
+              if (!bytes3.length) {
+                showMenu = true;
+                continue;
+              }
+              let choice = 0;
+              let phase = "start";
+              let valid = true;
+              let negative = false;
+              let digits = false;
+              for (const byte of bytes3) {
+                const pending = stringCheckpoint(work);
+                if (pending) await pending;
+                if (byte === 32 || byte >= 9 && byte <= 13) {
+                  if (phase === "digits") phase = "tail";
+                  continue;
+                }
+                if (phase === "start" && (byte === 43 || byte === 45)) {
+                  negative = byte === 45;
+                  phase = "digits";
+                  continue;
+                }
+                if (phase === "tail" || byte < 48 || byte > 57) {
+                  valid = false;
+                  continue;
+                }
+                phase = "digits";
+                digits = true;
+                choice = Math.min(values.length + 1, choice * 10 + byte - 48);
+              }
+              await this.assignVariable(state, command7.name, valid && digits && !negative && choice >= 1 && choice <= values.length ? values[choice - 1] : "");
+              const result2 = await this.loopBody(command7.body, state, io);
+              status3 = result2.status;
+              if (result2.stop) break;
+              showMenu = shellValueByteLength(stateMonitor(state)?.values.get("REPLY", state.variables.REPLY ?? "") ?? state.variables.REPLY ?? "") === 0;
+            }
           } else {
             while (true) {
               this.budget.loop();
@@ -44392,6 +44539,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);
@@ -44440,7 +44588,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;
@@ -45037,6 +45191,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");
@@ -47963,6 +48119,52 @@ var ShellInput = class _ShellInput {
   line(raw, options3) {
     return this.#cursor.consume(this.signal, () => options3 ? this.readBounded(raw, options3) : this.readLine(raw));
   }
+  /** Select uses read's escape rules without projecting raw REPLY bytes to text. */
+  selectLine(allocation) {
+    return this.#cursor.consume(this.signal, async () => {
+      allocation.reserve(64, 0);
+      const parts = [];
+      let escaping = false;
+      let length = 0;
+      let pulls = 0;
+      while (true) {
+        if (++pulls % 128 === 0) await yieldTurn(this.signal);
+        const result2 = await this.#cursor.take(this.signal);
+        if (result2.done) return { value: concatShellValues(parts, allocation), terminated: false };
+        const chunk = result2.value;
+        for (let offset = 0; offset < chunk.length; ) {
+          await yieldTurn(this.signal);
+          const end = Math.min(offset + 1024, chunk.length);
+          allocation.reserve(end - offset + 64, 0);
+          const output2 = new Uint8Array(end - offset);
+          let used = 0;
+          let terminated = false;
+          while (offset < end) {
+            const byte = chunk[offset++];
+            this.#cursor.position++;
+            if (++length > this.budget.limits.maxOutputBytes) this.budget.fail("maxOutputBytes");
+            if (byte === 0) continue;
+            if (escaping) {
+              escaping = false;
+              if (byte !== 10) output2[used++] = byte;
+            } else if (byte === 92) escaping = true;
+            else if (byte === 10) {
+              terminated = true;
+              break;
+            } else output2[used++] = byte;
+          }
+          if (used) {
+            allocation.reserve(32, 0);
+            parts.push(shellValueFromBytes(output2.subarray(0, used), allocation));
+          }
+          if (terminated) {
+            if (offset < chunk.length) this.#cursor.remainder = chunk.subarray(offset);
+            return { value: concatShellValues(parts, allocation), terminated: true };
+          }
+        }
+      }
+    });
+  }
   async readBounded(raw, options3) {
     const text3 = new ReadText();
     let characters = 0;