@poe-platform/safe-bash 0.1.508 → 0.1.509

package/dist/safe-bash/chunks/{chunk-3ISDVRIM.js → chunk-B637PJBS.js}

@@ -1620,14 +1620,14 @@ var require_buffer = __commonJS({
     );
     E(
       "ERR_OUT_OF_RANGE",
-      function(str, range, input3) {
+      function(str, range, input2) {
         let msg = `The value of "${str}" is out of range.`;
-        let received = input3;
-        if (Number.isInteger(input3) && Math.abs(input3) > 2 ** 32) {
-          received = addNumericalSeparator(String(input3));
-        } else if (typeof input3 === "bigint") {
-          received = String(input3);
-          if (input3 > BigInt(2) ** BigInt(32) || input3 < -(BigInt(2) ** BigInt(32))) {
+        let received = input2;
+        if (Number.isInteger(input2) && Math.abs(input2) > 2 ** 32) {
+          received = addNumericalSeparator(String(input2));
+        } else if (typeof input2 === "bigint") {
+          received = String(input2);
+          if (input2 > BigInt(2) ** BigInt(32) || input2 < -(BigInt(2) ** BigInt(32))) {
             received = addNumericalSeparator(received);
           }
           received += "n";
@@ -1826,13 +1826,6 @@ var init_platform = __esm({
   }
 });
 
-// packages/safe-bash/src/commands/xml/index.ts
-init_platform();
-import { parseXmlSteps, XmlLimitError } from "@poe-platform/safe-fs/core";
-
-// packages/safe-bash/src/contracts/command.ts
-init_platform();
-
 // packages/safe-bash/src/contracts/value.ts
 init_platform();
 var byteValues = /* @__PURE__ */ new WeakMap();
@@ -2020,6 +2013,7 @@ function encodeValues(values, output2) {
 }
 
 // packages/safe-bash/src/contracts/command.ts
+init_platform();
 var argumentCarriers = /* @__PURE__ */ new WeakSet();
 var CommandArgumentIdentityError = class extends TypeError {
   constructor() {
@@ -2184,17 +2178,17 @@ var CommandRegistry = class {
     for (const command of commands) this.register(command);
   }
   register(command, options2 = {}) {
-    const { name, execute: execute2 } = command;
+    const { name, execute } = command;
     if (typeof name !== "string" || !name || /[\s/\0]/u.test(name)) {
       throw new TypeError("Command names must be nonempty and contain no whitespace, slash, or NUL");
     }
-    if (typeof execute2 !== "function") {
+    if (typeof execute !== "function") {
       throw new TypeError("Command execute must be a function");
     }
     if (this.#commands.has(name) && !options2.replace) {
       throw new Error(`Command already registered: ${name}`);
     }
-    this.#commands.set(name, Object.freeze({ ...command, name, execute: execute2 }));
+    this.#commands.set(name, Object.freeze({ ...command, name, execute }));
     return this;
   }
   get(name) {
@@ -2217,14 +2211,12 @@ function validateExitCode(exitCode) {
   return exitCode;
 }
 
-// packages/safe-bash/src/contracts/command-requirements.ts
-init_platform();
-
 // packages/safe-bash/src/contracts/errors.ts
 init_platform();
 import { isErrnoCode, isFsError, toFsError, FsError } from "@poe-platform/safe-fs/core";
 
 // packages/safe-bash/src/contracts/command-requirements.ts
+init_platform();
 function evaluateMode(requirement, capabilities) {
   const missing = requirement.capabilities.filter((name) => capabilities[name] === false);
   const unknown = requirement.capabilities.filter((name) => capabilities[name] === void 0);
@@ -2420,12 +2412,12 @@ async function abortable(operation, signal) {
   });
 }
 
-// packages/safe-bash/src/contracts/path.ts
+// packages/safe-bash/src/escaping.ts
 init_platform();
-import { validatePath, resolvePath, normalizePath, relativePath, isPathWithin, assertPathWithin, basename, dirname, extname, joinPath, isAbsolutePath, posixPath as posixPath2 } from "@poe-platform/safe-fs/core";
 
-// packages/safe-bash/src/escaping.ts
+// packages/safe-bash/src/contracts/path.ts
 init_platform();
+import { validatePath, resolvePath, normalizePath, relativePath, isPathWithin, assertPathWithin, basename, dirname, extname, joinPath, isAbsolutePath, posixPath as posixPath2 } from "@poe-platform/safe-fs/core";
 
 // packages/safe-bash/src/contracts/yield.ts
 init_platform();
@@ -3212,501 +3204,6 @@ async function interruptible(operation, signal) {
   });
 }
 
-// packages/safe-bash/src/commands/xml/limits.ts
-init_platform();
-var defaultXmlQueryLimits = Object.freeze({
-  maxInputBytes: 8 * 1024 * 1024,
-  maxOutputBytes: 8 * 1024 * 1024,
-  maxSourceBytes: 64 * 1024,
-  maxDepth: 64,
-  maxNodes: 1e5,
-  maxAttributes: 1e4,
-  maxAttributesPerElement: 128,
-  maxNamespaces: 256,
-  maxSteps: 1e6,
-  maxResults: 1e5
-});
-var XmlQueryError = class extends Error {
-  constructor(message, status) {
-    super(message);
-    this.status = status;
-  }
-  status;
-};
-var XmlQueryLimitError = class extends XmlQueryError {
-  constructor(name) {
-    super(`${name} limit exceeded`, 5);
-  }
-};
-function resolveXmlQueryLimits(options2 = {}) {
-  const limits = { ...defaultXmlQueryLimits, ...options2 };
-  for (const [name, value2] of Object.entries(limits)) {
-    if (!Object.hasOwn(defaultXmlQueryLimits, name) || !Number.isSafeInteger(value2) || value2 < 1) {
-      throw new RangeError(`${name} must be a positive safe integer XML limit`);
-    }
-  }
-  if (limits.maxDepth > 256) throw new RangeError("maxDepth must be <=256");
-  return Object.freeze(limits);
-}
-var XmlBudget = class {
-  constructor(limits, signal) {
-    this.limits = limits;
-    this.signal = signal;
-  }
-  limits;
-  signal;
-  steps = 0;
-  checkpoint = 0;
-  outputBytes = 0;
-  async tick(work = 1) {
-    this.signal.throwIfAborted();
-    this.steps += work;
-    if (this.steps > this.limits.maxSteps) throw new XmlQueryLimitError("maxSteps");
-    this.checkpoint += work;
-    if (this.checkpoint >= 1024) {
-      this.checkpoint = 0;
-      await yieldTurn(this.signal);
-    }
-  }
-  results(size) {
-    if (size > this.limits.maxResults) throw new XmlQueryLimitError("maxResults");
-  }
-};
-
-// packages/safe-bash/src/commands/xml/query.ts
-init_platform();
-var nameStart = (character) => character >= "a" && character <= "z" || character >= "A" && character <= "Z" || character === "_";
-var namePart = (character) => nameStart(character) || character >= "0" && character <= "9" || character === "-" || character === ".";
-async function parseQuery(source, budget) {
-  if (source.length > budget.limits.maxSourceBytes || import_buffer.Buffer.byteLength(source) > budget.limits.maxSourceBytes) throw new XmlQueryLimitError("maxSourceBytes");
-  for (let offset = 0; offset < source.length; offset += 256) await budget.tick(Math.min(256, source.length - offset));
-  let at = 0;
-  const fail = () => {
-    throw new XmlQueryError(`unsupported XPath syntax at offset ${at}`, 10);
-  };
-  const space = () => {
-    while (source[at] === " " || source[at] === "	" || source[at] === "\r" || source[at] === "\n") at++;
-  };
-  const expect = (value2) => {
-    space();
-    if (!source.startsWith(value2, at)) fail();
-    at += value2.length;
-  };
-  const name = () => {
-    space();
-    const start = at;
-    if (!nameStart(source[at] ?? "")) fail();
-    while (namePart(source[at] ?? "")) at++;
-    if (source[at] === ":") fail();
-    return source.slice(start, at);
-  };
-  space();
-  let scalar;
-  if (source[at] !== "/") {
-    const value2 = name();
-    if (value2 !== "string" && value2 !== "count" && value2 !== "boolean") fail();
-    scalar = value2;
-    expect("(");
-  }
-  const steps = [];
-  space();
-  while (source[at] === "/") {
-    at++;
-    const descendant = source[at] === "/";
-    if (descendant) at++;
-    space();
-    let kind = "element";
-    if (source[at] === "@") {
-      kind = "attribute";
-      at++;
-    }
-    let selected;
-    if (source[at] === "*") {
-      selected = "*";
-      at++;
-    } else {
-      selected = name();
-      space();
-      if (source[at] === "(") {
-        if (selected !== "text" || kind !== "element") fail();
-        expect("(");
-        expect(")");
-        kind = "text";
-      }
-    }
-    const predicates = [];
-    space();
-    while (source[at] === "[") {
-      at++;
-      space();
-      if (source[at] === "@") {
-        at++;
-        const attribute = name();
-        expect("=");
-        space();
-        const quote = source[at++];
-        if (quote !== "'" && quote !== '"') fail();
-        const start = at;
-        while (at < source.length && source[at] !== quote) at++;
-        if (at === source.length) fail();
-        predicates.push({ kind: "attribute", name: attribute, value: source.slice(start, at++) });
-      } else {
-        const start = at;
-        while ((source[at] ?? "") >= "0" && (source[at] ?? "") <= "9") at++;
-        const value2 = Number(source.slice(start, at));
-        if (start === at || !Number.isSafeInteger(value2) || value2 < 1) fail();
-        predicates.push({ kind: "position", value: value2 });
-      }
-      expect("]");
-      space();
-    }
-    steps.push({ descendant, kind, name: selected, predicates });
-    if (kind !== "element" && source[at] === "/") fail();
-    await budget.tick();
-  }
-  if (!steps.length) fail();
-  if (scalar !== void 0) expect(")");
-  space();
-  if (at !== source.length) fail();
-  return { scalar, steps };
-}
-
-// packages/safe-bash/src/commands/xml/evaluate.ts
-init_platform();
-var xmlns = "http://www.w3.org/2000/xmlns/";
-async function indexTree(root, budget) {
-  const document = { kind: "document", children: [] };
-  const order = [document];
-  const pending = [{ parent: document, content: root }];
-  while (pending.length) {
-    await budget.tick();
-    const { parent, content } = pending.pop();
-    if (content.kind === "element") {
-      const node = { kind: "element", value: content, children: [], attributes: [] };
-      parent.children.push(node);
-      order.push(node);
-      for (const attribute of content.attributes) {
-        await budget.tick();
-        if (attribute.namespace === xmlns) continue;
-        const selected = { kind: "attribute", value: attribute };
-        node.attributes.push(selected);
-        order.push(selected);
-      }
-      for (let index = content.content.length - 1; index >= 0; index--) {
-        await budget.tick();
-        pending.push({ parent: node, content: content.content[index] });
-      }
-    } else {
-      const node = { kind: content.kind, value: content };
-      parent.children.push(node);
-      order.push(node);
-    }
-  }
-  return { document, order };
-}
-function matches(node, step) {
-  if (step.kind === "text") return node.kind === "text" || node.kind === "cdata";
-  if (node.kind !== step.kind) return false;
-  if (node.kind === "element" || node.kind === "attribute") {
-    return step.name === "*" || node.value.namespace === "" && node.value.localName === step.name;
-  }
-  return false;
-}
-async function evaluate(query, root, budget) {
-  const { document, order } = await indexTree(root, budget);
-  let contexts = [document];
-  for (const step of query.steps) {
-    const parents = /* @__PURE__ */ new Set();
-    const pending = [...contexts];
-    while (pending.length) {
-      await budget.tick();
-      const node = pending.pop();
-      if (parents.has(node)) continue;
-      parents.add(node);
-      if (step.descendant && (node.kind === "document" || node.kind === "element")) {
-        for (const child of node.children) {
-          await budget.tick();
-          pending.push(child);
-        }
-      }
-    }
-    const selected = /* @__PURE__ */ new Set();
-    for (const parent of parents) {
-      await budget.tick();
-      const candidates = step.kind === "attribute" ? parent.kind === "element" ? parent.attributes : [] : parent.kind === "element" || parent.kind === "document" ? parent.children : [];
-      let matched = [];
-      for (const candidate of candidates) {
-        await budget.tick();
-        if (matches(candidate, step)) matched.push(candidate);
-      }
-      for (const predicate of step.predicates) {
-        await budget.tick();
-        if (predicate.kind === "position") matched = matched[predicate.value - 1] ? [matched[predicate.value - 1]] : [];
-        else {
-          const filtered = [];
-          for (const candidate of matched) {
-            await budget.tick();
-            if (candidate.kind !== "element") continue;
-            for (const attribute of candidate.attributes) {
-              await budget.tick(attribute.value.value.length + 1);
-              if (attribute.value.namespace === "" && attribute.value.localName === predicate.name && attribute.value.value === predicate.value) {
-                filtered.push(candidate);
-                break;
-              }
-            }
-          }
-          matched = filtered;
-        }
-      }
-      for (const node of matched) {
-        await budget.tick();
-        if (!selected.has(node)) {
-          budget.results(selected.size + 1);
-          selected.add(node);
-        }
-      }
-    }
-    contexts = [];
-    for (const node of order) {
-      await budget.tick();
-      if (selected.has(node)) contexts.push(node);
-    }
-  }
-  return contexts;
-}
-async function* stringValue(node, budget) {
-  if (node === void 0) return;
-  if (node.kind === "attribute") {
-    yield node.value.value;
-    return;
-  }
-  const pending = [node];
-  while (pending.length) {
-    await budget.tick();
-    const current = pending.pop();
-    if (current.kind === "element" || current.kind === "document") {
-      for (let index = current.children.length - 1; index >= 0; index--) {
-        await budget.tick();
-        pending.push(current.children[index]);
-      }
-    } else if (current.kind === "text" || current.kind === "cdata") yield current.value.text;
-  }
-}
-async function* serialize(node, budget) {
-  if (node.kind === "attribute") {
-    yield ` ${node.value.name}="`;
-    yield* escape(node.value.value, true, budget);
-    yield '"';
-    return;
-  }
-  if (node.kind === "document") return;
-  const pending = [node.value];
-  while (pending.length) {
-    await budget.tick();
-    const current = pending.pop();
-    if (typeof current === "string") {
-      yield current;
-      continue;
-    }
-    if (current.kind === "element") {
-      yield `<${current.name}`;
-      for (const attribute of current.attributes) {
-        await budget.tick();
-        yield ` ${attribute.name}="`;
-        yield* escape(attribute.value, true, budget);
-        yield '"';
-      }
-      if (!current.content.length) yield "/>";
-      else {
-        yield ">";
-        pending.push(`</${current.name}>`);
-        for (let index = current.content.length - 1; index >= 0; index--) {
-          await budget.tick();
-          pending.push(current.content[index]);
-        }
-      }
-    } else if (current.kind === "text") yield* escape(current.text, false, budget);
-    else if (current.kind === "cdata") {
-      yield "<![CDATA[";
-      yield current.text;
-      yield "]]>";
-    } else if (current.kind === "comment") {
-      yield "<!--";
-      yield current.text;
-      yield "-->";
-    } else if (current.kind === "processing-instruction") {
-      yield `<?${current.target}`;
-      if (current.text) {
-        yield " ";
-        yield current.text;
-      }
-      yield "?>";
-    }
-  }
-}
-async function* escape(value2, attribute, budget) {
-  let part = "";
-  for (const character of value2) {
-    await budget.tick();
-    part += character === "&" ? "&amp;" : character === "<" ? "&lt;" : character === ">" ? "&gt;" : attribute && character === '"' ? "&quot;" : attribute && character === "\n" ? "&#10;" : character === "\r" ? "&#13;" : attribute && character === "	" ? "&#9;" : character;
-    if (part.length >= 4096) {
-      yield part;
-      part = "";
-    }
-  }
-  if (part) yield part;
-}
-
-// packages/safe-bash/src/commands/xml/index.ts
-async function argumentsFor(context, budget) {
-  if (context.args.length > 5) throw new XmlQueryError("expected one XML input FILE or -", 2);
-  const carrier = getCommandArguments(context);
-  const args = carrier.args;
-  async function admitted(position, limit) {
-    const text = args[position];
-    if (text.length > budget.limits[limit]) throw new XmlQueryLimitError(limit);
-    const size = shellValueByteLength(carrier.values[position]);
-    if (size > budget.limits[limit]) throw new XmlQueryLimitError(limit);
-    for (let offset = 0; offset < size; offset += 1024) await budget.tick(Math.min(1024, size - offset));
-    let decoded;
-    try {
-      decoded = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(carrier.bytes(position));
-    } catch {
-      throw new XmlQueryError("XPath and filenames require valid UTF-8", 2);
-    }
-    if (decoded !== text) throw new XmlQueryError("XPath and filenames require lossless UTF-8", 2);
-    return decoded;
-  }
-  let index = 0;
-  if (context.command === "xmllint") {
-    if (args[index++] !== "--xpath") throw new XmlQueryError("expected --xpath QUERY [FILE|-]", 2);
-  }
-  if (args[index] === "--") index++;
-  const sourceIndex = index++;
-  const source = args[sourceIndex];
-  if (source === void 0 || source.startsWith("-")) throw new XmlQueryError("expected QUERY [FILE|-]", 2);
-  if (args[index] === "--") index++;
-  const fileIndex = index++;
-  const file = args[fileIndex];
-  if (index < args.length || file !== void 0 && file.startsWith("-") && file !== "-") throw new XmlQueryError("expected one XML input FILE or -", 2);
-  const query = await parseQuery(await admitted(sourceIndex, "maxSourceBytes"), budget);
-  return { query, file: file === void 0 ? void 0 : await admitted(fileIndex, "maxInputBytes") };
-}
-async function input2(context, file, budget) {
-  let source = context.stdin;
-  if (file !== void 0 && file !== "-") {
-    const path = pathOf(context, file);
-    const capabilities = context.fs.capabilitiesFor ? await interruptible(() => context.fs.capabilitiesFor(path, { signal: context.signal }), context.signal) : context.fs.capabilities;
-    context.signal.throwIfAborted();
-    if (context.fs.readStream && capabilities.streamingRead !== false) source = context.fs.readStream(path, { signal: context.signal });
-    else {
-      try {
-        source = toByteSource(await interruptible(() => context.fs.readFile(path, { signal: context.signal, maxBytes: budget.limits.maxInputBytes }), context.signal));
-      } catch (error) {
-        context.signal.throwIfAborted();
-        if (error instanceof FsError && error.code === "EFBIG") throw new XmlQueryLimitError("maxInputBytes");
-        throw error;
-      }
-    }
-  }
-  const parts2 = [];
-  let size = 0;
-  const decoder3 = new TextDecoder("utf-8", { fatal: true });
-  for await (const chunk of readBytes2(source, context.signal)) {
-    await budget.tick();
-    size += chunk.byteLength;
-    if (size > budget.limits.maxInputBytes) throw new XmlQueryLimitError("maxInputBytes");
-    for (let offset = 0; offset < chunk.length; offset += 4096) {
-      await budget.tick(Math.min(4096, chunk.length - offset));
-      try {
-        parts2.push(decoder3.decode(chunk.subarray(offset, offset + 4096), { stream: true }));
-      } catch {
-        throw new XmlQueryError("XML input must be UTF-8", 1);
-      }
-    }
-  }
-  try {
-    parts2.push(decoder3.decode());
-  } catch {
-    throw new XmlQueryError("XML input must be UTF-8", 1);
-  }
-  return parts2.join("");
-}
-async function execute(context, limits) {
-  const budget = new XmlBudget(limits, context.signal);
-  let outputFailed = false;
-  try {
-    const options2 = await argumentsFor(context, budget);
-    const source = await input2(context, options2.file, budget);
-    const parser = parseXmlSteps(source, { ...limits, maxContentNodes: limits.maxNodes, expectedEncoding: "UTF-8" });
-    let parsed = parser.next();
-    try {
-      while (!parsed.done) {
-        await budget.tick(parsed.value);
-        parsed = parser.next();
-      }
-    } finally {
-      if (!parsed.done) parser.return(void 0);
-    }
-    const nodes = await evaluate(options2.query, parsed.value, budget);
-    async function write(part) {
-      for (let offset = 0; offset < part.length; ) {
-        let end = Math.min(offset + 4096, part.length);
-        if (end < part.length && part.charCodeAt(end - 1) >= 55296 && part.charCodeAt(end - 1) <= 56319) end--;
-        await budget.tick(end - offset);
-        const slice = part.slice(offset, end);
-        const size = import_buffer.Buffer.byteLength(slice);
-        if (size > limits.maxOutputBytes - budget.outputBytes) throw new XmlQueryLimitError("maxOutputBytes");
-        budget.outputBytes += size;
-        try {
-          await writeBytes(context.stdout, import_buffer.Buffer.from(slice), context.signal);
-        } catch (error) {
-          outputFailed = true;
-          throw error;
-        }
-        offset = end;
-      }
-    }
-    if (options2.query.scalar === "count") await write(String(nodes.length));
-    else if (options2.query.scalar === "boolean") await write(nodes.length ? "true" : "false");
-    else if (options2.query.scalar === "string") {
-      for await (const part of stringValue(nodes[0], budget)) await write(part);
-    } else {
-      if (!nodes.length) throw new XmlQueryError("XPath set is empty", 11);
-      for (const node of nodes) {
-        for await (const part of serialize(node, budget)) await write(part);
-        await write("\n");
-      }
-      return { exitCode: 0 };
-    }
-    await write("\n");
-    return { exitCode: 0 };
-  } catch (error) {
-    context.signal.throwIfAborted();
-    if (outputFailed || error instanceof FsError && error.code === "EPIPE") throw error;
-    const status = error instanceof XmlQueryError ? error.status : error instanceof XmlLimitError ? 5 : error instanceof SyntaxError || error instanceof FsError ? 1 : void 0;
-    if (status === void 0) throw error;
-    const message = error instanceof Error ? error.message.slice(0, 1e3) : "XML query failed";
-    await writeDiagnostic(context.stderr, `${context.command}: ${message}
-`, context.signal);
-    return { exitCode: status };
-  }
-}
-function createXmlCommands(options2 = {}) {
-  const limits = resolveXmlQueryLimits(options2.limits);
-  return ["xq", "xmllint"].map((name) => ({ name, execute: (context) => execute(context, limits) }));
-}
-function xmlCommands(options2 = {}) {
-  const definitions = createXmlCommands(options2);
-  const replace = options2.replace ?? false;
-  return { name: "xml-commands", setup(host) {
-    if (!replace) for (const definition of definitions) {
-      if (host.commands.has(definition.name)) throw new Error(`Command already registered: ${definition.name}`);
-    }
-    for (const definition of definitions) host.commands.register(definition, { replace });
-  } };
-}
-
 export {
   import_buffer,
   init_platform,
@@ -3779,11 +3276,13 @@ export {
   emptyInput,
   replaceArgument,
   escapeBytes,
+  Decimal,
   isNumber,
   numberValue,
   numericToken,
   decimalNumber,
   compareNumbers,
+  numberText,
   defaultJqLimits,
   JqError,
   JqLimitError,
@@ -3800,10 +3299,7 @@ export {
   isObject,
   truth,
   scalarJson,
-  interruptible,
-  defaultXmlQueryLimits,
-  createXmlCommands,
-  xmlCommands
+  interruptible
 };
 /*! Bundled license information:
 
@@ -3818,4 +3314,4 @@ buffer/index.js:
    * @license  MIT
    *)
 */
-//# sourceMappingURL=chunk-3ISDVRIM.js.map
+//# sourceMappingURL=chunk-B637PJBS.js.map