@poe-platform/safe-bash 0.1.788 → 0.1.789

package/dist/safe-bash/command-chunks/{chunk-TOSM3T3A.js → chunk-UJOO6DKY.js}

@@ -4,7 +4,7 @@ import {
 import {
   gnuInformation,
   gnuInformationSync
-} from "./chunk-Y5IHIAY3.js";
+} from "./chunk-XNHSCU6I.js";
 import {
   inputRequirements
 } from "./chunk-YAFQG4SC.js";
@@ -505,7 +505,7 @@ function replaceArgument(source, pattern, replacement) {
   chunks.push(source.subarray(start));
   return concatenate(chunks);
 }
-function escapeBytes(text, zeroOctal = false, bareOctal = false, unicode) {
+function escapeBytes(text, zeroOctal = false, bareOctal = false, unicode, literalFormat = false) {
   if (unicode && typeof text === "string")
     text = encoder.encode(text);
   if (typeof text === "string") {
@@ -513,14 +513,19 @@ function escapeBytes(text, zeroOctal = false, bareOctal = false, unicode) {
     const control2 = { a: 7, b: 8, e: 27, E: 27, f: 12, n: 10, r: 13, t: 9, v: 11, "\\": 92 };
     for (let index = 0; index < text.length; ) {
       if (text[index] !== "\\" || index + 1 === text.length) {
-        const character = String.fromCodePoint(text.codePointAt(index));
-        chunks.push(encoder.encode(character));
-        index += character.length;
+        const character2 = String.fromCodePoint(text.codePointAt(index));
+        chunks.push(encoder.encode(character2));
+        index += character2.length;
         continue;
       }
       const next = text[index + 1];
-      if (next === "c")
+      if (!literalFormat && next === "c")
         return { bytes: concatenate(chunks), stop: true };
+      if (literalFormat && (next === "'" || next === '"' || next === "?")) {
+        chunks.push(encoder.encode(next));
+        index += 2;
+        continue;
+      }
       if (control2[next] !== void 0) {
         chunks.push(Uint8Array.of(control2[next]));
         index += 2;
@@ -539,8 +544,9 @@ function escapeBytes(text, zeroOctal = false, bareOctal = false, unicode) {
         index += 1 + hexadecimal[0].length;
         continue;
       }
-      chunks.push(encoder.encode(`\\${next}`));
-      index += 2;
+      const character = String.fromCodePoint(text.codePointAt(index + 1));
+      chunks.push(encoder.encode(`\\${character}`));
+      index += 1 + character.length;
     }
     return { bytes: concatenate(chunks), stop: false };
   }
@@ -554,8 +560,13 @@ function escapeBytes(text, zeroOctal = false, bareOctal = false, unicode) {
       continue;
     }
     const next = source[index + 1];
-    if (next === 99)
+    if (!literalFormat && next === 99)
       return { bytes: bytes.subarray(0, size), stop: true };
+    if (literalFormat && (next === 39 || next === 34 || next === 63)) {
+      bytes[size++] = next;
+      index += 2;
+      continue;
+    }
     if (control[next] !== void 0) {
       bytes[size++] = control[next];
       index += 2;

package/dist/safe-bash/command-chunks/{chunk-2LP3VMPA.js → chunk-WFDW4XXD.js}

@@ -33,26 +33,10 @@ var CsvkitCleanupError = class extends AggregateError {
   }
 };
 
-// packages/safe-bash-command-csvkit/dist/diagnostics/exception.js
-init_buffer();
-var PythonException = class extends CsvkitDiagnostic {
-  exceptionClass;
-  detail;
-  traceback;
-  constructor(exceptionClass, detail, traceback) {
-    super(detail);
-    this.exceptionClass = exceptionClass;
-    this.detail = detail;
-    this.traceback = traceback;
-    this.name = exceptionClass;
-  }
-};
-
 export {
   CsvkitDiagnostic,
   CsvkitBlocked,
   CsvkitOutputBudgetError,
   CsvkitWorkBudgetError,
-  CsvkitCleanupError,
-  PythonException
+  CsvkitCleanupError
 };

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

@@ -0,0 +1,318 @@
+import {
+  decimalZeroes
+} from "./chunk-QM4UZF3C.js";
+import {
+  CsvkitBlocked
+} from "./chunk-WFDW4XXD.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-csvkit/dist/python-regex.js
+init_buffer();
+function pythonWhitespace(char) {
+  const code = char.codePointAt(0);
+  return code >= 9 && code <= 13 || code >= 28 && code <= 32 || code === 133 || code === 160 || code === 5760 || code >= 8192 && code <= 8202 || code === 8232 || code === 8233 || code === 8239 || code === 8287 || code === 12288;
+}
+function fixedWidth(node) {
+  if (node.kind === "char")
+    return 1;
+  if (node.kind === "anchor" || node.kind === "assertion")
+    return 0;
+  if (node.kind === "repeat") {
+    const width = fixedWidth(node.node);
+    return width === 0 ? 0 : width !== void 0 && node.min === node.max ? width * node.min : void 0;
+  }
+  const widths = node.nodes.map(fixedWidth);
+  if (widths.some((width) => width === void 0))
+    return void 0;
+  if (node.kind === "alternative")
+    return widths.every((width) => width === widths[0]) ? widths[0] : void 0;
+  return widths.reduce((sum, width) => sum + width, 0);
+}
+function compilePythonSearch(pattern, step, maxWork, retain) {
+  retain(64 + pattern.length * 8);
+  const chars = Array.from(pattern);
+  let index = 0;
+  let insensitive = false;
+  let dotall = false;
+  let multiline = false;
+  let ascii = false;
+  let unicode = false;
+  const unsupported = () => {
+    throw new CsvkitBlocked("Python regex syntax or diagnostic outside qualified subset");
+  };
+  while (chars[index] === "(" && chars[index + 1] === "?") {
+    let end = index + 2;
+    while (chars[end] && "aimsu".includes(chars[end])) {
+      step();
+      end++;
+    }
+    if (end > index + 2 && chars[end] === ")") {
+      const flags = chars.slice(index + 2, end);
+      insensitive ||= flags.includes("i");
+      dotall ||= flags.includes("s");
+      multiline ||= flags.includes("m");
+      ascii ||= flags.includes("a");
+      unicode ||= flags.includes("u");
+      if (ascii && unicode)
+        unsupported();
+      index = end + 1;
+    } else
+      break;
+  }
+  const digit = (char) => ascii ? char >= "0" && char <= "9" : decimalZeroes.some((zero) => char.codePointAt(0) >= zero && char.codePointAt(0) < zero + 10);
+  const word = (char) => {
+    if (!ascii && char.codePointAt(0) > 127)
+      return unsupported();
+    return char === "_" || /^[a-zA-Z0-9]$/.test(char);
+  };
+  const space = (char) => ascii ? " 	\n\r\f\v".includes(char) : pythonWhitespace(char);
+  const literal = (value) => ({ kind: "char", test: (char) => {
+    if (insensitive && (value.codePointAt(0) > 127 || char.codePointAt(0) > 127))
+      unsupported();
+    return insensitive ? char.toLowerCase() === value.toLowerCase() : char === value;
+  } });
+  function escape(inClass = false) {
+    const value = chars[index++];
+    if (!value)
+      return unsupported();
+    if (value === "x" || value === "u" || value === "U") {
+      const length = value === "x" ? 2 : value === "u" ? 4 : 8;
+      let hex = "";
+      for (let count = 0; count < length; count++) {
+        step();
+        const digit2 = chars[index++];
+        if (!digit2 || !"0123456789abcdefABCDEF".includes(digit2))
+          return unsupported();
+        hex += digit2;
+      }
+      const code = Number.parseInt(hex, 16);
+      if (code > 1114111)
+        return unsupported();
+      return literal(String.fromCodePoint(code));
+    }
+    const predicate = { d: digit, s: space, w: word }[value.toLowerCase()];
+    if (predicate)
+      return { kind: "char", test: (char) => value === value.toLowerCase() ? predicate(char) : !predicate(char) };
+    if (!inClass && (value === "A" || value === "Z" || value === "z"))
+      return { kind: "anchor", test: (text, position) => value === "A" ? position === 0 : position === text.length };
+    if (!inClass && (value === "b" || value === "B"))
+      return { kind: "anchor", test: (text, position) => {
+        if (value === "B" && text.length === 0)
+          return true;
+        const boundary = (position > 0 && word(text[position - 1])) !== (position < text.length && word(text[position]));
+        return value === "b" ? boundary : !boundary;
+      } };
+    const control = { n: "\n", r: "\r", t: "	", f: "\f", v: "\v", a: "\x07", b: "\b" }[value];
+    if (control !== void 0)
+      return literal(control);
+    if (/^[a-zA-Z0-9]$/.test(value))
+      return unsupported();
+    return literal(value);
+  }
+  function atom() {
+    step();
+    const value = chars[index++];
+    if (!value)
+      return unsupported();
+    if (value === "\\")
+      return escape();
+    if (value === ".")
+      return { kind: "char", test: (char) => dotall || char !== "\n" };
+    if (value === "^")
+      return { kind: "anchor", test: (text, position) => position === 0 || multiline && text[position - 1] === "\n" };
+    if (value === "$")
+      return { kind: "anchor", test: (text, position) => position === text.length || text[position] === "\n" && (multiline || position === text.length - 1) };
+    if (value === "(") {
+      let assertion;
+      if (chars[index] === "?") {
+        const modifier = chars[index + 1];
+        if (modifier === ":")
+          index += 2;
+        else if (modifier === "=" || modifier === "!") {
+          assertion = { negative: modifier === "!", behind: false };
+          index += 2;
+        } else if (modifier === "<" && (chars[index + 2] === "=" || chars[index + 2] === "!")) {
+          assertion = { negative: chars[index + 2] === "!", behind: true };
+          index += 3;
+        } else
+          return unsupported();
+      }
+      const node = expression();
+      if (chars[index++] !== ")")
+        return unsupported();
+      if (assertion) {
+        const behind = assertion.behind ? fixedWidth(node) : void 0;
+        if (assertion.behind && behind === void 0)
+          return unsupported();
+        return { kind: "assertion", node, negative: assertion.negative, behind };
+      }
+      return node;
+    }
+    if (value === "[") {
+      if (chars[index] === "[")
+        return unsupported();
+      const negate = chars[index] === "^";
+      if (negate)
+        index++;
+      const tests = [];
+      while (index < chars.length && (chars[index] !== "]" || tests.length === 0)) {
+        const first = chars[index++];
+        if (first && "&|~".includes(first) && chars[index] === first)
+          return unsupported();
+        if (first === "-" && tests.length > 0 && chars[index] === "-")
+          return unsupported();
+        if (first === "\\") {
+          const escaped = escape(true);
+          if (escaped.kind !== "char")
+            return unsupported();
+          if (chars[index] === "-" && chars[index + 1] !== "]")
+            return unsupported();
+          tests.push(escaped.test);
+        } else if (chars[index] === "-" && chars[index + 1] !== "]" && chars[index + 1] !== void 0) {
+          index++;
+          const last = chars[index++];
+          if (!first || !last || last === "\\" || first.codePointAt(0) > last.codePointAt(0) || insensitive)
+            return unsupported();
+          tests.push((char) => char.codePointAt(0) >= first.codePointAt(0) && char.codePointAt(0) <= last.codePointAt(0));
+        } else {
+          const item = literal(first);
+          if (item.kind !== "char")
+            return unsupported();
+          tests.push(item.test);
+        }
+      }
+      if (chars[index++] !== "]")
+        return unsupported();
+      return { kind: "char", test: (char) => tests.some((test) => test(char)) !== negate };
+    }
+    if ("*+?{} )".includes(value) && value !== " ")
+      return unsupported();
+    return literal(value);
+  }
+  function expression() {
+    const alternatives = [];
+    do {
+      const nodes = [];
+      while (index < chars.length && chars[index] !== "|" && chars[index] !== ")") {
+        let node = atom();
+        const quantifier = chars[index];
+        if (quantifier && "*+?{".includes(quantifier)) {
+          if (node.kind === "anchor")
+            return unsupported();
+          index++;
+          let min = quantifier === "+" ? 1 : 0;
+          let max = quantifier === "?" ? 1 : Infinity;
+          if (quantifier === "{") {
+            let digits = "";
+            while (chars[index] && "0123456789".includes(chars[index])) {
+              step();
+              digits += chars[index++];
+            }
+            if (!digits && chars[index] !== ",")
+              return unsupported();
+            min = digits ? Number(digits) : 0;
+            max = min;
+            if (chars[index] === ",") {
+              index++;
+              digits = "";
+              while (chars[index] && "0123456789".includes(chars[index])) {
+                step();
+                digits += chars[index++];
+              }
+              max = digits ? Number(digits) : Infinity;
+            }
+            if (chars[index++] !== "}" || min > max || !Number.isSafeInteger(min) || min >= 4294967295 || max !== Infinity && (!Number.isSafeInteger(max) || max >= 4294967295))
+              return unsupported();
+          }
+          node = { kind: "repeat", node, min, max };
+          if (chars[index] === "?")
+            index++;
+          if (chars[index] === "+")
+            return unsupported();
+        }
+        nodes.push(node);
+      }
+      alternatives.push({ kind: "sequence", nodes });
+      if (chars[index] !== "|")
+        break;
+      index++;
+    } while (index <= chars.length);
+    return { kind: "alternative", nodes: alternatives };
+  }
+  const root = expression();
+  if (index !== chars.length)
+    unsupported();
+  let work = 0;
+  const tick = () => {
+    step();
+    if (++work > maxWork)
+      throw new CsvkitBlocked("Python regex work budget exceeded");
+  };
+  function* evaluate(node, text, position) {
+    tick();
+    if (node.kind === "char") {
+      if (position < text.length && node.test(text[position]))
+        yield position + 1;
+    } else if (node.kind === "anchor") {
+      if (node.test(text, position))
+        yield position;
+    } else if (node.kind === "assertion") {
+      const start = node.behind === void 0 ? position : position - node.behind;
+      let matched = false;
+      if (start >= 0)
+        for (const end of evaluate(node.node, text, start)) {
+          if (node.behind === void 0 || end === position) {
+            matched = true;
+            break;
+          }
+        }
+      if (matched !== node.negative)
+        yield position;
+    } else if (node.kind === "alternative") {
+      for (const child of node.nodes)
+        yield* evaluate(child, text, position);
+    } else if (node.kind === "sequence") {
+      const nodes = node.nodes;
+      function* sequence(index2, offset) {
+        tick();
+        if (index2 === nodes.length)
+          yield offset;
+        else
+          for (const next of evaluate(nodes[index2], text, offset))
+            yield* sequence(index2 + 1, next);
+      }
+      yield* sequence(0, position);
+    } else {
+      let positions = /* @__PURE__ */ new Set([position]);
+      for (let count = 0; count <= node.max && positions.size; count++) {
+        tick();
+        if (count >= node.min)
+          yield* positions;
+        const next = /* @__PURE__ */ new Set();
+        for (const offset of positions)
+          for (const end of evaluate(node.node, text, offset)) {
+            if (end !== offset || count < node.min)
+              next.add(end);
+          }
+        positions = next;
+      }
+    }
+  }
+  return (text) => {
+    retain(64 + text.length * 8);
+    const input = Array.from(text);
+    for (let start = 0; start <= input.length; start++)
+      for (const ignored of evaluate(root, input, start)) {
+        void ignored;
+        return true;
+      }
+    return false;
+  };
+}
+
+export {
+  pythonWhitespace,
+  compilePythonSearch
+};

package/dist/safe-bash/command-chunks/{chunk-Y5IHIAY3.js → chunk-XNHSCU6I.js}

@@ -48,7 +48,7 @@ var information = {
   wc: { usage: "[OPTION]... [FILE]...", description: "Count input lines, words, bytes, characters or display width.", options: ["-l, --lines", "-w, --words", "-c, --bytes", "-m, --chars", "-L, --max-line-length"] },
   pwd: { usage: "[OPTION]...", description: "Print the full filename of the current working directory.", options: ["-L, --logical", "-P, --physical"] },
   true: { usage: "[ignored command line arguments]", description: "Exit with a status code indicating success.", options: [] },
-  false: { usage: "[ignored command line arguments]", description: "Exit with a status code indicating failure.", options: [] },
+  false: { usage: "[ignored command line arguments]", description: "Exit with a status code indicating failure.", options: [], exitCode: 1 },
   echo: { usage: "[SHORT-OPTION]... [STRING]...", description: "Echo the STRING(s) to standard output.", options: ["-n", "-e", "-E"] },
   "[": { usage: "EXPRESSION ]", description: "Evaluate conditional expression.", options: [] }
 };
@@ -125,6 +125,10 @@ function gnuInformation(name, context) {
   return gnuInformationSlow(name, context);
 }
 async function gnuInformationSlow(name, context) {
+  if (name === "echo" && context.env.POSIXLY_CORRECT !== void 0)
+    return void 0;
+  if (name === "pwd" && !context.externalInvocation)
+    return void 0;
   if ((name === "true" || name === "false" || name === "echo" || name === "[") && (context.args.length !== 1 || !context.externalInvocation))
     return void 0;
   const info = information[name] ?? (["md5sum", "sha1sum", "sha224sum", "sha256sum", "sha384sum", "sha512sum"].includes(name) ? checksumInformation : void 0);
@@ -155,10 +159,10 @@ ${info.options.map((option) => `  ${option.split(", ").map((spelling) => spellin
 This is the safe-bash virtual implementation; filesystem operations require backend capabilities.
 `;
       await writeBytes(context.stdout, new TextEncoder().encode(text), context.signal);
-      return { exitCode: 0 };
+      return { exitCode: info.exitCode ?? 0 };
     }
     if (!arg.startsWith("-") || arg === "-") {
-      if (info.stopAtOperand)
+      if (info.stopAtOperand || name === "pwd" && context.env.POSIXLY_CORRECT !== void 0)
         break;
       continue;
     }