poe-code 15.0.9 → 15.0.10

package/packages/safe-bash/dist/chunks/chunk-LUIEXTN5.js

@@ -0,0 +1,527 @@
+import {
+  createOutputOperation
+} from "./chunk-UL4TNDNV.js";
+import {
+  FsError,
+  PublicDiagnostic,
+  getCommandArguments,
+  init_platform,
+  shellValueByteLength,
+  shellValueBytes,
+  yieldTurn
+} from "./chunk-4NMFAR4Z.js";
+
+// packages/safe-bash/src/commands/factor/index.ts
+init_platform();
+
+// packages/safe-bash/src/commands/factor/command.ts
+init_platform();
+
+// packages/safe-bash/src/commands/factor/internal.ts
+init_platform();
+function settings(options) {
+  const limits = {
+    maxValue: 4294967295,
+    maxArguments: 4096,
+    maxArgumentBytes: 65536,
+    maxInputBytes: 16777216,
+    maxTokenBytes: 65536,
+    maxNumbers: 65536,
+    maxBufferedBytes: 4194304,
+    maxOutputBytes: 16777216,
+    maxDiagnosticBytes: 65536,
+    maxWork: 8388608,
+    maxEmptyChunks: 4096,
+    ...options.limits
+  };
+  for (const [name, value] of Object.entries(limits)) {
+    if (!Number.isSafeInteger(value) || value < 1) throw new RangeError(`Invalid factor limit: ${name}`);
+  }
+  if (limits.maxValue > 4294967295) throw new RangeError("factor maxValue cannot exceed 4294967295");
+  return Object.freeze(limits);
+}
+var FactorError = class extends PublicDiagnostic {
+  constructor(message, usage = false) {
+    super(message);
+    this.usage = usage;
+  }
+  usage;
+};
+function raw(value) {
+  let result = "";
+  for (let offset = 0; offset < value.length; offset += 4096) result += String.fromCharCode(...value.subarray(offset, offset + 4096));
+  return result;
+}
+function bytes(value) {
+  return Uint8Array.from(value, (character) => character.charCodeAt(0));
+}
+var escapes = { "\x07": "\\a", "\b": "\\b", "\f": "\\f", "\n": "\\n", "\r": "\\r", "	": "\\t", "\v": "\\v", "\\": "\\\\", "'": "\\'" };
+function quote(value, budget, suffixLength) {
+  let length = 2;
+  for (const character of value) {
+    const code = character.charCodeAt(0);
+    length += escapes[character]?.length ?? (code >= 32 && code < 127 ? 1 : 4);
+  }
+  budget.diagnosticRoom(length + suffixLength);
+  let result = "'";
+  for (const character of value) {
+    const code = character.charCodeAt(0);
+    result += escapes[character] ?? (code >= 32 && code < 127 ? character : `\\${code.toString(8).padStart(3, "0")}`);
+  }
+  return `${result}'`;
+}
+var Budget = class {
+  constructor(context, limits, signal) {
+    this.context = context;
+    this.limits = limits;
+    this.signal = signal;
+  }
+  context;
+  limits;
+  signal;
+  work = 0;
+  checkpoint = 0;
+  retained = 0;
+  input = 0;
+  numbers = 0;
+  output = 0;
+  diagnostics = 0;
+  check(value, maximum, label) {
+    if (!Number.isSafeInteger(value) || value < 0 || value > maximum) throw new FactorError(`${label} limit exceeded`);
+  }
+  charge(amount = 1) {
+    this.signal.throwIfAborted();
+    this.check(this.work + amount, this.limits.maxWork, "work");
+    this.work += amount;
+  }
+  async checkpointWork() {
+    this.signal.throwIfAborted();
+    if (this.work - this.checkpoint >= 1024) {
+      this.checkpoint = this.work;
+      await yieldTurn(this.signal);
+    }
+  }
+  retain(amount) {
+    this.check(this.retained + amount, this.limits.maxBufferedBytes, "buffered bytes");
+    this.retained += amount;
+  }
+  number() {
+    this.check(++this.numbers, this.limits.maxNumbers, "numbers");
+    this.charge();
+  }
+  inputBytes(amount) {
+    this.check(this.input + amount, this.limits.maxInputBytes, "input bytes");
+    this.input += amount;
+  }
+  outputRoom(amount) {
+    this.check(this.output + amount, this.limits.maxOutputBytes, "output bytes");
+  }
+  diagnosticRoom(amount) {
+    this.check(this.diagnostics + amount, this.limits.maxDiagnosticBytes, "diagnostic bytes");
+  }
+  emitted(amount, diagnostic) {
+    if (diagnostic) {
+      this.diagnosticRoom(amount);
+      this.diagnostics += amount;
+    } else {
+      this.outputRoom(amount);
+      this.charge(amount);
+      this.output += amount;
+    }
+  }
+  arguments() {
+    this.check(this.context.args.length, this.limits.maxArguments, "argument count");
+    let total = 0;
+    for (const argument of this.context.args) {
+      total += argument.length;
+      this.check(total, this.limits.maxArgumentBytes, "argument bytes");
+      for (let offset = 0; offset < argument.length; offset++) {
+        const unit = argument.charCodeAt(offset);
+        if (unit >= 55296 && unit <= 56319) {
+          const next = argument.charCodeAt(++offset);
+          if (!(next >= 56320 && next <= 57343)) throw new FactorError("arguments must contain well-formed Unicode");
+        } else if (unit >= 56320 && unit <= 57343) throw new FactorError("arguments must contain well-formed Unicode");
+      }
+    }
+    total = 0;
+    const values = this.context.argumentValues === void 0 ? this.context.args : getCommandArguments(this.context).values;
+    for (const argument of values) {
+      total += shellValueByteLength(argument);
+      this.check(total, this.limits.maxArgumentBytes, "argument bytes");
+    }
+    this.charge(total);
+    this.retain(total * 8 + this.context.args.length * 64 + 128);
+    return getCommandArguments(this.context).values.map((argument) => {
+      const value = shellValueBytes(argument);
+      if (value.includes(0)) throw new FactorError("NUL is not supported in arguments");
+      return raw(value);
+    });
+  }
+};
+
+// packages/safe-bash/src/commands/factor/io.ts
+init_platform();
+var Lifecycle = class {
+  constructor(budget, output) {
+    this.budget = budget;
+    output.registerCleanup(() => this.close());
+  }
+  budget;
+  pending = /* @__PURE__ */ new Set();
+  cleanups = [];
+  closing;
+  cleanup(action) {
+    this.assertOpen();
+    this.cleanups.push(action);
+  }
+  assertOpen() {
+    this.budget.signal.throwIfAborted();
+    if (this.closing) throw new FactorError("command is closed");
+  }
+  async operation(action) {
+    this.assertOpen();
+    const pending = Promise.resolve().then(() => {
+      this.assertOpen();
+      return action();
+    });
+    this.pending.add(pending);
+    try {
+      const value = await pending;
+      this.assertOpen();
+      return value;
+    } finally {
+      this.pending.delete(pending);
+    }
+  }
+  close() {
+    return this.closing ??= Promise.resolve().then(async () => {
+      while (this.pending.size) await Promise.allSettled([...this.pending]);
+      const failures = [];
+      for (const cleanup of this.cleanups) {
+        try {
+          await cleanup();
+        } catch (error) {
+          failures.push(error);
+        }
+      }
+      if (failures.length === 1) throw failures[0];
+      if (failures.length > 1) throw new AggregateError(failures, "factor cleanup failed");
+    });
+  }
+  async write(value, diagnostic = false) {
+    this.budget.emitted(value.length, diagnostic);
+    await this.operation(async () => {
+      const sink = diagnostic ? this.budget.context.stderr : this.budget.context.stdout;
+      this.assertOpen();
+      const destination = sink.ownedOutput ?? sink;
+      this.assertOpen();
+      const write = destination.write;
+      this.assertOpen();
+      await Reflect.apply(write, destination, [value]);
+    });
+  }
+  async diagnostic(value) {
+    this.budget.diagnosticRoom(value.length);
+    await this.write(bytes(value), true);
+  }
+};
+var TokenReader = class {
+  constructor(lifecycle) {
+    this.lifecycle = lifecycle;
+    lifecycle.cleanup(async () => {
+      try {
+        if (!this.ended) await this.iterator?.return?.();
+      } finally {
+        this.iterator = void 0;
+        lifecycle.budget.retain(-this.chunk.length - this.token.length);
+        this.chunk = new Uint8Array();
+        this.token = new Uint8Array();
+      }
+    });
+  }
+  lifecycle;
+  iterator;
+  chunk = new Uint8Array();
+  token = new Uint8Array();
+  offset = 0;
+  ended = false;
+  empties = 0;
+  async get() {
+    const { budget } = this.lifecycle;
+    budget.charge();
+    await budget.checkpointWork();
+    while (this.offset === this.chunk.length) {
+      if (this.ended) return -1;
+      let next;
+      try {
+        if (!this.iterator) await this.lifecycle.operation(() => {
+          const source = budget.context.stdin;
+          this.lifecycle.assertOpen();
+          const factory = source[Symbol.asyncIterator];
+          this.lifecycle.assertOpen();
+          this.iterator = Reflect.apply(factory, source, []);
+        });
+        budget.charge();
+        next = await this.lifecycle.operation(() => {
+          const iterator = this.iterator;
+          const advance = iterator.next;
+          this.lifecycle.assertOpen();
+          return Reflect.apply(advance, iterator, []);
+        });
+      } catch (error) {
+        if (error instanceof FsError) throw new FactorError(`standard input: ${error.code === "EIO" ? "Input/output error" : error.message}`);
+        throw error;
+      }
+      budget.retain(-this.chunk.length);
+      this.chunk = new Uint8Array();
+      this.offset = 0;
+      if (next.done) {
+        this.ended = true;
+        this.iterator = void 0;
+        return -1;
+      }
+      if (!(next.value instanceof Uint8Array)) throw new TypeError("factor input requires bytes");
+      budget.inputBytes(next.value.length);
+      budget.charge(next.value.length);
+      budget.retain(next.value.length);
+      this.chunk = Uint8Array.from(next.value);
+      if (!this.chunk.length) budget.check(++this.empties, budget.limits.maxEmptyChunks, "empty input chunks");
+    }
+    return this.chunk[this.offset++];
+  }
+  async next() {
+    const { budget } = this.lifecycle;
+    let length = 0, kept = 0;
+    let nul = false;
+    for (; ; ) {
+      const value = await this.get();
+      if (value < 0 || value === 32 || value === 9 || value === 10) {
+        if (length) {
+          budget.charge(kept);
+          budget.retain(kept * 4);
+          return raw(this.token.subarray(0, kept));
+        }
+        if (value < 0) return void 0;
+      } else {
+        budget.check(++length, budget.limits.maxTokenBytes, "token bytes");
+        if (value === 0) nul = true;
+        if (!nul) {
+          if (kept === this.token.length) {
+            const capacity = Math.min(budget.limits.maxTokenBytes, Math.max(64, this.token.length * 2));
+            budget.retain(capacity);
+            budget.charge(this.token.length);
+            const grown = new Uint8Array(capacity);
+            grown.set(this.token);
+            budget.retain(-this.token.length);
+            this.token = grown;
+          }
+          this.token[kept++] = value;
+        }
+      }
+    }
+  }
+};
+var RecordWriter = class {
+  constructor(lifecycle) {
+    this.lifecycle = lifecycle;
+    lifecycle.budget.retain(1024);
+    this.buffer = new Uint8Array(1024);
+    lifecycle.cleanup(async () => {
+      lifecycle.budget.retain(-this.buffer.length);
+      this.buffer = new Uint8Array();
+    });
+  }
+  lifecycle;
+  buffer;
+  used = 0;
+  async append(record) {
+    const { budget } = this.lifecycle;
+    this.lifecycle.assertOpen();
+    budget.outputRoom(this.used + record.length);
+    budget.charge(record.length);
+    for (let offset = 0; offset < record.length; offset++) this.buffer[this.used++] = record.charCodeAt(offset);
+    if (this.used >= 512) {
+      let end = 512;
+      while (this.buffer[end - 1] !== 10) end--;
+      await this.lifecycle.write(this.buffer.subarray(0, end));
+      this.buffer.copyWithin(0, end, this.used);
+      this.used -= end;
+    }
+  }
+  async finish() {
+    if (this.used) {
+      await this.lifecycle.write(this.buffer.subarray(0, this.used));
+      this.used = 0;
+    }
+  }
+};
+
+// packages/safe-bash/src/commands/factor/factor.ts
+init_platform();
+async function parseNumber(input, budget) {
+  let start = 0;
+  while (input[start] === " ") {
+    budget.charge();
+    start++;
+    await budget.checkpointWork();
+  }
+  if (input[start] === "+") start++;
+  if (start === input.length) return "invalid";
+  let result = 0, large = false;
+  for (let offset = start; offset < input.length; offset++) {
+    budget.charge();
+    const digit = input.charCodeAt(offset) - 48;
+    if (digit < 0 || digit > 9) return "invalid";
+    if (!large) {
+      if (result > Math.floor((budget.limits.maxValue - digit) / 10)) large = true;
+      else result = result * 10 + digit;
+    }
+    await budget.checkpointWork();
+  }
+  return large ? "large" : result;
+}
+async function factorRecord(value, budget) {
+  let remaining = value;
+  const factors = [];
+  budget.retain(512);
+  try {
+    for (let divisor = 2; divisor * divisor <= remaining; divisor = divisor === 2 ? 3 : divisor + 2) {
+      for (; ; ) {
+        budget.charge();
+        await budget.checkpointWork();
+        if (remaining % divisor !== 0) break;
+        budget.charge(2);
+        factors.push(divisor);
+        remaining /= divisor;
+      }
+    }
+    if (remaining > 1) factors.push(remaining);
+    budget.charge(1 + factors.length * 11);
+    return `${value}:${factors.map((factor) => ` ${factor}`).join("")}
+`;
+  } finally {
+    budget.retain(-512);
+  }
+}
+
+// packages/safe-bash/src/commands/factor/command.ts
+function createFactorCommand(options = {}) {
+  const limits = settings(options);
+  return { name: "factor", description: "Print prime factors of bounded nonnegative integers", async execute(context) {
+    const output = createOutputOperation(context, context.stdout);
+    const budget = new Budget(context, limits, output.signal);
+    let lifecycle;
+    let failure;
+    let primary;
+    let exitCode = 0;
+    try {
+      lifecycle = new Lifecycle(budget, output);
+      const operands = [];
+      let optionsEnded = false, debug = false;
+      let information;
+      for (const argument of budget.arguments()) {
+        if (!optionsEnded && argument === "--") {
+          optionsEnded = true;
+          continue;
+        }
+        if (!optionsEnded && argument.startsWith("--")) {
+          const equals = argument.indexOf("=");
+          const option = equals < 0 ? argument.slice(2) : argument.slice(2, equals);
+          const matches = ["-debug", "help", "version"].filter((name) => name.startsWith(option));
+          if (matches.length > 1) throw new FactorError(`option '${argument}' is ambiguous; possibilities: ${matches.map((name) => `'--${name}'`).join(" ")}`, true);
+          const matched = matches[0];
+          if (!matched) throw new FactorError(`unrecognized option '${argument}'`, true);
+          if (equals >= 0) throw new FactorError(`option '--${matched}' doesn't allow an argument`, true);
+          if (matched === "-debug") debug = true;
+          else {
+            information = matched;
+            break;
+          }
+        } else {
+          if (!optionsEnded && argument.length > 1 && argument.startsWith("-")) throw new FactorError(`invalid option -- '${argument[1]}'`, true);
+          operands.push(argument);
+          if (context.env.POSIXLY_CORRECT !== void 0) optionsEnded = true;
+        }
+      }
+      if (information) {
+        const message = information === "version" ? "factor (virtual-bash)\n" : `Usage: factor [NUMBER]...
+Print prime factors; with no numbers, read standard input.
+Options: --help --version
+Maximum supported value: ${limits.maxValue}
+`;
+        budget.outputRoom(message.length);
+        await lifecycle.write(bytes(message));
+      } else {
+        const writer = new RecordWriter(lifecycle);
+        const process = async (input) => {
+          budget.number();
+          budget.check(input.length, limits.maxTokenBytes, "token bytes");
+          const value = await parseNumber(input, budget);
+          if (typeof value === "string") {
+            exitCode = 1;
+            const suffix = value === "invalid" ? " is not a valid positive integer\n" : ` exceeds supported maximum ${limits.maxValue}
+`;
+            await lifecycle.diagnostic(`factor: ${quote(input, budget, 8 + suffix.length)}${suffix}`);
+          } else {
+            if (debug) await lifecycle.diagnostic("[using single-precision arithmetic] ");
+            await writer.append(await factorRecord(value, budget));
+          }
+        };
+        if (operands.length) {
+          for (const operand of operands) await process(operand);
+        } else {
+          const reader = new TokenReader(lifecycle);
+          for (; ; ) {
+            const token = await reader.next();
+            if (token === void 0) break;
+            try {
+              await process(token);
+            } finally {
+              budget.retain(-token.length * 4);
+            }
+          }
+        }
+        await writer.finish();
+      }
+    } catch (error) {
+      primary = { reason: error };
+      if (error instanceof FactorError && !output.signal.aborted && lifecycle) {
+        exitCode = 1;
+        try {
+          await lifecycle.diagnostic(`factor: ${error.message}
+${error.usage ? "Try 'factor --help' for more information.\n" : ""}`);
+        } catch (reporting) {
+          failure = { reason: new AggregateError([error, reporting], "factor failure reporting failed") };
+        }
+      } else failure = { reason: error };
+    }
+    try {
+      await output.close();
+    } catch (cleanup) {
+      const previous = failure ?? primary;
+      failure = { reason: previous ? new AggregateError([previous.reason, cleanup], "factor execution and cleanup failed") : cleanup };
+    }
+    context.signal.throwIfAborted();
+    output.signal.throwIfAborted();
+    if (failure) throw failure.reason;
+    return { exitCode };
+  } };
+}
+
+// packages/safe-bash/src/commands/factor/index.ts
+function createFactorCommands(options = {}) {
+  return [createFactorCommand(options)];
+}
+function factorCommands(options = {}) {
+  const commands = createFactorCommands(options);
+  return { name: "factor-commands", setup(host) {
+    for (const command of commands) host.commands.register(command, { replace: options.replace ?? false });
+  } };
+}
+
+export {
+  createFactorCommand,
+  createFactorCommands,
+  factorCommands
+};
+//# sourceMappingURL=chunk-LUIEXTN5.js.map

