@poe-platform/safe-bash 0.1.788 → 0.1.790

package/dist/safe-bash/command-chunks/{chunk-YNT4ZJHW.js → chunk-TPPBPIWL.js}

@@ -1,9 +1,9 @@
-import {
-  Interpreter
-} from "./chunk-RTOJNFFL.js";
 import {
   parse
 } from "./chunk-JUMF6JDJ.js";
+import {
+  Interpreter
+} from "./chunk-KNI4GRXF.js";
 import {
   Budget,
   JqLimitError,

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

@@ -0,0 +1,82 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-llm/dist/numeric-option.js
+init_buffer();
+function decimalDigit(value) {
+  return value !== void 0 && value >= "0" && value <= "9";
+}
+function parseLlmNumericOption(input, type) {
+  if (typeof input === "number")
+    return type === "integer" && input === 0 ? 0 : input;
+  if (typeof input !== "string")
+    return void 0;
+  const text = input.trim();
+  if (!text)
+    return void 0;
+  if (type === "integer") {
+    let index2 = text[0] === "+" || text[0] === "-" ? 1 : 0;
+    let digits2 = 0;
+    while (index2 < text.length) {
+      if (decimalDigit(text[index2])) {
+        digits2++;
+        index2++;
+      } else if (text[index2] === "_" && decimalDigit(text[index2 - 1]) && decimalDigit(text[index2 + 1]))
+        index2++;
+      else
+        break;
+    }
+    if (!digits2)
+      return void 0;
+    if (text[index2] === ".") {
+      const first = ++index2;
+      while (text[index2] === "0")
+        index2++;
+      if (first === index2)
+        return void 0;
+    }
+    if (index2 !== text.length)
+      return void 0;
+    const value = Number(text.replaceAll("_", ""));
+    return value === 0 ? 0 : value;
+  }
+  if (text.startsWith("_") || text.endsWith("_") || text.includes("__"))
+    return void 0;
+  const normalized = text.replaceAll("_", "");
+  let index = normalized[0] === "+" || normalized[0] === "-" ? 1 : 0;
+  const special = normalized.slice(index).toLowerCase();
+  if (special === "nan")
+    return NaN;
+  if (special === "inf" || special === "infinity")
+    return normalized[0] === "-" ? -Infinity : Infinity;
+  let digits = 0;
+  while (decimalDigit(normalized[index])) {
+    digits++;
+    index++;
+  }
+  if (normalized[index] === ".") {
+    index++;
+    while (decimalDigit(normalized[index])) {
+      digits++;
+      index++;
+    }
+  }
+  if (!digits)
+    return void 0;
+  if (normalized[index] === "e" || normalized[index] === "E") {
+    index++;
+    if (normalized[index] === "+" || normalized[index] === "-")
+      index++;
+    const first = index;
+    while (decimalDigit(normalized[index]))
+      index++;
+    if (first === index)
+      return void 0;
+  }
+  return index === normalized.length ? Number(normalized) : void 0;
+}
+
+export {
+  parseLlmNumericOption
+};

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

@@ -0,0 +1,130 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-llm/dist/elevenlabs-stream.js
+init_buffer();
+async function abortable(operation, signal) {
+  signal.throwIfAborted();
+  let onAbort;
+  const aborted = new Promise((_resolve, reject) => {
+    onAbort = () => reject(signal.reason);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+  try {
+    return await Promise.race([Promise.resolve().then(() => {
+      signal.throwIfAborted();
+      return operation();
+    }), aborted]);
+  } finally {
+    signal.removeEventListener("abort", onAbort);
+  }
+}
+async function* streamElevenLabs(transport, request, limit = Infinity) {
+  const { signal } = request;
+  signal.throwIfAborted();
+  let iterator;
+  let finished = false;
+  let failed = false;
+  let closed = false;
+  let size = 0;
+  const cleanups = /* @__PURE__ */ new Map();
+  const runCleanup = (entry) => {
+    return entry.pending ??= Promise.resolve().then(entry.run);
+  };
+  const register = (cleanup, receiver) => {
+    if (cleanups.has(cleanup))
+      return;
+    const entry = { run: () => cleanup.call(receiver) };
+    cleanups.set(cleanup, entry);
+    if (closed)
+      void runCleanup(entry).catch(() => {
+      });
+  };
+  const dispose = async () => {
+    closed = true;
+    let seen = 0;
+    const failures = [];
+    while (seen < cleanups.size) {
+      const entries = [...cleanups.values()].slice(seen);
+      seen = cleanups.size;
+      const results = await Promise.allSettled(entries.map(runCleanup));
+      for (const result of results)
+        if (result.status === "rejected")
+          failures.push(result.reason);
+    }
+    if (failures.length)
+      throw failures[0];
+  };
+  const close = async () => {
+    const failures = [];
+    try {
+      await dispose();
+    } catch (error) {
+      failures.push(error);
+    }
+    if (!finished && iterator?.return) {
+      const closing = Promise.resolve().then(() => iterator.return());
+      if (signal.aborted)
+        void closing.catch(() => {
+        });
+      else {
+        try {
+          await closing;
+        } catch (error) {
+          failures.push(error);
+        }
+      }
+    }
+    if (!failed) {
+      signal.throwIfAborted();
+      if (failures.length)
+        throw failures[0];
+    }
+  };
+  const onAbort = () => {
+    void dispose().catch(() => {
+    });
+  };
+  signal.addEventListener("abort", onAbort, { once: true });
+  try {
+    const acquired = await abortable(async () => {
+      signal.throwIfAborted();
+      const response = await transport({ ...request, registerCleanup: register });
+      register(response.dispose, response);
+      if (signal.aborted) {
+        await dispose();
+        signal.throwIfAborted();
+      }
+      return response;
+    }, signal);
+    signal.throwIfAborted();
+    if (acquired.status < 200 || acquired.status >= 300)
+      throw new Error(`ElevenLabs HTTP ${acquired.status}: ${acquired.statusText}`);
+    iterator = acquired.body[Symbol.asyncIterator]();
+    while (true) {
+      const next = await abortable(() => iterator.next(), signal);
+      signal.throwIfAborted();
+      if (next.done) {
+        finished = true;
+        return;
+      }
+      if (!(next.value instanceof Uint8Array))
+        throw new TypeError("ElevenLabs audio stream must yield Uint8Array chunks");
+      size += next.value.byteLength;
+      if (size > limit)
+        throw new RangeError("Provider response byte limit exceeded");
+      yield Uint8Array.from(next.value);
+    }
+  } catch (error) {
+    failed = true;
+    throw error;
+  } finally {
+    signal.removeEventListener("abort", onAbort);
+    await close();
+  }
+}
+
+export {
+  streamElevenLabs
+};

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-YFNTMH6Z.js

@@ -0,0 +1,6 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-llm/dist/providers/openai.js
+init_buffer();