@poe-platform/safe-bash 0.1.802 → 0.1.804

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

@@ -8,6 +8,17 @@ init_buffer();
 
 // packages/safe-bash-command-htmlq/src/contracts.ts
 init_buffer();
+var defaultHtmlLimits = Object.freeze({
+  inputBytes: Infinity,
+  decodedBytes: Infinity,
+  retainedBytes: Infinity,
+  nodes: Infinity,
+  attributes: Infinity,
+  depth: Infinity,
+  tokenBytes: Infinity,
+  work: Infinity,
+  outputBytes: Infinity
+});
 var HtmlError = class extends Error {
   constructor(code, message, offset = 0, resource) {
     super(message);
@@ -26,51 +37,45 @@ var htmlqBaseline = Object.freeze({
   scripting: true,
   fullHtml5Parity: false
 });
-function createLedger(signal) {
-  const aborted = Boolean(signal?.aborted);
-  const pollSignal = Boolean(signal && (typeof signal.addEventListener !== "function" || Object.prototype.hasOwnProperty.call(signal, "aborted")));
+function createLedger() {
   const ledger = {
     counts: { inputBytes: 0, decodedBytes: 0, retainedBytes: 0, nodes: 0, attributes: 0, depth: 0, tokenBytes: 0, work: 0, outputBytes: 0 },
-    peaks: { inputBytes: 0, decodedBytes: 0, retainedBytes: 0, nodes: 0, attributes: 0, depth: 0, tokenBytes: 0, work: 0, outputBytes: 0 },
-    aborted,
-    pollSignal
+    peaks: { inputBytes: 0, decodedBytes: 0, retainedBytes: 0, nodes: 0, attributes: 0, depth: 0, tokenBytes: 0, work: 0, outputBytes: 0 }
   };
-  if (signal && !aborted && !pollSignal) {
-    signal.addEventListener("abort", () => {
-      ledger.aborted = true;
-    }, { once: true });
-  }
   return ledger;
 }
 var invocationCounts = /* @__PURE__ */ new WeakMap();
 function invocationOptions(options) {
-  const owned = { signal: options.signal, limits: { ...options.limits } };
-  invocationCounts.set(owned, createLedger(options.signal));
+  const owned = { signal: options.signal, limits: { ...defaultHtmlLimits, ...options.limits } };
+  for (const name of Object.keys(defaultHtmlLimits)) {
+    if (owned.limits[name] === void 0) owned.limits[name] = defaultHtmlLimits[name];
+  }
+  invocationCounts.set(owned, createLedger());
   return owned;
 }
 var HtmlBudget = class {
   constructor(options) {
     this.options = options;
     let ledger = invocationCounts.get(options);
+    this.limits = { ...defaultHtmlLimits, ...options.limits };
+    for (const name of [
+      "inputBytes",
+      "decodedBytes",
+      "retainedBytes",
+      "nodes",
+      "attributes",
+      "depth",
+      "tokenBytes",
+      "work",
+      "outputBytes"
+    ]) {
+      if (this.limits[name] === void 0) this.limits[name] = defaultHtmlLimits[name];
+      if (this.limits[name] !== Infinity && (!Number.isSafeInteger(this.limits[name]) || this.limits[name] < 0))
+        throw new HtmlError("E_LIMIT", "Expected nonnegative safe integer limits or Infinity", 0, name);
+    }
     if (!ledger) {
-      this.limits = { ...options.limits };
-      for (const name of [
-        "inputBytes",
-        "decodedBytes",
-        "retainedBytes",
-        "nodes",
-        "attributes",
-        "depth",
-        "tokenBytes",
-        "work",
-        "outputBytes"
-      ])
-        if (this.limits[name] !== Infinity && (!Number.isSafeInteger(this.limits[name]) || this.limits[name] < 0))
-          throw new HtmlError("E_LIMIT", "Expected nonnegative safe integer limits or Infinity", 0, name);
-      ledger = createLedger(options.signal);
+      ledger = createLedger();
       invocationCounts.set(options, ledger);
-    } else {
-      this.limits = options.limits;
     }
     this.ledger = ledger;
     this.check();
@@ -79,7 +84,7 @@ var HtmlBudget = class {
   limits;
   ledger;
   check() {
-    if (this.ledger.aborted || this.ledger.pollSignal && this.options.signal.aborted)
+    if (this.options.signal.aborted)
       throw new HtmlError("E_CANCELLED", "HTML invocation cancelled");
   }
   bound(resource, amount) {
@@ -2018,7 +2023,7 @@ function parseHtmlqArguments(argv, options) {
     attributes: [],
     removeNodes: []
   };
-  const selectors = [];
+  let positional = false;
   let literal = false;
   const seen = /* @__PURE__ */ new Set();
   for (let i = 0; i < argv.length && !result.help && !result.version; i++) {
@@ -2093,10 +2098,17 @@ function parseHtmlqArguments(argv, options) {
         if (!short || result.help || result.version) break;
       }
     } else {
-      selectors.push(arg);
+      if (!positional) {
+        result.selector = arg;
+        positional = true;
+      } else if (!seen.has("filename")) {
+        result.filename = arg;
+        seen.add("filename");
+      } else {
+        throw new HtmlError("E_ARGUMENT", "Only one selector and input file are accepted");
+      }
     }
   }
-  if (selectors.length) result.selector = selectors.join(",");
   budget.charge("retainedBytes", result.selector.length * 2);
   budget.charge("work", result.selector.length);
   return Object.freeze({
@@ -2114,10 +2126,11 @@ import { yieldTurn } from "../safe-bash-contracts/yield.js";
 init_buffer();
 var help = `Like jq, but for HTML.
 
-Usage: htmlq [OPTIONS] [SELECTOR]...
+Usage: htmlq [OPTIONS] [SELECTOR] [FILE]
 
 Arguments:
-  [SELECTOR]...  CSS selectors to combine in document order [default: html]
+  [SELECTOR]     CSS selector, including comma-separated unions [default: html]
+  [FILE]         VFS input path (alternative to --filename) [default: -]
 
 Options:
   -f, --filename <INPUT_PATH>        Where to read HTML input from [default: -]
@@ -2330,20 +2343,10 @@ import { FsError } from "../safe-bash-contracts/errors.js";
 import { writeBytes } from "../safe-bash-contracts/io.js";
 import { createOutputOperation } from "../safe-bash-contracts/output.js";
 import { shellValueByteLength } from "../safe-bash-contracts/value.js";
-var defaultLimits = Object.freeze({
-  inputBytes: Infinity,
-  decodedBytes: Infinity,
-  retainedBytes: Infinity,
-  nodes: Infinity,
-  attributes: Infinity,
-  depth: Infinity,
-  tokenBytes: Infinity,
-  work: Infinity,
-  outputBytes: Infinity
-});
 function admittedLimits(overrides = {}) {
-  const limits = { ...defaultLimits, ...overrides };
-  for (const name of Object.keys(defaultLimits)) {
+  const limits = { ...defaultHtmlLimits, ...overrides };
+  for (const name of Object.keys(defaultHtmlLimits)) {
+    if (limits[name] === void 0) limits[name] = defaultHtmlLimits[name];
     const value = limits[name];
     if (value !== Infinity && (!Number.isSafeInteger(value) || value < 0))
       throw new HtmlError("E_LIMIT", "Limits must be nonnegative safe integers or Infinity", 0, name);
@@ -2679,12 +2682,135 @@ function htmlqCommands(options = {}) {
 function createHtmlqCommands(options = {}) {
   return Object.freeze([createHtmlqCommand(options)]);
 }
+
+// packages/safe-bash-command-htmlq/src/sync.ts
+init_buffer();
+var _syncAbortSignal;
+var syncAbortSignal = () => _syncAbortSignal ??= new AbortController().signal;
+var syncHtmlDecoder = new TextDecoder("utf-8", { fatal: false, ignoreBOM: true });
+var syncHtmlEncoder = new TextEncoder();
+var syncHtmlLimits = Object.freeze({
+  inputBytes: Infinity,
+  decodedBytes: Infinity,
+  retainedBytes: Infinity,
+  nodes: Infinity,
+  attributes: Infinity,
+  depth: Infinity,
+  tokenBytes: Infinity,
+  work: Infinity,
+  outputBytes: Infinity
+});
+function evalSyncHtmlq(inBytes, opArgs, readFileSync, writeFileSync) {
+  if (inBytes && inBytes.byteLength > 16384) return void 0;
+  try {
+    const invocation = invocationOptions({ signal: syncAbortSignal(), limits: syncHtmlLimits });
+    const args = parseHtmlqArguments(opArgs, invocation);
+    if (args.help || args.version) return void 0;
+    let srcBytes = inBytes;
+    if (args.filename !== "-") {
+      if (!readFileSync) return void 0;
+      const fBytes = readFileSync(args.filename);
+      if (!fBytes || fBytes.byteLength > 16384) return void 0;
+      srcBytes = fBytes;
+    }
+    if (!srcBytes) return void 0;
+    const budget = new HtmlBudget(invocation);
+    const original = syncHtmlDecoder.decode(srcBytes);
+    const document = parseHtmlSync(original, invocation, budget);
+    let base;
+    if (args.base) {
+      try {
+        base = new URL(args.base);
+      } catch {
+        base = void 0;
+      }
+    }
+    if (args.detectBase) {
+      const first = selectHtml(document, "base", invocation).next().value;
+      const href = first?.attributes.find((a) => a.name === "href")?.value ?? "";
+      if (href) {
+        try {
+          base = new URL(href);
+        } catch {
+        }
+      }
+    }
+    const selected = selectHtml(document, args.selector, invocation);
+    let removal = "";
+    if (args.removeNodes.length) {
+      removal = args.removeNodes.join(",");
+      try {
+        selectHtml(document, removal, invocation);
+      } catch (error) {
+        if (!(error instanceof HtmlError) || error.code !== "E_SELECTOR") throw error;
+        removal = "";
+      }
+    }
+    let out = "";
+    let selectedIndex = 0;
+    for (const node of selected) {
+      const isFirstNode = selectedIndex++ === 0;
+      if (removal) {
+        const first = selectHtml(node, removal, invocation).next().value;
+        if (first) detachHtmlNode(first, invocation);
+      }
+      if (base && node.namespace === "html" && ["a", "area", "link"].includes(node.name)) {
+        const href = node.attributes.find((a) => a.namespace === "none" && a.name === "href")?.value;
+        if (href !== void 0) {
+          let value;
+          if (href.startsWith("////")) {
+            let i = 0;
+            while (href[i] === "/") i++;
+            value = href.slice(i);
+          } else {
+            try {
+              value = new URL(href, base).href;
+            } catch {
+              value = base.href;
+            }
+          }
+          replaceHtmlAttribute(node, "href", value, invocation);
+        }
+      }
+      if (args.attributes.length) {
+        for (const name of args.attributes) {
+          const attribute2 = node.attributes.find((a) => a.namespace === "none" && a.name === name);
+          if (attribute2) out += attribute2.value + "\n";
+        }
+      } else if (args.text) {
+        const internal = !args.ignoreWhitespace && !isFirstNode ? getInternalHtmlNode(node) : void 0;
+        if (internal && internal.children.length === 1 && internal.children[0].kind === "text" && internal.children[0].children.length === 0) {
+          out += internal.children[0].data + "\n";
+        } else {
+          for (const descendant of inclusiveHtmlDescendants(node, invocation)) {
+            if (descendant.kind !== "text") continue;
+            if (args.ignoreWhitespace && rustWhitespaceOnly(descendant.data)) continue;
+            out += descendant.data;
+            if (args.ignoreWhitespace) out += "\n";
+          }
+          out += "\n";
+        }
+      } else {
+        out += serializeHtml(node, invocation, args.pretty ? "pretty" : "normalized") + "\n";
+      }
+    }
+    if (args.output !== "-") {
+      if (!writeFileSync || !writeFileSync(args.output, syncHtmlEncoder.encode(out))) return void 0;
+      return "";
+    }
+    return out;
+  } catch {
+    return void 0;
+  }
+}
 export {
   HtmlBudget,
   HtmlError,
   createHtmlqCommand,
   createHtmlqCommands,
+  defaultHtmlLimits,
   detachHtmlNode,
+  evalSyncHtmlq,
   getInternalHtmlNode,
   htmlText,
   htmlq,

package/dist/safe-bash-command-htmlq/sync.d.ts

@@ -0,0 +1 @@
+export declare function evalSyncHtmlq(inBytes: Uint8Array | undefined, opArgs: readonly string[], readFileSync?: (filePath: string) => Uint8Array | undefined, writeFileSync?: (filePath: string, bytes: Uint8Array) => boolean): string | undefined;

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

@@ -1,4 +1,4 @@
-import "../safe-bash/command-chunks/chunk-AJR3AQYA.js";
+import "../safe-bash/command-chunks/chunk-UKX3LZHR.js";
 import {
   applyExifOrientationSteps,
   blurImageSteps,
@@ -28,13 +28,14 @@ import {
   thresholdImageSteps,
   tintImageSteps,
   trimImageSteps
-} from "../safe-bash/command-chunks/chunk-YG4EPFWC.js";
+} from "../safe-bash/command-chunks/chunk-M3NINRDU.js";
 import {
   init_buffer
 } from "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
 
 // packages/safe-bash-command-imagemagick/src/index.ts
 init_buffer();
+import { FsError } from "../safe-bash-contracts/errors.js";
 import { resolvePath } from "../safe-bash-contracts/path.js";
 import { yieldTurn, drainCooperativeSteps as drainSteps } from "../safe-bash-contracts/yield.js";
 import { InputByteBudget } from "../safe-bash-contracts/io.js";
@@ -3052,7 +3053,49 @@ function* applyInlineReadModifierSteps(img, inlineGeom, kernel) {
   }
   return yield* applyMagickResizeSteps(img, inlineGeom, kernel);
 }
-function* parseInputOperandsSteps(token, files, state, stdinBytes) {
+function inferMaxDecodeDimensionFromUpcomingTokens(tokens, startIdx, inlineGeom) {
+  if (inlineGeom) {
+    const g = parseMagickGeometry(inlineGeom);
+    if (!g.hasOffset && !g.isPercent && g.areaLimit === void 0 && (g.width !== void 0 || g.height !== void 0)) {
+      const dim = Math.max(g.width ?? 0, g.height ?? 0);
+      if (dim >= 32) return dim;
+    }
+  }
+  const coordDependentOps = /* @__PURE__ */ new Set([
+    "-crop",
+    "-chop",
+    "-splice",
+    "-trim",
+    "-roll",
+    "-shave",
+    "-extent",
+    "-border",
+    "-frame",
+    "-draw",
+    "-annotate",
+    "-region",
+    "-floodfill",
+    "-repage",
+    "+repage",
+    "-distort"
+  ]);
+  for (let k = startIdx; k < tokens.length; k++) {
+    const tok = tokens[k];
+    if (coordDependentOps.has(tok)) return void 0;
+    if (tok === "-resize" || tok === "-thumbnail" || tok === "-scale" || tok === "-sample") {
+      const geomStr = tokens[k + 1];
+      if (!geomStr) return void 0;
+      const g = parseMagickGeometry(geomStr);
+      if (!g.hasOffset && !g.isPercent && g.areaLimit === void 0 && (g.width !== void 0 || g.height !== void 0)) {
+        const dim = Math.max(g.width ?? 0, g.height ?? 0);
+        if (dim >= 32) return dim;
+      }
+      return void 0;
+    }
+  }
+  return void 0;
+}
+function* parseInputOperandsSteps(token, files, state, stdinBytes, maxDecodeDimension) {
   let work = 0;
   let baseToken = token;
   let pageSpec;
@@ -3163,12 +3206,14 @@ function* parseInputOperandsSteps(token, files, state, stdinBytes) {
   } else {
     pageIndices = [0];
   }
+  const effectiveMaxDecodeDim = inferMaxDecodeDimensionFromUpcomingTokens([], 0, inlineGeom) ?? maxDecodeDimension;
   const results = [];
   for (const pageIdx of pageIndices) {
     if (++work % 16384 === 0)
       yield;
     let img = decodeImage(rawBytes, {
       density: state.density,
+      ...effectiveMaxDecodeDim !== void 0 ? { maxDecodeDimension: effectiveMaxDecodeDim } : {},
       ...totalPages > 1 || pageSpec !== void 0 ? { page: pageIdx } : {}
     });
     if (inlineGeom) {
@@ -4271,7 +4316,8 @@ function* evaluatePipelineTokensSteps(tokens, files, state, parentStack = [], st
         stack = [composed, ...stack.slice(2)];
       }
     } else {
-      const loaded = yield* parseInputOperandsSteps(t, files, state, stdinBytes);
+      const maxDecodeDim = inferMaxDecodeDimensionFromUpcomingTokens(tokens, i + 1);
+      const loaded = yield* parseInputOperandsSteps(t, files, state, stdinBytes, maxDecodeDim);
       if (loaded) {
         stack.push(...loaded);
       }
@@ -5089,7 +5135,8 @@ async function executeVfsMagickTool(context, runner, maxInputBytes) {
         bytes = await context.fs.readFile(resolvePath(context.cwd, candidate), {
           signal: invocation.signal
         });
-      } catch {
+      } catch (error) {
+        if (!(error instanceof FsError) || !["ENOENT", "ENOTDIR", "EISDIR", "EACCES", "EPERM"].includes(error.code)) throw error;
         continue;
       }
       chargeInput(bytes.byteLength);
@@ -5249,8 +5296,13 @@ function createImagemagickCommands(options = {}) {
   return [createMagickCommand(options), createConvertCommand(options), createMogrifyCommand(options), createCompositeCommand(options), createMontageCommand(options), createIdentifyCommand(options), createCompareCommand(options)];
 }
 function* mapSteps(values, mapper) {
-  const result = [];
-  for (const value of values) result.push(yield* mapper(value));
+  const result = new Array(values.length);
+  const mutable = Array.isArray(values) ? values : void 0;
+  for (let i = 0; i < values.length; i++) {
+    const val = values[i];
+    if (mutable) mutable[i] = void 0;
+    result[i] = yield* mapper(val);
+  }
   return result;
 }
 export {

package/dist/safe-bash-command-install/arguments.d.ts

@@ -0,0 +1,27 @@
+import type { CommandContext } from "../safe-bash-contracts/index.js";
+import { type InstallCommandsOptions } from "./options.js";
+export interface InstallArguments {
+    files: string[];
+    directory: boolean;
+    parents: boolean;
+    compare: boolean;
+    preserve: boolean;
+    strip: boolean;
+    stripProgram: string;
+    stripProgramSpecified: boolean;
+    verbose: boolean;
+    debug: boolean;
+    noTarget: boolean;
+    target?: string;
+    mode?: string;
+    modeBytes?: Uint8Array;
+    owner?: string;
+    group?: string;
+    backup: "none" | "simple" | "existing" | "numbered";
+    suffix: string;
+    contextMode?: "default" | "preserve" | "explicit";
+    contextLabel?: string;
+    display?: "help" | "version";
+}
+export declare function parseArguments(context: CommandContext, options: InstallCommandsOptions, warn: (message: string) => Promise<void>): Promise<InstallArguments>;
+export declare const helpText = "Usage: install [OPTION]... [-T] SOURCE DEST\n  or:  install [OPTION]... SOURCE... DIRECTORY\n  or:  install [OPTION]... -t DIRECTORY SOURCE...\n  or:  install [OPTION]... -d DIRECTORY...\n\nThis install program copies files (often just compiled) into destination\nlocations you choose.  If you want to download and install a ready-to-use\npackage on a GNU/Linux system, you should instead be using a package manager\nlike yum(1) or apt-get(1).\n\nIn the first three forms, copy SOURCE to DEST or multiple SOURCE(s) to\nthe existing DIRECTORY, while setting permission modes and owner/group.\nIn the 4th form, create all components of the given DIRECTORY(ies).\n\nMandatory arguments to long options are mandatory for short options too.\n      --backup[=CONTROL]  make a backup of each existing destination file\n  -b                  like --backup but does not accept an argument\n  -c                  (ignored)\n  -C, --compare       compare content of source and destination files, and\n                        if no change to content, ownership, and permissions,\n                        do not modify the destination at all\n  -d, --directory     treat all arguments as directory names; create all\n                        components of the specified directories\n  -D                  create all leading components of DEST except the last,\n                        or all components of --target-directory,\n                        then copy SOURCE to DEST\n      --debug         explain how a file is copied.  Implies -v\n  -g, --group=GROUP   set group ownership, instead of process' current group\n  -m, --mode=MODE     set permission mode (as in chmod), instead of rwxr-xr-x\n  -o, --owner=OWNER   set ownership (super-user only)\n  -p, --preserve-timestamps   apply access/modification times of SOURCE files\n                        to corresponding destination files\n  -s, --strip         strip symbol tables\n      --strip-program=PROGRAM  program used to strip binaries\n  -S, --suffix=SUFFIX  override the usual backup suffix\n  -t, --target-directory=DIRECTORY  copy all SOURCE arguments into DIRECTORY\n  -T, --no-target-directory  treat DEST as a normal file\n  -v, --verbose       print the name of each created file or directory\n      --preserve-context  preserve SELinux security context\n  -Z                      set SELinux security context of destination\n                            file and each created directory to default type\n      --context[=CTX]     like -Z, or if CTX is specified then set the\n                            SELinux or SMACK security context to CTX\n      --help        display this help and exit\n      --version     output version information and exit\n\nThe backup suffix is '~', unless set with --suffix or SIMPLE_BACKUP_SUFFIX.\nThe version control method may be selected via the --backup option or through\nthe VERSION_CONTROL environment variable.  Here are the values:\n\n  none, off       never make backups (even if --backup is given)\n  numbered, t     make numbered backups\n  existing, nil   numbered if numbered backups exist, simple otherwise\n  simple, never   always make simple backups\n\nGNU coreutils online help: <https://www.gnu.org/software/coreutils/>\nReport any translation bugs to <https://translationproject.org/team/>\nFull documentation <https://www.gnu.org/software/coreutils/install>\nor available locally via: info '(coreutils) install invocation'\n";