package/packages/safe-bash/dist/chunks/chunk-LUIEXTN5.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/commands/factor/index.ts", "../../src/commands/factor/command.ts", "../../src/commands/factor/internal.ts", "../../src/commands/factor/io.ts", "../../src/commands/factor/factor.ts"],
+  "sourcesContent": ["import type { CommandDefinition, VirtualShellPlugin } from \"../../contracts/index.js\";\nimport { createFactorCommand } from \"./command.js\";\nimport type { FactorCommandsOptions } from \"./internal.js\";\n\nexport { createFactorCommand } from \"./command.js\";\nexport type { FactorCommandsOptions, FactorLimits } from \"./internal.js\";\n\nexport function createFactorCommands(options: FactorCommandsOptions = {}): readonly CommandDefinition[] {\n  return [createFactorCommand(options)];\n}\n\nexport function factorCommands(options: FactorCommandsOptions = {}): VirtualShellPlugin {\n  const commands = createFactorCommands(options);\n  return { name: \"factor-commands\", setup(host) {\n    for (const command of commands) host.commands.register(command, { replace: options.replace ?? false });\n  } };\n}\n", "import type { CommandDefinition } from \"../../contracts/index.js\";\nimport { createOutputOperation } from \"../../contracts/output.js\";\nimport { Budget, FactorError, bytes, quote, settings, type FactorCommandsOptions } from \"./internal.js\";\nimport { Lifecycle, RecordWriter, TokenReader } from \"./io.js\";\nimport { factorRecord, parseNumber } from \"./factor.js\";\n\nexport function createFactorCommand(options: FactorCommandsOptions = {}): CommandDefinition {\n  const limits = settings(options);\n  return { name: \"factor\", description: \"Print prime factors of bounded nonnegative integers\", async execute(context) {\n    const output = createOutputOperation(context, context.stdout);\n    const budget = new Budget(context, limits, output.signal);\n    let lifecycle: Lifecycle | undefined;\n    let failure: { reason: unknown } | undefined;\n    let primary: { reason: unknown } | undefined;\n    let exitCode = 0;\n    try {\n      lifecycle = new Lifecycle(budget, output);\n      const operands: string[] = [];\n      let optionsEnded = false, debug = false;\n      let information: \"help\" | \"version\" | undefined;\n      for (const argument of budget.arguments()) {\n        if (!optionsEnded && argument === \"--\") { optionsEnded = true; continue; }\n        if (!optionsEnded && argument.startsWith(\"--\")) {\n          const equals = argument.indexOf(\"=\");\n          const option = equals < 0 ? argument.slice(2) : argument.slice(2, equals);\n          const matches = [\"-debug\", \"help\", \"version\"].filter(name => name.startsWith(option));\n          if (matches.length > 1) throw new FactorError(`option '${argument}' is ambiguous; possibilities: ${matches.map(name => `'--${name}'`).join(\" \")}`, true);\n          const matched = matches[0];\n          if (!matched) throw new FactorError(`unrecognized option '${argument}'`, true);\n          if (equals >= 0) throw new FactorError(`option '--${matched}' doesn't allow an argument`, true);\n          if (matched === \"-debug\") debug = true;\n          else { information = matched as \"help\" | \"version\"; break; }\n        } else {\n          if (!optionsEnded && argument.length > 1 && argument.startsWith(\"-\")) throw new FactorError(`invalid option -- '${argument[1]}'`, true);\n          operands.push(argument);\n          if (context.env.POSIXLY_CORRECT !== undefined) optionsEnded = true;\n        }\n      }\n      if (information) {\n        const message = information === \"version\" ? \"factor (virtual-bash)\\n\" : `Usage: factor [NUMBER]...\\nPrint prime factors; with no numbers, read standard input.\\nOptions: --help --version\\nMaximum supported value: ${limits.maxValue}\\n`;\n        budget.outputRoom(message.length);\n        await lifecycle.write(bytes(message));\n      } else {\n        const writer = new RecordWriter(lifecycle);\n        const process = async (input: string): Promise<void> => {\n          budget.number();\n          budget.check(input.length, limits.maxTokenBytes, \"token bytes\");\n          const value = await parseNumber(input, budget);\n          if (typeof value === \"string\") {\n            exitCode = 1;\n            const suffix = value === \"invalid\" ? \" is not a valid positive integer\\n\" : ` exceeds supported maximum ${limits.maxValue}\\n`;\n            await lifecycle!.diagnostic(`factor: ${quote(input, budget, 8 + suffix.length)}${suffix}`);\n          } else {\n            if (debug) await lifecycle!.diagnostic(\"[using single-precision arithmetic] \");\n            await writer.append(await factorRecord(value, budget));\n          }\n        };\n        if (operands.length) { for (const operand of operands) await process(operand); }\n        else {\n          const reader = new TokenReader(lifecycle);\n          for (;;) {\n            const token = await reader.next();\n            if (token === undefined) break;\n            try { await process(token); } finally { budget.retain(-token.length * 4); }\n          }\n        }\n        await writer.finish();\n      }\n    } catch (error) {\n      primary = { reason: error };\n      if (error instanceof FactorError && !output.signal.aborted && lifecycle) {\n        exitCode = 1;\n        try { await lifecycle.diagnostic(`factor: ${error.message}\\n${error.usage ? \"Try 'factor --help' for more information.\\n\" : \"\"}`); }\n        catch (reporting) { failure = { reason: new AggregateError([error, reporting], \"factor failure reporting failed\") }; }\n      } else failure = { reason: error };\n    }\n    try { await output.close(); }\n    catch (cleanup) {\n      const previous = failure ?? primary;\n      failure = { reason: previous ? new AggregateError([previous.reason, cleanup], \"factor execution and cleanup failed\") : cleanup };\n    }\n    context.signal.throwIfAborted();\n    output.signal.throwIfAborted();\n    if (failure) throw failure.reason;\n    return { exitCode };\n  } };\n}\n", "import { getCommandArguments, type CommandContext } from \"../../contracts/index.js\";\nimport { shellValueByteLength, shellValueBytes } from \"../../contracts/value.js\";\nimport { yieldTurn } from \"../../contracts/yield.js\";\nimport { PublicDiagnostic } from \"../../diagnostics.js\";\n\nexport interface FactorLimits {\n  readonly maxValue: number;\n  readonly maxArguments: number;\n  readonly maxArgumentBytes: number;\n  readonly maxInputBytes: number;\n  readonly maxTokenBytes: number;\n  readonly maxNumbers: number;\n  readonly maxBufferedBytes: number;\n  readonly maxOutputBytes: number;\n  readonly maxDiagnosticBytes: number;\n  readonly maxWork: number;\n  readonly maxEmptyChunks: number;\n}\n\nexport interface FactorCommandsOptions {\n  readonly replace?: boolean;\n  readonly limits?: Partial<FactorLimits>;\n}\n\nexport function settings(options: FactorCommandsOptions): FactorLimits {\n  const limits: FactorLimits = {\n    maxValue: 4_294_967_295, maxArguments: 4096, maxArgumentBytes: 65_536,\n    maxInputBytes: 16_777_216, maxTokenBytes: 65_536, maxNumbers: 65_536,\n    maxBufferedBytes: 4_194_304, maxOutputBytes: 16_777_216,\n    maxDiagnosticBytes: 65_536, maxWork: 8_388_608, maxEmptyChunks: 4096, ...options.limits,\n  };\n  for (const [name, value] of Object.entries(limits)) {\n    if (!Number.isSafeInteger(value) || value < 1) throw new RangeError(`Invalid factor limit: ${name}`);\n  }\n  if (limits.maxValue > 4_294_967_295) throw new RangeError(\"factor maxValue cannot exceed 4294967295\");\n  return Object.freeze(limits);\n}\n\nexport class FactorError extends PublicDiagnostic {\n  constructor(message: string, readonly usage = false) { super(message); }\n}\n\nexport function raw(value: Uint8Array): string {\n  let result = \"\";\n  for (let offset = 0; offset < value.length; offset += 4096) result += String.fromCharCode(...value.subarray(offset, offset + 4096));\n  return result;\n}\n\nexport function bytes(value: string): Uint8Array {\n  return Uint8Array.from(value, character => character.charCodeAt(0));\n}\n\nconst escapes: Readonly<Record<string, string>> = { \"\\x07\": \"\\\\a\", \"\\b\": \"\\\\b\", \"\\f\": \"\\\\f\", \"\\n\": \"\\\\n\", \"\\r\": \"\\\\r\", \"\\t\": \"\\\\t\", \"\\v\": \"\\\\v\", \"\\\\\": \"\\\\\\\\\", \"'\": \"\\\\'\" };\n\nexport function quote(value: string, budget: Budget, suffixLength: number): string {\n  let length = 2;\n  for (const character of value) {\n    const code = character.charCodeAt(0);\n    length += escapes[character]?.length ?? (code >= 32 && code < 127 ? 1 : 4);\n  }\n  budget.diagnosticRoom(length + suffixLength);\n  let result = \"'\";\n  for (const character of value) {\n    const code = character.charCodeAt(0);\n    result += escapes[character] ?? (code >= 32 && code < 127 ? character : `\\\\${code.toString(8).padStart(3, \"0\")}`);\n  }\n  return `${result}'`;\n}\n\nexport class Budget {\n  private work = 0;\n  private checkpoint = 0;\n  private retained = 0;\n  private input = 0;\n  private numbers = 0;\n  private output = 0;\n  private diagnostics = 0;\n  constructor(readonly context: CommandContext, readonly limits: FactorLimits, readonly signal: AbortSignal) {}\n  check(value: number, maximum: number, label: string): void {\n    if (!Number.isSafeInteger(value) || value < 0 || value > maximum) throw new FactorError(`${label} limit exceeded`);\n  }\n  charge(amount = 1): void {\n    this.signal.throwIfAborted();\n    this.check(this.work + amount, this.limits.maxWork, \"work\");\n    this.work += amount;\n  }\n  async checkpointWork(): Promise<void> {\n    this.signal.throwIfAborted();\n    if (this.work - this.checkpoint >= 1024) { this.checkpoint = this.work; await yieldTurn(this.signal); }\n  }\n  retain(amount: number): void {\n    this.check(this.retained + amount, this.limits.maxBufferedBytes, \"buffered bytes\");\n    this.retained += amount;\n  }\n  number(): void { this.check(++this.numbers, this.limits.maxNumbers, \"numbers\"); this.charge(); }\n  inputBytes(amount: number): void {\n    this.check(this.input + amount, this.limits.maxInputBytes, \"input bytes\");\n    this.input += amount;\n  }\n  outputRoom(amount: number): void { this.check(this.output + amount, this.limits.maxOutputBytes, \"output bytes\"); }\n  diagnosticRoom(amount: number): void { this.check(this.diagnostics + amount, this.limits.maxDiagnosticBytes, \"diagnostic bytes\"); }\n  emitted(amount: number, diagnostic: boolean): void {\n    if (diagnostic) { this.diagnosticRoom(amount); this.diagnostics += amount; }\n    else { this.outputRoom(amount); this.charge(amount); this.output += amount; }\n  }\n  arguments(): string[] {\n    this.check(this.context.args.length, this.limits.maxArguments, \"argument count\");\n    let total = 0;\n    for (const argument of this.context.args) {\n      total += argument.length;\n      this.check(total, this.limits.maxArgumentBytes, \"argument bytes\");\n      for (let offset = 0; offset < argument.length; offset++) {\n        const unit = argument.charCodeAt(offset);\n        if (unit >= 0xd800 && unit <= 0xdbff) {\n          const next = argument.charCodeAt(++offset);\n          if (!(next >= 0xdc00 && next <= 0xdfff)) throw new FactorError(\"arguments must contain well-formed Unicode\");\n        } else if (unit >= 0xdc00 && unit <= 0xdfff) throw new FactorError(\"arguments must contain well-formed Unicode\");\n      }\n    }\n    total = 0;\n    const values = this.context.argumentValues === undefined ? this.context.args : getCommandArguments(this.context).values;\n    for (const argument of values) { total += shellValueByteLength(argument); this.check(total, this.limits.maxArgumentBytes, \"argument bytes\"); }\n    this.charge(total);\n    this.retain(total * 8 + this.context.args.length * 64 + 128);\n    return getCommandArguments(this.context).values.map(argument => {\n      const value = shellValueBytes(argument);\n      if (value.includes(0)) throw new FactorError(\"NUL is not supported in arguments\");\n      return raw(value);\n    });\n  }\n}\n", "import { FsError } from \"../../contracts/index.js\";\nimport type { OutputOperation } from \"../../contracts/output.js\";\nimport { Budget, FactorError, bytes, raw } from \"./internal.js\";\n\nexport class Lifecycle {\n  private readonly pending = new Set<Promise<unknown>>();\n  private readonly cleanups: (() => Promise<void>)[] = [];\n  private closing: Promise<void> | undefined;\n  constructor(readonly budget: Budget, output: OutputOperation) { output.registerCleanup(() => this.close()); }\n  cleanup(action: () => Promise<void>): void { this.assertOpen(); this.cleanups.push(action); }\n  assertOpen(): void {\n    this.budget.signal.throwIfAborted();\n    if (this.closing) throw new FactorError(\"command is closed\");\n  }\n  async operation<Value>(action: () => Value | Promise<Value>): Promise<Value> {\n    this.assertOpen();\n    const pending = Promise.resolve().then(() => { this.assertOpen(); return action(); });\n    this.pending.add(pending);\n    try { const value = await pending; this.assertOpen(); return value; }\n    finally { this.pending.delete(pending); }\n  }\n  close(): Promise<void> {\n    return this.closing ??= Promise.resolve().then(async () => {\n      while (this.pending.size) await Promise.allSettled([...this.pending]);\n      const failures: unknown[] = [];\n      for (const cleanup of this.cleanups) { try { await cleanup(); } catch (error) { failures.push(error); } }\n      if (failures.length === 1) throw failures[0];\n      if (failures.length > 1) throw new AggregateError(failures, \"factor cleanup failed\");\n    });\n  }\n  async write(value: Uint8Array, diagnostic = false): Promise<void> {\n    this.budget.emitted(value.length, diagnostic);\n    await this.operation(async () => {\n      const sink = diagnostic ? this.budget.context.stderr : this.budget.context.stdout;\n      this.assertOpen();\n      const destination = sink.ownedOutput ?? sink;\n      this.assertOpen();\n      const write = destination.write;\n      this.assertOpen();\n      await Reflect.apply(write, destination, [value]);\n    });\n  }\n  async diagnostic(value: string): Promise<void> {\n    this.budget.diagnosticRoom(value.length);\n    await this.write(bytes(value), true);\n  }\n}\n\nexport class TokenReader {\n  private iterator: AsyncIterator<Uint8Array> | undefined;\n  private chunk: Uint8Array = new Uint8Array();\n  private token: Uint8Array = new Uint8Array();\n  private offset = 0;\n  private ended = false;\n  private empties = 0;\n  constructor(readonly lifecycle: Lifecycle) {\n    lifecycle.cleanup(async () => {\n      try { if (!this.ended) await this.iterator?.return?.(); }\n      finally {\n        this.iterator = undefined;\n        lifecycle.budget.retain(-this.chunk.length - this.token.length);\n        this.chunk = new Uint8Array();\n        this.token = new Uint8Array();\n      }\n    });\n  }\n  private async get(): Promise<number> {\n    const { budget } = this.lifecycle;\n    budget.charge();\n    await budget.checkpointWork();\n    while (this.offset === this.chunk.length) {\n      if (this.ended) return -1;\n      let next: IteratorResult<Uint8Array>;\n      try {\n        if (!this.iterator) await this.lifecycle.operation(() => {\n          const source = budget.context.stdin;\n          this.lifecycle.assertOpen();\n          const factory = source[Symbol.asyncIterator];\n          this.lifecycle.assertOpen();\n          this.iterator = Reflect.apply(factory, source, []);\n        });\n        budget.charge();\n        next = await this.lifecycle.operation(() => {\n          const iterator = this.iterator!;\n          const advance = iterator.next;\n          this.lifecycle.assertOpen();\n          return Reflect.apply(advance, iterator, []);\n        });\n      } catch (error) {\n        if (error instanceof FsError) throw new FactorError(`standard input: ${error.code === \"EIO\" ? \"Input/output error\" : error.message}`);\n        throw error;\n      }\n      budget.retain(-this.chunk.length);\n      this.chunk = new Uint8Array();\n      this.offset = 0;\n      if (next.done) { this.ended = true; this.iterator = undefined; return -1; }\n      if (!(next.value instanceof Uint8Array)) throw new TypeError(\"factor input requires bytes\");\n      budget.inputBytes(next.value.length);\n      budget.charge(next.value.length);\n      budget.retain(next.value.length);\n      this.chunk = Uint8Array.from(next.value);\n      if (!this.chunk.length) budget.check(++this.empties, budget.limits.maxEmptyChunks, \"empty input chunks\");\n    }\n    return this.chunk[this.offset++]!;\n  }\n  async next(): Promise<string | undefined> {\n    const { budget } = this.lifecycle;\n    let length = 0, kept = 0;\n    let nul = false;\n    for (;;) {\n      const value = await this.get();\n      if (value < 0 || value === 32 || value === 9 || value === 10) {\n        if (length) { budget.charge(kept); budget.retain(kept * 4); return raw(this.token.subarray(0, kept)); }\n        if (value < 0) return undefined;\n      } else {\n        budget.check(++length, budget.limits.maxTokenBytes, \"token bytes\");\n        if (value === 0) nul = true;\n        if (!nul) {\n          if (kept === this.token.length) {\n            const capacity = Math.min(budget.limits.maxTokenBytes, Math.max(64, this.token.length * 2));\n            budget.retain(capacity);\n            budget.charge(this.token.length);\n            const grown = new Uint8Array(capacity);\n            grown.set(this.token);\n            budget.retain(-this.token.length);\n            this.token = grown;\n          }\n          this.token[kept++] = value;\n        }\n      }\n    }\n  }\n}\n\nexport class RecordWriter {\n  private buffer: Uint8Array;\n  private used = 0;\n  constructor(readonly lifecycle: Lifecycle) {\n    lifecycle.budget.retain(1024);\n    this.buffer = new Uint8Array(1024);\n    lifecycle.cleanup(async () => { lifecycle.budget.retain(-this.buffer.length); this.buffer = new Uint8Array(); });\n  }\n  async append(record: string): Promise<void> {\n    const { budget } = this.lifecycle;\n    this.lifecycle.assertOpen();\n    budget.outputRoom(this.used + record.length);\n    budget.charge(record.length);\n    for (let offset = 0; offset < record.length; offset++) this.buffer[this.used++] = record.charCodeAt(offset);\n    if (this.used >= 512) {\n      let end = 512;\n      while (this.buffer[end - 1] !== 10) end--;\n      await this.lifecycle.write(this.buffer.subarray(0, end));\n      this.buffer.copyWithin(0, end, this.used);\n      this.used -= end;\n    }\n  }\n  async finish(): Promise<void> {\n    if (this.used) { await this.lifecycle.write(this.buffer.subarray(0, this.used)); this.used = 0; }\n  }\n}\n", "import { Budget } from \"./internal.js\";\n\nexport async function parseNumber(input: string, budget: Budget): Promise<number | \"invalid\" | \"large\"> {\n  let start = 0;\n  while (input[start] === \" \") { budget.charge(); start++; await budget.checkpointWork(); }\n  if (input[start] === \"+\") start++;\n  if (start === input.length) return \"invalid\";\n  let result = 0, large = false;\n  for (let offset = start; offset < input.length; offset++) {\n    budget.charge();\n    const digit = input.charCodeAt(offset) - 48;\n    if (digit < 0 || digit > 9) return \"invalid\";\n    if (!large) {\n      if (result > Math.floor((budget.limits.maxValue - digit) / 10)) large = true;\n      else result = result * 10 + digit;\n    }\n    await budget.checkpointWork();\n  }\n  return large ? \"large\" : result;\n}\n\nexport async function factorRecord(value: number, budget: Budget): Promise<string> {\n  let remaining = value;\n  const factors: number[] = [];\n  budget.retain(512);\n  try {\n    for (let divisor = 2; divisor * divisor <= remaining; divisor = divisor === 2 ? 3 : divisor + 2) {\n      for (;;) {\n        budget.charge();\n        await budget.checkpointWork();\n        if (remaining % divisor !== 0) break;\n        budget.charge(2);\n        factors.push(divisor);\n        remaining /= divisor;\n      }\n    }\n    if (remaining > 1) factors.push(remaining);\n    budget.charge(1 + factors.length * 11);\n    return `${value}:${factors.map(factor => ` ${factor}`).join(\"\")}\\n`;\n  } finally { budget.retain(-512); }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/packages/safe-bash/dist/chunks/{chunk-AVXYPKV7.js → chunk-QQHMFJHF.js}

@@ -1,10 +1,10 @@
 import {
   interruptible
-} from "./chunk-M7KZ7V4P.js";
+} from "./chunk-5X2TAR25.js";
 import {
   pathOf,
   writeDiagnostic
-} from "./chunk-5Y4AEZB2.js";
+} from "./chunk-7XJVLU37.js";
 import {
   FsError,
   getCommandArguments,
@@ -15,7 +15,7 @@ import {
   toByteSource,
   writeBytes,
   yieldTurn
-} from "./chunk-L2GZSOSJ.js";
+} from "./chunk-4NMFAR4Z.js";
 
 // packages/safe-bash/src/commands/xml/index.ts
 init_platform();
