@poe-platform/safe-bash 0.1.799 → 0.1.801

package/dist/safe-bash-command-bc/index.js

@@ -4,6 +4,7 @@ import {
 
 // packages/safe-bash-command-bc/src/index.ts
 init_buffer();
+import { Decimal } from "decimal.js";
 import {
   commandRuntimeIdentity,
   readBytes,
@@ -56,7 +57,10 @@ function settings(options = {}) {
     maxInputBytes: options.limits?.maxInputBytes ?? options.maxInputBytes ?? Infinity,
     maxOutputBytes: options.limits?.maxOutputBytes ?? options.maxOutputBytes ?? Infinity,
     maxSteps: options.limits?.maxSteps ?? options.maxSteps ?? Infinity,
-    maxScale: options.limits?.maxScale ?? options.maxScale ?? Infinity
+    maxScale: options.limits?.maxScale ?? options.maxScale ?? Infinity,
+    maxExponent: options.limits?.maxExponent ?? options.maxExponent ?? Infinity,
+    maxRecursionDepth: options.limits?.maxRecursionDepth ?? options.maxRecursionDepth ?? Infinity,
+    maxObase: options.limits?.maxObase ?? options.maxObase ?? Infinity
   };
   for (const [name, value] of Object.entries(limits)) {
     if (value !== Infinity && (!Number.isSafeInteger(value) || value < 1)) throw new RangeError(`Invalid bc limit: ${name}`);
@@ -115,26 +119,21 @@ function modDec(a, b, currentScale) {
 function truncToInt(d) {
   return d.scale > 0 ? d.coeff / pow10(d.scale) : d.coeff;
 }
-function powDec(base, exp, currentScale) {
+function powDec(base, exp, currentScale, maxExponent) {
   let n = truncToInt(exp);
   if (n === 0n) return ONE;
   const neg = n < 0n;
   if (neg) n = -n;
-  let result = ONE;
-  let cur = base;
-  const workScale = neg ? currentScale : Math.min(base.scale * Number(n), Math.max(currentScale, base.scale));
-  let e = n;
-  while (e > 0n) {
-    if ((e & 1n) === 1n) {
-      result = mulDec(result, cur, workScale);
-    }
-    e >>= 1n;
-    if (e > 0n) cur = mulDec(cur, cur, workScale);
-  }
+  if (maxExponent !== Infinity && n > BigInt(maxExponent)) throw new Error(`exponent exceeds maximum limit (${maxExponent})`);
+  const coeff = base.coeff ** n;
+  const fullScale = BigInt(base.scale) * n;
   if (neg) {
-    return divDec(ONE, result, currentScale);
+    if (coeff === 0n) throw new Error("Runtime error (func=(main), adr=0): Divide by zero");
+    return { coeff: 10n ** (BigInt(currentScale) + fullScale) / coeff, scale: currentScale };
   }
-  return result;
+  const scaleLimit = BigInt(Math.max(currentScale, base.scale));
+  const resultScale = fullScale < scaleLimit ? fullScale : scaleLimit;
+  return { coeff: coeff / 10n ** (fullScale - resultScale), scale: Number(resultScale) };
 }
 function cmpDec(a, b) {
   const { aCoeff, bCoeff } = alignDecimals(a, b);
@@ -179,10 +178,7 @@ function parseLiteralInBase(raw, ibase) {
     if (code >= 65 && code <= 70) return BigInt(code - 55);
     return 0n;
   };
-  if (ibase === 10) {
-    const combined = intPart + fracPart || "0";
-    return { coeff: BigInt(combined), scale };
-  }
+  if (raw.length === 1 && dot < 0) return { coeff: digitVal(raw), scale: 0 };
   let intVal = 0n;
   for (const ch of intPart) {
     const d = digitVal(ch);
@@ -203,7 +199,7 @@ function formatDecimalInBase(val, obase) {
   const neg = val.coeff < 0n;
   const absCoeff = neg ? -val.coeff : val.coeff;
   if (absCoeff === 0n) return "0";
-  if (obase === 10) {
+  if (obase === 10n) {
     if (val.scale <= 0) {
       return (neg && absCoeff !== 0n ? "-" : "") + absCoeff.toString(10);
     }
@@ -213,67 +209,84 @@ function formatDecimalInBase(val, obase) {
     const prefix = intStr === "0" ? "" : intStr;
     return (neg && absCoeff !== 0n ? "-" : "") + (prefix || (fracStr.length > 0 ? "" : "0")) + "." + fracStr;
   }
-  const baseBig = BigInt(obase);
   const scaleFactor = pow10(val.scale);
   let intPart = absCoeff / scaleFactor;
   let rem = absCoeff % scaleFactor;
   const digits = "0123456789ABCDEF";
+  const digitWidth = (obase - 1n).toString(10).length;
   let intOut = "";
   if (intPart === 0n) intOut = "0";
   else {
     while (intPart > 0n) {
-      const d = Number(intPart % baseBig);
-      intOut = (obase <= 16 ? digits[d] : ` ${d.toString(10).padStart(2, "0")}`) + intOut;
-      intPart /= baseBig;
+      const d = intPart % obase;
+      intOut = (obase <= 16n ? digits[Number(d)] : ` ${d.toString(10).padStart(digitWidth, "0")}`) + intOut;
+      intPart /= obase;
     }
   }
   if (val.scale <= 0) {
-    return (neg && absCoeff !== 0n ? "-" : "") + intOut.trimStart();
+    return (neg && absCoeff !== 0n ? "-" : "") + intOut;
   }
   let fracOut = "";
-  for (let i = 0; i < val.scale; i++) {
-    rem *= baseBig;
-    const d = Number(rem / scaleFactor);
+  for (let place = 1n; place < scaleFactor; place *= obase) {
+    rem *= obase;
+    const d = rem / scaleFactor;
     rem %= scaleFactor;
-    fracOut += obase <= 16 ? digits[d] : ` ${d.toString(10).padStart(2, "0")}`;
+    fracOut += obase <= 16n ? digits[Number(d)] : `${fracOut ? " " : ""}${d.toString(10).padStart(digitWidth, "0")}`;
   }
   return (neg && absCoeff !== 0n ? "-" : "") + (intOut === "0" ? "" : intOut) + "." + fracOut;
 }
-function besselJ(nInt, x) {
-  const n = Math.trunc(nInt);
-  if (x === 0) return n === 0 ? 1 : 0;
-  const m = Math.abs(n);
-  const halfX = x / 2;
-  let term = 1;
-  for (let i = 1; i <= m; i++) term *= halfX / i;
-  let sum = term;
-  const minusQuarterX2 = -(halfX * halfX);
-  for (let k = 1; k <= 80; k++) {
-    term *= minusQuarterX2 / (k * (m + k));
-    sum += term;
-    if (Math.abs(term) < 1e-18 * Math.abs(sum)) break;
+async function mathValue(name, args, scale, tick) {
+  if (!["s", "c", "a", "l", "e", "j"].includes(name)) return void 0;
+  const decimal = (value) => `${value.coeff}e-${value.scale}`;
+  const raw = args[name === "j" ? 1 : 0] ?? ZERO;
+  const magnitude = new Decimal(decimal(raw)).abs();
+  const extra = name === "e" || name === "j" ? magnitude.ceil().toNumber() : Math.max(0, magnitude.e + 1);
+  const D = Decimal.clone({ precision: scale + extra + 32, rounding: Decimal.ROUND_DOWN });
+  const x = new D(decimal(raw));
+  let result;
+  switch (name) {
+    case "s":
+      result = x.sin();
+      break;
+    case "c":
+      result = x.cos();
+      break;
+    case "a":
+      result = x.atan();
+      break;
+    case "l":
+      if (x.lte(0)) throw new Error("Runtime error: l(x) domain error");
+      result = x.ln();
+      break;
+    case "e":
+      result = x.exp();
+      break;
+    default: {
+      const n = truncToInt(args[0] ?? ZERO);
+      const order = n < 0n ? -n : n;
+      const half = x.div(2);
+      let term = new D(1);
+      for (let i = 1n; i <= order; i++) {
+        const pending = tick();
+        if (pending) await pending;
+        term = term.mul(half).div(i.toString());
+      }
+      result = term;
+      const factor = half.mul(half).neg();
+      const epsilon = new D(10).pow(-scale - 16);
+      for (let k = 1n; !term.isZero(); k++) {
+        const pending = tick();
+        if (pending) await pending;
+        term = term.mul(factor).div((k * (order + k)).toString());
+        result = result.add(term);
+        if (term.abs().lt(epsilon) && new D((k * (order + k)).toString()).gt(factor.abs())) break;
+      }
+      if (n < 0n && order % 2n === 1n) result = result.neg();
+    }
   }
-  if (n < 0 && (m & 1) === 1) sum = -sum;
-  return sum;
-}
-function fromNumber(num, scale) {
-  if (!Number.isFinite(num)) throw new Error("math domain/range error");
-  const clampedScale = Math.min(scale, 30);
-  const fixed = num.toFixed(Math.min(clampedScale + 4, 20));
-  const dot = fixed.indexOf(".");
-  const neg = fixed.startsWith("-");
-  const clean = neg ? fixed.slice(1) : fixed;
-  const cleanDot = clean.indexOf(".");
-  const intPart = cleanDot >= 0 ? clean.slice(0, cleanDot) : clean;
-  let fracPart = cleanDot >= 0 ? clean.slice(cleanDot + 1) : "";
-  if (fracPart.length < scale) fracPart = fracPart.padEnd(scale, "0");
-  else if (fracPart.length > scale) fracPart = fracPart.slice(0, scale);
-  void dot;
-  const coeff = BigInt(intPart + fracPart || "0");
-  return { coeff: neg ? -coeff : coeff, scale };
-}
-function toNumber(val) {
-  return Number(formatDecimalInBase(val, 10));
+  if (!result.isFinite()) throw new Error("math domain/range error");
+  const fixed = result.toFixed(scale, Decimal.ROUND_DOWN);
+  return { coeff: BigInt(fixed.split(".").join("")), scale };
 }
 function tokenizeBc(source) {
   const clean = source.replace(/\\\r?\n/gu, "");
@@ -458,10 +471,9 @@ var BcParser = class {
       while (true) {
         const p = this.next();
         if (p?.type !== "id") throw new Error("expected variable name in auto");
-        if (this.matchPunct("[")) {
-          this.matchPunct("]");
-        }
-        names.push(p.name ?? "");
+        const array = this.matchPunct("[");
+        if (array && !this.matchPunct("]")) throw new Error("expected ']' in auto");
+        names.push({ name: p.name ?? "", array });
         if (!this.matchPunct(",")) break;
       }
       return { kind: "auto", names };
@@ -619,7 +631,7 @@ var BcParser = class {
     if (t.type === "punct" && (t.value ?? "") === "(") {
       const expr = this.parseExpr();
       if (!this.matchPunct(")")) throw new Error("expected ')'");
-      return expr;
+      return expr.kind === "assign" ? { ...expr, parenthesized: true } : expr;
     }
     if (t.type === "id") {
       if (this.matchPunct("(")) {
@@ -661,6 +673,7 @@ function createBcCommand(options = {}) {
     description: "Arbitrary-precision calculator language",
     runtimeIdentity: commandRuntimeIdentity,
     async execute(context) {
+      context.signal.throwIfAborted();
       try {
         let mathlib = false;
         const files = [];
@@ -715,6 +728,7 @@ function createBcCommand(options = {}) {
               sources.push(decoder.decode(await collectSourceBytes(context.stdin, context.signal, maxInputBytes)));
             } else {
               const raw = await context.fs.readFile(pathPosix.resolve(context.cwd, file));
+              context.signal.throwIfAborted();
               if (raw.byteLength > maxInputBytes) throw new Error(`bc program exceeds maximum input size (${maxInputBytes} bytes)`);
               sources.push(decoder.decode(raw));
             }
@@ -727,7 +741,7 @@ function createBcCommand(options = {}) {
         const stmts = new BcParser(tokenizeBc(fullProgram)).parseProgram();
         let scale = mathlib ? 20 : 0;
         let ibase = 10;
-        let obase = 10;
+        let obase = 10n;
         let last = ZERO;
         const globals = /* @__PURE__ */ new Map();
         const arrays = /* @__PURE__ */ new Map();
@@ -735,25 +749,48 @@ function createBcCommand(options = {}) {
         const callStack = [];
         let steps = 0;
         let outBuffer = "";
+        let outputBytes = 0;
+        const appendOutput = (text) => {
+          if (limits.maxOutputBytes !== Infinity) {
+            outputBytes += encoder.encode(text).byteLength;
+            if (outputBytes > limits.maxOutputBytes) {
+              throw new Error(`output exceeds maximum size (${limits.maxOutputBytes} bytes)`);
+            }
+          }
+          outBuffer += text;
+        };
         const tick = () => {
+          context.signal.throwIfAborted();
           if (++steps > maxSteps) throw new Error(`bc execution exceeded maximum step limit (${maxSteps})`);
           if ((steps & 4095) === 0) {
             return yieldTurn(context.signal);
           }
           return void 0;
         };
+        const getArray = (name) => {
+          for (let i = callStack.length - 1; i >= 0; i--) {
+            const local = callStack[i].arrays.get(name);
+            if (local) return local;
+          }
+          let array = arrays.get(name);
+          if (!array) {
+            array = /* @__PURE__ */ new Map();
+            arrays.set(name, array);
+          }
+          return array;
+        };
         const getVar = async (name, indexExpr) => {
           if (indexExpr) {
             const idxVal = await evalExpr(indexExpr);
             const key = truncToInt(idxVal).toString(10);
-            return arrays.get(name)?.get(key) ?? ZERO;
+            return getArray(name).get(key) ?? ZERO;
           }
           if (name === "scale") return { coeff: BigInt(scale), scale: 0 };
           if (name === "ibase") return { coeff: BigInt(ibase), scale: 0 };
-          if (name === "obase") return { coeff: BigInt(obase), scale: 0 };
+          if (name === "obase") return { coeff: obase, scale: 0 };
           if (name === "last") return last;
           for (let i = callStack.length - 1; i >= 0; i--) {
-            const frame = callStack[i];
+            const frame = callStack[i].scalars;
             if (frame.has(name)) return frame.get(name);
           }
           return globals.get(name) ?? ZERO;
@@ -762,12 +799,7 @@ function createBcCommand(options = {}) {
           if (indexExpr) {
             const idxVal = await evalExpr(indexExpr);
             const key = truncToInt(idxVal).toString(10);
-            let map = arrays.get(name);
-            if (!map) {
-              map = /* @__PURE__ */ new Map();
-              arrays.set(name, map);
-            }
-            map.set(key, val);
+            getArray(name).set(key, val);
             return val;
           }
           if (name === "scale") {
@@ -783,61 +815,19 @@ function createBcCommand(options = {}) {
             return { coeff: BigInt(ibase), scale: 0 };
           }
           if (name === "obase") {
-            const b = Number(truncToInt(val));
-            if (b < 2 || b > 1e3) throw new Error(`obase (${b}) out of bounds`);
-            obase = b;
-            return { coeff: BigInt(obase), scale: 0 };
-          }
-          if (name === "last") {
-            last = val;
-            return val;
-          }
-          for (let i = callStack.length - 1; i >= 0; i--) {
-            const frame = callStack[i];
-            if (frame.has(name)) {
-              frame.set(name, val);
-              return val;
+            const b = truncToInt(val);
+            if (b < 2n || limits.maxObase !== Infinity && b > BigInt(limits.maxObase)) {
+              throw new Error(`obase (${b}) out of bounds [2, ${limits.maxObase}]`);
             }
-          }
-          globals.set(name, val);
-          return val;
-        };
-        const getVarScalarSync = (name) => {
-          if (name === "scale") return { coeff: BigInt(scale), scale: 0 };
-          if (name === "ibase") return { coeff: BigInt(ibase), scale: 0 };
-          if (name === "obase") return { coeff: BigInt(obase), scale: 0 };
-          if (name === "last") return last;
-          for (let i = callStack.length - 1; i >= 0; i--) {
-            const frame = callStack[i];
-            if (frame.has(name)) return frame.get(name);
-          }
-          return globals.get(name) ?? ZERO;
-        };
-        const setVarScalarSync = (name, val) => {
-          if (name === "scale") {
-            const s = Number(truncToInt(val));
-            if (s < 0 || s > maxScale) throw new Error(`scale (${s}) out of bounds [0, ${maxScale}]`);
-            scale = s;
-            return { coeff: BigInt(scale), scale: 0 };
-          }
-          if (name === "ibase") {
-            const b = Number(truncToInt(val));
-            if (b < 2 || b > 16) throw new Error(`ibase (${b}) must be between 2 and 16`);
-            ibase = b;
-            return { coeff: BigInt(ibase), scale: 0 };
-          }
-          if (name === "obase") {
-            const b = Number(truncToInt(val));
-            if (b < 2 || b > 1e3) throw new Error(`obase (${b}) out of bounds`);
             obase = b;
-            return { coeff: BigInt(obase), scale: 0 };
+            return { coeff: obase, scale: 0 };
           }
           if (name === "last") {
             last = val;
             return val;
           }
           for (let i = callStack.length - 1; i >= 0; i--) {
-            const frame = callStack[i];
+            const frame = callStack[i].scalars;
             if (frame.has(name)) {
               frame.set(name, val);
               return val;
@@ -846,101 +836,6 @@ function createBcCommand(options = {}) {
           globals.set(name, val);
           return val;
         };
-        const evalExprSync = (expr) => {
-          if (steps + 1 >= maxSteps || (steps + 1 & 4095) === 0) return null;
-          steps++;
-          switch (expr.kind) {
-            case "num":
-              return parseLiteralInBase(expr.raw, ibase);
-            case "str":
-              outBuffer += expr.value;
-              return ZERO;
-            case "var":
-              if (expr.index) return null;
-              return getVarScalarSync(expr.name);
-            case "assign": {
-              if (expr.target.index) return null;
-              const r = evalExprSync(expr.right);
-              if (r === null) return null;
-              if (expr.op === "=") return setVarScalarSync(expr.target.name, r);
-              const cur = getVarScalarSync(expr.target.name);
-              let next;
-              if (expr.op === "+=") next = addDec(cur, r);
-              else if (expr.op === "-=") next = subDec(cur, r);
-              else if (expr.op === "*=") next = mulDec(cur, r, scale);
-              else if (expr.op === "/=") next = divDec(cur, r, scale);
-              else if (expr.op === "%=") next = modDec(cur, r, scale);
-              else next = powDec(cur, r, scale);
-              return setVarScalarSync(expr.target.name, next);
-            }
-            case "unary": {
-              if (expr.op === "++" || expr.op === "--") {
-                if (expr.arg.kind !== "var" || expr.arg.index) return null;
-                const cur = getVarScalarSync(expr.arg.name);
-                const next = expr.op === "++" ? addDec(cur, ONE) : subDec(cur, ONE);
-                setVarScalarSync(expr.arg.name, next);
-                return expr.prefix ? next : cur;
-              }
-              const v = evalExprSync(expr.arg);
-              if (v === null) return null;
-              if (expr.op === "-") return { coeff: -v.coeff, scale: v.scale };
-              if (expr.op === "+") return v;
-              if (expr.op === "!") return isNonZero(v) ? ZERO : ONE;
-              return v;
-            }
-            case "binary": {
-              if (expr.op === "&&") {
-                const l2 = evalExprSync(expr.left);
-                if (l2 === null) return null;
-                if (!isNonZero(l2)) return ZERO;
-                const r2 = evalExprSync(expr.right);
-                if (r2 === null) return null;
-                return isNonZero(r2) ? ONE : ZERO;
-              }
-              if (expr.op === "||") {
-                const l2 = evalExprSync(expr.left);
-                if (l2 === null) return null;
-                if (isNonZero(l2)) return ONE;
-                const r2 = evalExprSync(expr.right);
-                if (r2 === null) return null;
-                return isNonZero(r2) ? ONE : ZERO;
-              }
-              const l = evalExprSync(expr.left);
-              if (l === null) return null;
-              const r = evalExprSync(expr.right);
-              if (r === null) return null;
-              switch (expr.op) {
-                case "+":
-                  return addDec(l, r);
-                case "-":
-                  return subDec(l, r);
-                case "*":
-                  return mulDec(l, r, scale);
-                case "/":
-                  return divDec(l, r, scale);
-                case "%":
-                  return modDec(l, r, scale);
-                case "^":
-                  return powDec(l, r, scale);
-                case "==":
-                  return cmpDec(l, r) === 0 ? ONE : ZERO;
-                case "!=":
-                  return cmpDec(l, r) !== 0 ? ONE : ZERO;
-                case "<":
-                  return cmpDec(l, r) < 0 ? ONE : ZERO;
-                case "<=":
-                  return cmpDec(l, r) <= 0 ? ONE : ZERO;
-                case ">":
-                  return cmpDec(l, r) > 0 ? ONE : ZERO;
-                case ">=":
-                  return cmpDec(l, r) >= 0 ? ONE : ZERO;
-              }
-              return ZERO;
-            }
-            default:
-              return null;
-          }
-        };
         const evalExpr = async (expr) => {
           {
             const p = tick();
@@ -950,7 +845,7 @@ function createBcCommand(options = {}) {
             case "num":
               return parseLiteralInBase(expr.raw, ibase);
             case "str":
-              outBuffer += expr.value;
+              appendOutput(expr.value);
               return ZERO;
             case "var":
               return getVar(expr.name, expr.index);
@@ -964,7 +859,7 @@ function createBcCommand(options = {}) {
               else if (expr.op === "*=") next = mulDec(cur, r, scale);
               else if (expr.op === "/=") next = divDec(cur, r, scale);
               else if (expr.op === "%=") next = modDec(cur, r, scale);
-              else next = powDec(cur, r, scale);
+              else next = powDec(cur, r, scale, limits.maxExponent);
               return setVar(expr.target.name, expr.target.index, next);
             }
             case "unary": {
@@ -1008,7 +903,7 @@ function createBcCommand(options = {}) {
                 case "%":
                   return modDec(l, r, scale);
                 case "^":
-                  return powDec(l, r, scale);
+                  return powDec(l, r, scale, limits.maxExponent);
                 case "==":
                   return cmpDec(l, r) === 0 ? ONE : ZERO;
                 case "!=":
@@ -1033,30 +928,17 @@ function createBcCommand(options = {}) {
               if (expr.name === "length") return lengthDec(arg0);
               if (expr.name === "abs") return { coeff: arg0.coeff < 0n ? -arg0.coeff : arg0.coeff, scale: arg0.scale };
               if (mathlib) {
-                if (expr.name === "s") return fromNumber(Math.sin(toNumber(arg0)), scale);
-                if (expr.name === "c") return fromNumber(Math.cos(toNumber(arg0)), scale);
-                if (expr.name === "a") return fromNumber(Math.atan(toNumber(arg0)), scale);
-                if (expr.name === "l") {
-                  const x = toNumber(arg0);
-                  if (x <= 0) throw new Error("Runtime error: l(x) domain error");
-                  return fromNumber(Math.log(x), scale);
-                }
-                if (expr.name === "e") return fromNumber(Math.exp(toNumber(arg0)), scale);
-                if (expr.name === "j") {
-                  const nVal = Math.trunc(toNumber(arg0));
-                  const xVal = toNumber(args[1] ?? ZERO);
-                  if (xVal === 0) return nVal === 0 ? fromNumber(1, scale) : { coeff: 0n, scale };
-                  return fromNumber(besselJ(nVal, xVal), scale);
-                }
+                const result = await mathValue(expr.name, args, scale, tick);
+                if (result) return result;
               }
               const fn = funcs.get(expr.name);
               if (!fn) throw new Error(`Function ${expr.name} not defined.`);
-              if (callStack.length >= 64) throw new Error("bc function recursion depth exceeded (64)");
+              if (callStack.length >= limits.maxRecursionDepth) throw new Error(`bc function recursion depth exceeded (${limits.maxRecursionDepth})`);
               const frame = /* @__PURE__ */ new Map();
               for (let i = 0; i < fn.params.length; i++) {
                 frame.set(fn.params[i], args[i] ?? ZERO);
               }
-              callStack.push(frame);
+              callStack.push({ scalars: frame, arrays: /* @__PURE__ */ new Map() });
               try {
                 await execStmt(fn.body);
                 return ZERO;
@@ -1083,8 +965,10 @@ function createBcCommand(options = {}) {
             case "auto": {
               const frame = callStack.at(-1);
               if (frame) {
-                for (const name of stmt.names) {
-                  if (!frame.has(name)) frame.set(name, ZERO);
+                for (const { name, array } of stmt.names) {
+                  if (array) {
+                    if (!frame.arrays.has(name)) frame.arrays.set(name, /* @__PURE__ */ new Map());
+                  } else if (!frame.scalars.has(name)) frame.scalars.set(name, ZERO);
                 }
               }
               return;
@@ -1133,11 +1017,11 @@ function createBcCommand(options = {}) {
             case "print":
               for (const item of stmt.items) {
                 if (item.kind === "str") {
-                  outBuffer += item.value;
+                  appendOutput(item.value);
                 } else {
                   const v = await evalExpr(item);
                   last = v;
-                  outBuffer += formatDecimalInBase(v, obase);
+                  appendOutput(formatDecimalInBase(v, obase));
                 }
               }
               return;
@@ -1151,13 +1035,13 @@ function createBcCommand(options = {}) {
               throw new FlowSignal("halt");
             case "expr": {
               if (stmt.expr.kind === "str") {
-                outBuffer += stmt.expr.value;
+                appendOutput(stmt.expr.value);
                 return;
               }
               const val = await evalExpr(stmt.expr);
-              if (stmt.expr.kind !== "assign") {
+              if (stmt.expr.kind !== "assign" || stmt.expr.parenthesized) {
                 last = val;
-                outBuffer += formatDecimalInBase(val, obase) + "\n";
+                appendOutput(formatDecimalInBase(val, obase) + "\n");
               }
               return;
             }
@@ -1165,25 +1049,6 @@ function createBcCommand(options = {}) {
         };
         try {
           for (const s of stmts) {
-            if (s.kind === "expr" && (steps & 4095) < 4060 && steps + 32 < maxSteps) {
-              const savedSteps = steps;
-              const savedOutLen = outBuffer.length;
-              steps++;
-              if (s.expr.kind === "str") {
-                outBuffer += s.expr.value;
-                continue;
-              }
-              const syncVal = evalExprSync(s.expr);
-              if (syncVal !== null) {
-                if (s.expr.kind !== "assign") {
-                  last = syncVal;
-                  outBuffer += formatDecimalInBase(syncVal, obase) + "\n";
-                }
-                continue;
-              }
-              steps = savedSteps;
-              outBuffer = outBuffer.slice(0, savedOutLen);
-            }
             await execStmt(s);
           }
         } catch (sig) {
@@ -1191,15 +1056,20 @@ function createBcCommand(options = {}) {
             throw sig;
           }
         }
+        context.signal.throwIfAborted();
         if (outBuffer.length > 0) {
           await writeText(context.stdout, outBuffer);
+          context.signal.throwIfAborted();
         }
         return { exitCode: 0 };
       } catch (err) {
+        context.signal.throwIfAborted();
+        if (err instanceof Error && err.name === "AbortError") throw err;
         const msg = err instanceof Error ? err.message : String(err);
         const code = err instanceof UsageError ? 2 : 1;
         await writeText(context.stderr, `bc: ${msg}
 `);
+        context.signal.throwIfAborted();
         return { exitCode: code };
       }
     }

package/dist/safe-bash-command-column/column.js

@@ -1,11 +1,11 @@
 import {
   createColumnCommand
-} from "../safe-bash/command-chunks/chunk-LPORMIZS.js";
-import "../safe-bash/command-chunks/chunk-2WRTLCGK.js";
-import "../safe-bash/command-chunks/chunk-NI7MKJPN.js";
-import "../safe-bash/command-chunks/chunk-WDHI3S6Y.js";
-import "../safe-bash/command-chunks/chunk-K543PB3I.js";
+} from "../safe-bash/command-chunks/chunk-FZTK4MFI.js";
+import "../safe-bash/command-chunks/chunk-LAOM65EE.js";
+import "../safe-bash/command-chunks/chunk-4OOUQTQO.js";
+import "../safe-bash/command-chunks/chunk-G66QUHIZ.js";
 import "../safe-bash/command-chunks/chunk-AHEQ2THG.js";
+import "../safe-bash/command-chunks/chunk-MTQH74CF.js";
 import "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
 export {
   createColumnCommand

package/dist/safe-bash-command-column/display.d.ts

@@ -8,4 +8,4 @@ export declare function widthOf(point: number): number;
 export declare function validateScalar(character: string, allowTab?: boolean): void;
 export declare function cell(text: string, budget: ColumnBudget): Cell | Promise<Cell>;
 export declare function decode(bytes: Uint8Array): string;
-export declare function fields(text: string, separator: Set<string> | undefined, budget: ColumnBudget, remainingCells: number, columnLimit?: number, outputSeparatorBytes?: number): string[] | Promise<string[]>;
+export declare function fields(text: string, separator: Set<string> | undefined, budget: ColumnBudget, remainingCells: number, columnLimit?: number, outputSeparatorBytes?: number): Promise<string[]>;

package/dist/safe-bash-command-column/display.js

@@ -5,7 +5,7 @@ import {
   validateScalar,
   whitespace,
   widthOf
-} from "../safe-bash/command-chunks/chunk-NI7MKJPN.js";
+} from "../safe-bash/command-chunks/chunk-MTQH74CF.js";
 import "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
 export {
   cell,