@poe-platform/safe-bash 0.1.799 → 0.1.800

package/dist/safe-bash/command-chunks/chunk-V6MSPQLA.js

@@ -0,0 +1,362 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-awk/src/awk-values.ts
+init_buffer();
+import { latin1Bytes, latin1Text } from "../../safe-bash-io-engine/byte-encoding.js";
+import { ProgramError } from "../../safe-bash-io-engine/commands/text-programs/shared.js";
+var AwkArray = class {
+  entries = /* @__PURE__ */ new Map();
+};
+var unset = Object.freeze({ kind: "unset" });
+var SMALL_NUMERICS = Array.from({ length: 4098 }, (_, i) => Object.freeze({ kind: "number", number: i - 1 }));
+var SMALL_NUMERIC_STRINGS = Array.from({ length: 4096 }, (_, i) => Object.freeze({ kind: "numeric", text: String(i), number: i }));
+var EMPTY_STRING_SCALAR = Object.freeze({ kind: "string", text: "" });
+var SCALAR_ZERO = SMALL_NUMERICS[1];
+var SCALAR_ONE = SMALL_NUMERICS[2];
+var INPUT_STRING_CACHE_KEYS = new Array(64);
+var INPUT_STRING_CACHE_VALS = new Array(64);
+var STRING_SCALAR_CACHE_KEYS = new Array(64);
+var STRING_SCALAR_CACHE_VALS = new Array(64);
+var numeric = (n) => (n | 0) === n && n >= -1 && n <= 4096 && (n !== 0 || !Object.is(n, -0)) ? SMALL_NUMERICS[n + 1] : { kind: "number", number: n };
+var string = (text2) => {
+  const len = text2.length;
+  if (len === 0) return EMPTY_STRING_SCALAR;
+  if (len <= 16) {
+    const slot = text2.charCodeAt(0) * 31 + text2.charCodeAt(len - 1) * 17 + len & 63;
+    if (STRING_SCALAR_CACHE_KEYS[slot] === text2) return STRING_SCALAR_CACHE_VALS[slot];
+    const flat = text2.split("").join("");
+    const val = Object.freeze({ kind: "string", text: flat });
+    STRING_SCALAR_CACHE_KEYS[slot] = flat;
+    STRING_SCALAR_CACHE_VALS[slot] = val;
+    return val;
+  }
+  return { kind: "string", text: text2 };
+};
+function inputValue(text2) {
+  const len = text2.length;
+  if (len === 0) return EMPTY_STRING_SCALAR;
+  const first = text2.charCodeAt(0);
+  if (first >= 48 && first <= 57 && len <= 15) {
+    let num = first - 48;
+    let allDigits = true;
+    for (let i = 1; i < len; i++) {
+      const c = text2.charCodeAt(i);
+      if (c < 48 || c > 57) {
+        allDigits = false;
+        break;
+      }
+      num = num * 10 + (c - 48);
+    }
+    if (allDigits) {
+      if (num < 4096 && (len === 1 || first !== 48)) return SMALL_NUMERIC_STRINGS[num];
+      return { kind: "numeric", text: text2, number: num };
+    }
+  }
+  if (first > 57 || first < 48 && first !== 32 && first !== 9 && first !== 10 && first !== 13 && first !== 43 && first !== 45 && first !== 46) {
+    if (len <= 12) {
+      const slot = first * 31 + text2.charCodeAt(len - 1) * 17 + len & 63;
+      if (INPUT_STRING_CACHE_KEYS[slot] === text2) return INPUT_STRING_CACHE_VALS[slot];
+      const flat = latin1Text(latin1Bytes(text2));
+      const val = Object.freeze({ kind: "string", text: flat });
+      INPUT_STRING_CACHE_KEYS[slot] = flat;
+      INPUT_STRING_CACHE_VALS[slot] = val;
+      return val;
+    }
+    return { kind: "string", text: text2 };
+  }
+  return /^[ \t\r\n]*[+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:[eE][+-]?[0-9]+)?[ \t\r\n]*$/u.test(text2) ? { kind: "numeric", text: text2, number: Number(text2) } : string(text2);
+}
+function inputValueFromSlice(record, start, end) {
+  const len = end - start;
+  if (len <= 0) return EMPTY_STRING_SCALAR;
+  const first = record.charCodeAt(start);
+  if (first >= 48 && first <= 57 && len <= 15) {
+    let num = first - 48;
+    let allDigits = true;
+    for (let i = start + 1; i < end; i++) {
+      const c = record.charCodeAt(i);
+      if (c < 48 || c > 57) {
+        allDigits = false;
+        break;
+      }
+      num = num * 10 + (c - 48);
+    }
+    if (allDigits) {
+      if (num < 4096 && (len === 1 || first !== 48)) return SMALL_NUMERIC_STRINGS[num];
+      return { kind: "numeric", text: record.slice(start, end), number: num };
+    }
+  }
+  if (first > 57 || first < 48 && first !== 32 && first !== 9 && first !== 10 && first !== 13 && first !== 43 && first !== 45 && first !== 46) {
+    if (len <= 12) {
+      const slot = first * 31 + record.charCodeAt(end - 1) * 17 + len & 63;
+      const cachedKey = INPUT_STRING_CACHE_KEYS[slot];
+      if (cachedKey !== void 0 && cachedKey.length === len && record.startsWith(cachedKey, start)) {
+        return INPUT_STRING_CACHE_VALS[slot];
+      }
+      const flat = latin1Text(latin1Bytes(record.slice(start, end)));
+      const val = Object.freeze({ kind: "string", text: flat });
+      INPUT_STRING_CACHE_KEYS[slot] = flat;
+      INPUT_STRING_CACHE_VALS[slot] = val;
+      return val;
+    }
+    return { kind: "string", text: record.slice(start, end) };
+  }
+  return inputValue(record.slice(start, end));
+}
+function scalar(value) {
+  if (value instanceof AwkArray) throw new ProgramError("array used in scalar context");
+  return value;
+}
+function number(value) {
+  if (value.kind === "unset") return 0;
+  if (value.kind === "number" || value.kind === "numeric") return value.number;
+  const prefix = /^[ \t\r\n]*[+-]?(?:0[xX][0-9a-fA-F]+|(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:[eE][+-]?[0-9]+)?)/u.exec(value.text)?.[0];
+  if (prefix === void 0) return 0;
+  if (prefix.includes("x") || prefix.includes("X")) {
+    const trimmed = prefix.trimStart();
+    const sign = trimmed[0] === "-" ? -1 : 1;
+    const digits = trimmed.slice(trimmed[0] === "+" || trimmed[0] === "-" ? 3 : 2);
+    return sign * Number.parseInt(digits, 16);
+  }
+  return Number(prefix);
+}
+function truth(value) {
+  return value.kind === "unset" ? false : value.kind === "number" || value.kind === "numeric" ? value.number !== 0 : value.text !== "";
+}
+function general(value, precision, alternate) {
+  precision = Math.max(1, precision);
+  if (value === 0) return alternate ? 0 .toFixed(precision - 1) : "0";
+  const rounded = Number(value.toPrecision(precision));
+  const exponent = Math.floor(Math.log10(Math.abs(rounded)));
+  let result = exponent < -4 || exponent >= precision ? rounded.toExponential(precision - 1) : rounded.toFixed(Math.max(0, precision - exponent - 1));
+  if (!alternate) result = result.replace(/(\.[0-9]*?)0+(?=e|$)/u, "$1").replace(/\.(?=e|$)/u, "");
+  return result;
+}
+function preciseFloat(value, precision, conversion, alternate, admit) {
+  const buffer = new ArrayBuffer(8);
+  const view = new DataView(buffer);
+  view.setFloat64(0, Math.abs(value));
+  const bits = view.getBigUint64(0);
+  const exponentBits = Number(bits >> 52n & 2047n);
+  let mantissa = bits & (1n << 52n) - 1n;
+  if (exponentBits) mantissa += 1n << 52n;
+  const power = (exponentBits || 1) - 1023 - 52;
+  const digits = (power >= 0 ? mantissa << BigInt(power) : mantissa * 5n ** BigInt(-power)).toString();
+  const point = digits.length + Math.min(0, power);
+  const negative = value < 0 ? "-" : "";
+  if (conversion.toLowerCase() === "f") {
+    admit(Math.max(1, value === 0 ? 1 : point) + precision + 1 + negative.length);
+    const count = point + precision;
+    let scaled = count >= digits.length ? digits.padEnd(count, "0") : count <= 0 ? "0" : digits.slice(0, count);
+    if (count >= 0 && count < digits.length && Number(digits[count]) >= 5) scaled = (BigInt(scaled) + 1n).toString();
+    scaled = scaled.padStart(precision + 1, "0");
+    return negative + scaled.slice(0, -precision) + "." + scaled.slice(-precision);
+  }
+  const significant = conversion.toLowerCase() === "g" ? precision : precision + 1;
+  const exact = digits.replace(/^0+/u, "") || "0";
+  const exponent = value === 0 ? 0 : point - 1;
+  let rounded = exact.slice(0, significant);
+  if (exact.length > significant && Number(exact[significant]) >= 5) rounded = (BigInt(rounded) + 1n).toString();
+  const exponential = conversion.toLowerCase() === "e" || exponent < -4 || exponent >= significant;
+  const padded = conversion.toLowerCase() !== "g" || alternate;
+  if (padded) {
+    admit(negative.length + (exponential ? significant + 3 + Math.max(2, String(Math.abs(exponent)).length) : significant + 1 + Math.max(0, -exponent)));
+    rounded = rounded.padEnd(significant, "0");
+  } else rounded = rounded.replace(/0+$/u, "") || "0";
+  let result;
+  if (exponential) {
+    result = rounded[0] + "." + rounded.slice(1) + "e" + (exponent < 0 ? "-" : "+") + Math.abs(exponent);
+  } else {
+    const decimalPoint = exponent + 1;
+    result = decimalPoint <= 0 ? "0." + "0".repeat(-decimalPoint) + rounded : rounded.slice(0, decimalPoint).padEnd(decimalPoint, "0") + "." + rounded.slice(decimalPoint);
+  }
+  if (conversion.toLowerCase() === "g" && !alternate) result = result.replace(/(\.[0-9]*?)0+(?=e|$)/u, "$1").replace(/\.(?=e|$)/u, "");
+  return negative + result;
+}
+function scanFormat(format, offset) {
+  let cursor = offset + 1;
+  const flagsStart = cursor;
+  while (cursor < format.length && "-+ #0".includes(format[cursor])) cursor++;
+  const flags = format.slice(flagsStart, cursor);
+  const amount = () => {
+    const start = cursor;
+    if (format[cursor] === "*") cursor++;
+    else while (cursor < format.length && format[cursor] >= "0" && format[cursor] <= "9") cursor++;
+    return format.slice(start, cursor);
+  };
+  const width = amount();
+  let precision;
+  if (format[cursor] === ".") {
+    cursor++;
+    precision = amount();
+  }
+  const conversion = format[cursor];
+  if (conversion === void 0 || !"csdiuoxXfFeEgG".includes(conversion)) {
+    throw new ProgramError(`unsupported format near '${format.slice(offset)}'`);
+  }
+  return { end: cursor + 1, flags, width, precision, conversion };
+}
+function validateFormat(format) {
+  for (let offset = 0; offset < format.length; ) {
+    if (format[offset] !== "%") {
+      offset++;
+      continue;
+    }
+    if (format[offset + 1] === "%") {
+      offset += 2;
+      continue;
+    }
+    const match = scanFormat(format, offset);
+    offset = match.end;
+    if (match.width !== "*" && !Number.isSafeInteger(Number(match.width ?? 0)) || match.precision !== "*" && !Number.isSafeInteger(Number(match.precision ?? 0))) throw new ProgramError("excessive format width or precision");
+  }
+}
+function formatted(format, values, text2, budget) {
+  budget?.step(format.length);
+  let result = "";
+  let argument = 0;
+  const limit = budget?.maxBufferBytes ?? Infinity;
+  const admit = (length) => {
+    budget?.step(0);
+    if (length > limit - result.length) throw new ProgramError("text buffer limit exceeded");
+    budget?.step(length);
+  };
+  const amountOf = (value) => {
+    budget?.step(value.kind === "string" ? value.text.length : 0);
+    return number(value);
+  };
+  const take = () => {
+    const value = values[argument++];
+    if (value === void 0) throw new ProgramError("not enough arguments for format");
+    return value;
+  };
+  for (let offset = 0; offset < format.length; ) {
+    if (format[offset] !== "%") {
+      admit(1);
+      result += format[offset++];
+      continue;
+    }
+    if (format[offset + 1] === "%") {
+      admit(1);
+      result += "%";
+      offset += 2;
+      continue;
+    }
+    const match = scanFormat(format, offset);
+    offset = match.end;
+    let flags = match.flags;
+    let width = match.width === "*" ? Math.trunc(amountOf(take())) : Number(match.width ?? 0);
+    let precision = match.precision === void 0 ? void 0 : match.precision === "*" ? Math.trunc(amountOf(take())) : Number(match.precision || 0);
+    if (width < 0) {
+      flags += "-";
+      width = -width;
+    }
+    if (precision !== void 0 && precision < 0) precision = void 0;
+    const conversion = match.conversion;
+    if (!Number.isSafeInteger(width) || precision !== void 0 && !Number.isSafeInteger(precision)) throw new ProgramError("excessive format width or precision");
+    const value = take();
+    let part;
+    if (conversion === "s") {
+      const source = text2(value);
+      admit(Math.min(source.length, precision ?? source.length));
+      part = source.slice(0, precision);
+    } else if (conversion === "c") {
+      admit(1);
+      part = value.kind === "string" ? value.text[0] ?? "\0" : String.fromCharCode(Math.trunc(amountOf(value)) & 255);
+    } else {
+      const amount = amountOf(value);
+      if (!Number.isFinite(amount)) throw new ProgramError("cannot format a non-finite number");
+      budget?.step(1 + (/[fFeEgG]/u.test(conversion) ? precision ?? 6 : 0));
+      if (/[fFeEgG]/u.test(conversion) && (precision ?? 6) > 100) {
+        part = preciseFloat(amount, precision, conversion, flags.includes("#"), admit);
+      } else if (conversion === "f" || conversion === "F") part = amount.toFixed(precision ?? 6);
+      else if (conversion === "e" || conversion === "E") part = amount.toExponential(precision ?? 6);
+      else if (conversion === "g" || conversion === "G") part = general(amount, precision ?? 6, flags.includes("#"));
+      else {
+        const radix = conversion === "o" ? 8 : conversion === "x" || conversion === "X" ? 16 : 10;
+        const integer = BigInt(Math.trunc(amount));
+        part = (/[uoxX]/u.test(conversion) ? BigInt.asUintN(32, integer) : integer).toString(radix);
+        if (precision !== void 0) {
+          const negative = part.startsWith("-");
+          admit(amount === 0 && precision === 0 ? 0 : Math.max(part.length, precision + Number(negative)));
+          part = amount === 0 && precision === 0 ? "" : negative ? `-${part.slice(1).padStart(precision, "0")}` : part.padStart(precision, "0");
+        }
+        if (flags.includes("#") && amount !== 0) {
+          const prefix = radix === 16 ? "0x" : radix === 8 ? "0" : "";
+          admit(prefix.length + part.length);
+          part = prefix + part;
+        }
+      }
+      admit(part.length);
+      part = part.replace(/e([+-])([0-9])$/u, "e$10$2");
+      if (/[XFEG]/u.test(conversion)) {
+        admit(part.length);
+        part = part.toUpperCase();
+      }
+      if (amount >= 0 && !/[uoxX]/u.test(conversion)) {
+        const prefix = flags.includes("+") ? "+" : flags.includes(" ") ? " " : "";
+        admit(prefix.length + part.length);
+        part = prefix + part;
+      }
+      if (flags.includes("#") && /[fFeE]/u.test(conversion)) {
+        budget?.step(part.length);
+        if (!part.includes(".")) {
+          admit(part.length + 1);
+          part = part.replace(/([eE]|$)/u, ".$1");
+        }
+      }
+    }
+    admit(Math.max(part.length, width));
+    if (flags.includes("-")) part = part.padEnd(width, " ");
+    else if (flags.includes("0") && /[diuoxXfFeEgG]/u.test(conversion) && (precision === void 0 || /[fFeEgG]/u.test(conversion))) {
+      const prefix = /^(?:[+ -]|0[xX])/u.exec(part)?.[0] ?? "";
+      part = prefix + part.slice(prefix.length).padStart(Math.max(0, width - prefix.length), "0");
+    } else part = part.padStart(width, " ");
+    admit(part.length);
+    result += part;
+  }
+  return result;
+}
+function text(value, format = "%.6g", budget) {
+  if (value.kind === "unset") return "";
+  if (value.kind !== "number") return value.text;
+  if (Number.isInteger(value.number) && Math.abs(value.number) < 1e21) {
+    budget?.step(0);
+    const n = value.number;
+    const result = (n | 0) === n && n >= 0 && n < 4096 ? SMALL_NUMERIC_STRINGS[n].text : String(n);
+    budget?.check(result);
+    budget?.step(result.length);
+    return result;
+  }
+  return formatted(format, [value], (argument) => String(number(argument)), budget);
+}
+function compare(left, right, format, budget) {
+  if (left.kind !== "string" && right.kind !== "string") {
+    const first2 = number(left);
+    const second2 = number(right);
+    return first2 < second2 ? -1 : first2 > second2 ? 1 : 0;
+  }
+  const first = text(left, format, budget);
+  const second = text(right, format, budget);
+  return first < second ? -1 : first > second ? 1 : 0;
+}
+
+export {
+  AwkArray,
+  unset,
+  SCALAR_ZERO,
+  SCALAR_ONE,
+  numeric,
+  string,
+  inputValue,
+  inputValueFromSlice,
+  scalar,
+  number,
+  truth,
+  validateFormat,
+  formatted,
+  text,
+  compare
+};

package/dist/safe-bash/command-chunks/{chunk-J4PEQWSF.js → chunk-VGG2DL5Q.js}

@@ -575,7 +575,6 @@ function parse(args, target) {
       if (long && equals >= 0 && !tookValue) throw new SearchError(`--${flag} does not take a value`);
     }
   }
-  if (result.replacement?.includes("$")) throw new SearchError("replacement capture expansion is unsupported; use a literal replacement without '$'");
   if (!result.help && !result.version && result.mode !== "files" && !result.explicitPatterns) {
     if (opLen === 0) {
       patterns.length = 0;

package/dist/safe-bash/command-chunks/{chunk-SG424QWS.js → chunk-VL67NWNS.js}

@@ -1,6 +1,6 @@
 import {
   inferDelimiter
-} from "./chunk-2FUAW6GO.js";
+} from "./chunk-QI7LGHJJ.js";
 import {
   Scanner
 } from "./chunk-QUENU6GM.js";