@@ -521,4 +521,4 @@ export {
   createXmlCommands,
   xmlCommands
 };
-//# sourceMappingURL=chunk-AVXYPKV7.js.map
+//# sourceMappingURL=chunk-QQHMFJHF.js.map

package/packages/safe-bash/dist/chunks/{chunk-QY2XHZTE.js → chunk-RDIJ6M2D.js}

@@ -1,12 +1,12 @@
 import {
   createOutputOperation
-} from "./chunk-PPVCI2F2.js";
+} from "./chunk-UL4TNDNV.js";
 import {
   FsError,
   createBytePipe,
   init_platform,
   outputFailure
-} from "./chunk-L2GZSOSJ.js";
+} from "./chunk-4NMFAR4Z.js";
 
 // packages/safe-bash/src/contracts/filesystem-output.ts
 init_platform();
@@ -189,4 +189,4 @@ export {
   writeFileOutput,
   openFileOutput
 };
-//# sourceMappingURL=chunk-QY2XHZTE.js.map
+//# sourceMappingURL=chunk-RDIJ6M2D.js.map

package/packages/safe-bash/dist/chunks/{chunk-PPVCI2F2.js → chunk-UL4TNDNV.js}

@@ -2,7 +2,7 @@ import {
   init_platform,
   outputFailure,
   writeBytes
-} from "./chunk-L2GZSOSJ.js";
+} from "./chunk-4NMFAR4Z.js";
 
 // packages/safe-bash/src/contracts/output.ts
 init_platform();
@@ -133,4 +133,4 @@ function createOutputOperation(context, destination) {
 export {
   createOutputOperation
 };
-//# sourceMappingURL=chunk-PPVCI2F2.js.map
+//# sourceMappingURL=chunk-UL4TNDNV.js.map