@poe-platform/safe-bash 0.1.756 → 0.1.757

package/dist/safe-bash/chunks/chunk-LMUKYZIJ.js

@@ -1,708 +0,0 @@
-import {
-  builtInDirectContextExecutors
-} from "./chunk-ISCZG7WA.js";
-import {
-  init_platform
-} from "./chunk-ZG7GWQ5P.js";
-
-// packages/safe-bash/src/commands/factor/index.ts
-init_platform();
-
-// packages/safe-bash-command-factor/src/index.ts
-init_platform();
-
-// packages/safe-bash-command-factor/src/command.ts
-init_platform();
-import { createOutputOperation } from "../../safe-bash-contracts/output.js";
-
-// packages/safe-bash-command-factor/src/internal.ts
-init_platform();
-import { getCommandArguments } from "../../safe-bash-contracts/index.js";
-import { shellValueByteLength, shellValueBytes } from "../../safe-bash-contracts/value.js";
-import { yieldTurn } from "../../safe-bash-contracts/yield.js";
-import { PublicDiagnostic } from "../../safe-bash-contracts/diagnostics.js";
-function settings(options) {
-  const limits = {
-    maxValue: Infinity,
-    maxArguments: Infinity,
-    maxArgumentBytes: Infinity,
-    maxInputBytes: Infinity,
-    maxTokenBytes: Infinity,
-    maxNumbers: Infinity,
-    maxBufferedBytes: Infinity,
-    maxOutputBytes: Infinity,
-    maxDiagnosticBytes: Infinity,
-    maxWork: Infinity,
-    maxEmptyChunks: Infinity,
-    ...options.limits
-  };
-  for (const [name, value] of Object.entries(limits)) {
-    if (name === "maxValue" && typeof value === "bigint" && value > 0n) continue;
-    if (value !== Infinity && (!Number.isSafeInteger(value) || value < 1)) throw new RangeError(`Invalid factor limit: ${name}`);
-  }
-  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) {
-  const out = new Uint8Array(value.length);
-  for (let i = 0; i < value.length; i++) out[i] = value.charCodeAt(i);
-  return out;
-}
-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;
-    this.pollSignal = Object.prototype.hasOwnProperty.call(signal, "aborted");
-    if (signal.aborted) {
-      this.signalAborted = true;
-    } else if (!this.pollSignal) {
-      signal.addEventListener("abort", () => {
-        this.signalAborted = true;
-      }, { once: true });
-    }
-  }
-  context;
-  limits;
-  signal;
-  work = 0;
-  checkpoint = 0;
-  retained = 0;
-  input = 0;
-  numbers = 0;
-  output = 0;
-  diagnostics = 0;
-  signalAborted = false;
-  pollSignal;
-  check(value, maximum, label) {
-    if ((value | 0) === value && value >= 0) {
-      if (value <= maximum) return;
-      throw new FactorError(`${label} limit exceeded`);
-    }
-    if (!Number.isSafeInteger(value) || value < 0 || value > maximum) throw new FactorError(`${label} limit exceeded`);
-  }
-  charge(amount = 1) {
-    if (this.signalAborted || this.pollSignal && this.signal.aborted) this.signal.throwIfAborted();
-    const next = this.work + amount;
-    this.check(next, this.limits.maxWork, "work");
-    this.work = next;
-  }
-  checkpointWork() {
-    if (this.signalAborted || this.pollSignal && this.signal.aborted) this.signal.throwIfAborted();
-    if (this.work - this.checkpoint < 1024) return;
-    this.checkpoint = this.work;
-    return 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-command-factor/src/io.ts
-init_platform();
-import { FsError } from "../../safe-bash-contracts/index.js";
-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;
-  get() {
-    const { budget } = this.lifecycle;
-    budget.charge();
-    const cp = budget.checkpointWork();
-    if (!cp && this.offset < this.chunk.length) return this.chunk[this.offset++];
-    return this.getSlow(cp);
-  }
-  async getSlow(cp) {
-    const { budget } = this.lifecycle;
-    if (cp) await cp;
-    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 r = this.get();
-      const value = typeof r === "number" ? r : await r;
-      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.retained = true;
-    this.buffer = new Uint8Array(1024);
-    lifecycle.cleanup(async () => {
-      if (this.retained) {
-        lifecycle.budget.retain(-1024);
-        this.retained = false;
-      }
-      this.buffer = new Uint8Array();
-    });
-  }
-  lifecycle;
-  buffer;
-  used = 0;
-  retained = false;
-  async append(record) {
-    const { budget } = this.lifecycle;
-    this.lifecycle.assertOpen();
-    budget.outputRoom(this.used + record.length);
-    budget.charge(record.length);
-    if (record.length > 512) {
-      await this.finish();
-      this.used = 0;
-      budget.retain(record.length);
-      try {
-        await this.lifecycle.write(bytes(record));
-      } finally {
-        budget.retain(-record.length);
-      }
-      return;
-    }
-    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--;
-      budget.retain(end);
-      try {
-        await this.lifecycle.write(this.buffer.slice(0, end));
-      } finally {
-        budget.retain(-end);
-      }
-      this.buffer.copyWithin(0, end, this.used);
-      this.used -= end;
-    }
-  }
-  async finish() {
-    if (this.used) {
-      const size = this.used;
-      this.lifecycle.budget.retain(size);
-      try {
-        await this.lifecycle.write(this.buffer.slice(0, size));
-        this.used = 0;
-      } finally {
-        this.lifecycle.budget.retain(-size);
-      }
-    }
-  }
-};
-
-// packages/safe-bash-command-factor/src/factor.ts
-init_platform();
-async function parseNumber(input, budget) {
-  let start = 0;
-  while (input[start] === " ") {
-    budget.charge();
-    start++;
-    {
-      const cp = budget.checkpointWork();
-      if (cp) await cp;
-    }
-  }
-  if (input[start] === "+") start++;
-  if (start === input.length) return "invalid";
-  const maximum = budget.limits.maxValue === Infinity ? void 0 : BigInt(budget.limits.maxValue);
-  let result = 0n, 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) {
-      result = result * 10n + BigInt(digit);
-      if (maximum !== void 0 && result > maximum) large = true;
-    }
-    {
-      const cp = budget.checkpointWork();
-      if (cp) await cp;
-    }
-  }
-  return large ? "large" : result;
-}
-async function prime64(value, budget) {
-  if (value >= 1n << 64n || value % 2n === 0n) return false;
-  let odd = value - 1n, powers = 0;
-  while (odd % 2n === 0n) {
-    odd /= 2n;
-    powers++;
-    budget.charge();
-  }
-  for (const witness of [2n, 325n, 9375n, 28178n, 450775n, 9780504n, 1795265022n]) {
-    let base = witness % value;
-    if (base === 0n) continue;
-    let exponent = odd, result = 1n;
-    while (exponent > 0n) {
-      budget.charge();
-      if (exponent % 2n) result = result * base % value;
-      base = base * base % value;
-      exponent /= 2n;
-      {
-        const cp = budget.checkpointWork();
-        if (cp) await cp;
-      }
-    }
-    if (result === 1n || result === value - 1n) continue;
-    let passed = false;
-    for (let power = 1; power < powers; power++) {
-      budget.charge();
-      result = result * result % value;
-      {
-        const cp = budget.checkpointWork();
-        if (cp) await cp;
-      }
-      if (result === value - 1n) {
-        passed = true;
-        break;
-      }
-    }
-    if (!passed) return false;
-  }
-  return true;
-}
-function prime32Sync(n) {
-  if (n < 2) return false;
-  if (n === 2 || n === 3 || n === 5 || n === 7) return true;
-  if ((n & 1) === 0 || n % 3 === 0) return false;
-  const bn = BigInt(n);
-  let odd = bn - 1n;
-  let powers = 0;
-  while ((odd & 1n) === 0n) {
-    odd >>= 1n;
-    powers++;
-  }
-  for (const witness of [2n, 7n, 61n]) {
-    if (bn <= witness) break;
-    let base = witness % bn;
-    if (base === 0n) continue;
-    let exp = odd;
-    let res = 1n;
-    while (exp > 0n) {
-      if ((exp & 1n) === 1n) res = res * base % bn;
-      base = base * base % bn;
-      exp >>= 1n;
-    }
-    if (res === 1n || res === bn - 1n) continue;
-    let passed = false;
-    for (let r = 1; r < powers; r++) {
-      res = res * res % bn;
-      if (res === bn - 1n) {
-        passed = true;
-        break;
-      }
-    }
-    if (!passed) return false;
-  }
-  return true;
-}
-async function factorRecord(value, budget, exponents) {
-  let remaining = value;
-  const factors = [];
-  let retained = 512, checkPrime = true;
-  const unlimitedWork = budget.limits.maxWork === Infinity;
-  budget.retain(retained);
-  try {
-    for (let divisor = 2n; divisor * divisor <= remaining; divisor = divisor === 2n ? 3n : divisor + 2n) {
-      if (checkPrime && unlimitedWork && remaining > 256n && remaining <= 4294967295n && prime32Sync(Number(remaining))) {
-        budget.charge(1024);
-        {
-          const cp = budget.checkpointWork();
-          if (cp) await cp;
-        }
-        break;
-      }
-      if (checkPrime && remaining > 4294967295n && await prime64(remaining, budget)) break;
-      checkPrime = false;
-      for (; ; ) {
-        budget.charge();
-        {
-          const cp = budget.checkpointWork();
-          if (cp) await cp;
-        }
-        if (remaining % divisor !== 0n) break;
-        budget.charge(2);
-        budget.retain(16);
-        retained += 16;
-        factors.push(divisor);
-        remaining /= divisor;
-        checkPrime = true;
-      }
-    }
-    if (remaining > 1n) factors.push(remaining);
-    budget.charge(1 + factors.length * 11);
-    let record = `${value}:`;
-    for (let index = 0; index < factors.length; index++) {
-      const factor = factors[index];
-      let exponent = 1;
-      if (exponents) {
-        while (factors[index + 1] === factor) {
-          exponent++;
-          index++;
-        }
-      }
-      const part = ` ${factor}${exponent > 1 ? `^${exponent}` : ""}`;
-      budget.outputRoom(record.length + part.length + 1);
-      budget.retain(part.length * 2);
-      retained += part.length * 2;
-      record += part;
-    }
-    return `${record}
-`;
-  } finally {
-    budget.retain(-retained);
-  }
-}
-
-// packages/safe-bash-command-factor/src/command.ts
-function createFactorCommand(options = {}) {
-  const limits = settings(options);
-  return { name: "factor", description: "Print prime factors of 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, exponents = 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", "exponents", "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 if (matched === "exponents") exponents = true;
-          else {
-            information = matched;
-            break;
-          }
-        } else {
-          if (!optionsEnded && argument.length > 1 && argument.startsWith("-")) {
-            for (let index = 1; index < argument.length; index++) {
-              if (argument[index] !== "h") throw new FactorError(`invalid option -- '${argument[index]}'`, true);
-              exponents = true;
-            }
-            continue;
-          }
-          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: --exponents (print repeated factors as powers) --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, exponents));
-          }
-        };
-        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-command-factor/src/index.ts
-function createFactorCommand2(options = {}) {
-  const def = createFactorCommand(options);
-  builtInDirectContextExecutors.add(def.execute);
-  return def;
-}
-function createFactorCommands(options = {}) {
-  return [createFactorCommand2(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 {
-  createFactorCommand2 as createFactorCommand,
-  createFactorCommands,
-  factorCommands
-};
-//# sourceMappingURL=chunk-LMUKYZIJ.js.map