@poe-platform/safe-bash 0.1.756 → 0.1.757

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

@@ -1,2955 +0,0 @@
-import {
-  builtInDirectContextExecutors
-} from "./chunk-ISCZG7WA.js";
-import {
-  init_platform
-} from "./chunk-ZG7GWQ5P.js";
-
-// packages/safe-bash/src/commands/iconv/index.ts
-init_platform();
-
-// packages/safe-bash-command-iconv/src/index.ts
-init_platform();
-
-// packages/safe-bash-command-iconv/src/command.ts
-init_platform();
-import { FsError as FsError2, resolvePath as resolvePath2 } from "../../safe-bash-contracts/index.js";
-import { openFileOutput } from "../../safe-bash-contracts/filesystem-output.js";
-import { createOutputOperation } from "../../safe-bash-contracts/output.js";
-import { outputFailure } from "../../safe-bash-contracts/io.js";
-
-// packages/safe-bash-command-iconv/src/internal.ts
-init_platform();
-import { getCommandArguments } from "../../safe-bash-contracts/index.js";
-import { shellValueByteLength, shellValueBytes } from "../../safe-bash-contracts/value.js";
-import { hasYieldCheckpoint, monotonicNow, runYieldCheckpoint, yieldTurn } from "../../safe-bash-contracts/yield.js";
-import { PublicDiagnostic } from "../../safe-bash-contracts/diagnostics.js";
-function settings(options) {
-  const limits = {
-    maxArguments: Infinity,
-    maxArgumentBytes: Infinity,
-    maxInputBytes: Infinity,
-    maxBufferedBytes: Infinity,
-    maxOutputBytes: Infinity,
-    maxDiagnosticBytes: Infinity,
-    maxWork: Infinity,
-    maxChunks: Infinity,
-    maxEmptyChunks: Infinity,
-    ...options.limits
-  };
-  for (const [name, value] of Object.entries(options.limits ?? {})) {
-    if (value !== Infinity && (!Number.isSafeInteger(value) || value < 1)) throw new RangeError(`Invalid iconv limit: ${name}`);
-  }
-  return Object.freeze(limits);
-}
-var IconvError = class extends PublicDiagnostic {
-  constructor(message, status = 1) {
-    super(message);
-    this.status = status;
-  }
-  status;
-};
-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 pathText(value) {
-  try {
-    return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(Uint8Array.from(value, (character) => character.charCodeAt(0)));
-  } catch {
-    throw new IconvError("filesystem paths must be valid UTF-8");
-  }
-}
-var Budget = class {
-  constructor(context, limits, signal, callerSignal, admission) {
-    this.context = context;
-    this.limits = limits;
-    this.signal = signal;
-    this.callerSignal = callerSignal;
-    this.admission = admission;
-    this.signalAborted = signal.aborted;
-    this.pollSignal = Object.prototype.hasOwnProperty.call(signal, "aborted");
-    if (!this.signalAborted && !this.pollSignal) {
-      signal.addEventListener("abort", () => {
-        this.signalAborted = true;
-      }, { once: true });
-    }
-  }
-  context;
-  limits;
-  signal;
-  callerSignal;
-  admission;
-  work = 0;
-  checkpoint = 0;
-  checkpointCount = 0;
-  lastYield = monotonicNow();
-  retained = 0;
-  input = 0;
-  output = 0;
-  diagnostics = 0;
-  chunks = 0;
-  empties = 0;
-  signalAborted;
-  pollSignal;
-  assertOpen() {
-    if (this.pollSignal ? this.signal.aborted : this.signalAborted) this.signal.throwIfAborted();
-    if (this.admission.closed) throw new IconvError("command is closed");
-  }
-  check(value, maximum, label) {
-    if (value > maximum || value < 0 || (value | 0) !== value && !Number.isSafeInteger(value)) throw new IconvError(`${label} limit exceeded`);
-  }
-  charge(amount = 1) {
-    this.assertOpen();
-    this.check(this.work + amount, this.limits.maxWork, "work");
-    this.work += amount;
-  }
-  checkpointWork() {
-    this.assertOpen();
-    if (this.work - this.checkpoint < 4096) return;
-    this.checkpoint = this.work;
-    const count = ++this.checkpointCount;
-    const now = monotonicNow();
-    if (count === 1 || now - this.lastYield >= 16 || hasYieldCheckpoint(this.callerSignal)) {
-      this.lastYield = now;
-      return yieldTurn(this.callerSignal).then(() => {
-        this.lastYield = monotonicNow();
-        this.assertOpen();
-      });
-    }
-    runYieldCheckpoint(this.callerSignal);
-    this.assertOpen();
-  }
-  retain(amount) {
-    this.check(this.retained + amount, this.limits.maxBufferedBytes, "buffered bytes");
-    this.retained += amount;
-  }
-  snapshotMaximum() {
-    return Math.min(this.limits.maxInputBytes - this.input, Math.floor((this.limits.maxBufferedBytes - this.retained) / 2));
-  }
-  inputBytes(amount) {
-    this.check(this.input + amount, this.limits.maxInputBytes, "input bytes");
-    this.input += amount;
-    this.check(++this.chunks, this.limits.maxChunks, "input chunks");
-    if (!amount) this.check(++this.empties, this.limits.maxEmptyChunks, "empty input chunks");
-    this.charge(amount + 1);
-  }
-  emitted(amount, diagnostic) {
-    if (diagnostic) {
-      this.check(this.diagnostics + amount, this.limits.maxDiagnosticBytes, "diagnostic bytes");
-      this.diagnostics += amount;
-    } else {
-      this.check(this.output + amount, this.limits.maxOutputBytes, "output bytes");
-      this.charge(amount);
-      this.output += amount;
-    }
-  }
-  arguments() {
-    this.assertOpen();
-    const args = this.context.args;
-    this.assertOpen();
-    const count = args.length;
-    this.assertOpen();
-    this.check(count, this.limits.maxArguments, "argument count");
-    const argumentValues = this.context.argumentValues;
-    this.assertOpen();
-    const carrier = argumentValues === void 0 ? void 0 : getCommandArguments({ args, argumentValues });
-    this.assertOpen();
-    this.retain(count * 64 + 128);
-    const snapshot = [];
-    let units = 0, total = 0;
-    for (let index = 0; index < count; index++) {
-      const argument = args[index];
-      this.assertOpen();
-      if (typeof argument !== "string") throw new IconvError("arguments must be strings");
-      units += argument.length;
-      this.check(units, this.limits.maxArgumentBytes, "argument bytes");
-      this.charge(argument.length + 1);
-      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 IconvError("arguments must contain well-formed Unicode");
-        } else if (unit >= 56320 && unit <= 57343) throw new IconvError("arguments must contain well-formed Unicode");
-      }
-      const size = shellValueByteLength(carrier ? carrier.values[index] : argument);
-      total += size;
-      this.check(total, this.limits.maxArgumentBytes, "argument bytes");
-      this.charge(size);
-      this.retain(size * 8);
-      snapshot.push(argument);
-    }
-    return (carrier ?? getCommandArguments({ args: snapshot })).values.map((argument) => {
-      this.charge(shellValueByteLength(argument));
-      const value = shellValueBytes(argument);
-      if (value.includes(0)) throw new IconvError("NUL is not supported in arguments");
-      return raw(value);
-    });
-  }
-};
-
-// packages/safe-bash-command-iconv/src/lifecycle.ts
-init_platform();
-var Lifecycle = class {
-  constructor(budget, output, stdout) {
-    this.budget = budget;
-    this.stdout = stdout;
-    output.registerCleanup(() => this.close());
-  }
-  budget;
-  stdout;
-  pending = /* @__PURE__ */ new Set();
-  cleanups = /* @__PURE__ */ new Set();
-  closing;
-  diagnosticDestination;
-  diagnosticCancellation;
-  cleanup(action) {
-    this.assertOpen();
-    this.cleanups.add(action);
-  }
-  forget(action) {
-    this.cleanups.delete(action);
-  }
-  assertOpen() {
-    this.budget.assertOpen();
-    if (this.closing) throw new IconvError("command is closed");
-  }
-  assertDiagnosticOpen() {
-    this.budget.callerSignal.throwIfAborted();
-    const consumer = this.diagnosticDestination?.consumer;
-    if (consumer?.aborted) {
-      this.diagnosticCancellation = { reason: consumer.reason };
-      consumer.throwIfAborted();
-    }
-  }
-  async operation(action, diagnostic = false) {
-    if (diagnostic) this.assertDiagnosticOpen();
-    else this.assertOpen();
-    if (this.closing || this.budget.admission.closed) throw new IconvError("command is closed");
-    if (!diagnostic) this.budget.charge();
-    const pending = Promise.resolve().then(() => {
-      if (diagnostic) this.assertDiagnosticOpen();
-      else this.assertOpen();
-      return action();
-    });
-    this.pending.add(pending);
-    try {
-      const value = await pending;
-      if (diagnostic) this.assertDiagnosticOpen();
-      else 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, "iconv cleanup failed");
-    });
-  }
-  async write(value, diagnostic = false) {
-    this.budget.emitted(value.length, diagnostic);
-    await this.operation(async () => {
-      let destination;
-      if (diagnostic) {
-        if (!this.diagnosticDestination) {
-          const sink = this.budget.context.stderr;
-          this.assertDiagnosticOpen();
-          const capability = sink.ownedOutput;
-          this.assertDiagnosticOpen();
-          const consumer = capability?.consumerClosed;
-          this.diagnosticDestination = { destination: capability ?? sink, consumer };
-        }
-        this.assertDiagnosticOpen();
-        destination = this.diagnosticDestination.destination;
-      } else {
-        destination = this.stdout;
-        this.assertOpen();
-      }
-      const write = destination.write;
-      if (diagnostic) this.assertDiagnosticOpen();
-      else this.assertOpen();
-      await Reflect.apply(write, destination, [value]);
-    }, diagnostic);
-  }
-  async diagnostic(message) {
-    this.budget.check(message.length * 3 + 8, this.budget.limits.maxDiagnosticBytes, "diagnostic bytes");
-    await this.write(new TextEncoder().encode(`iconv: ${message}
-`), true);
-  }
-};
-
-// packages/safe-bash-command-iconv/src/reader.ts
-init_platform();
-import { FsError, resolvePath } from "../../safe-bash-contracts/index.js";
-var typedArrayPrototype = Object.getPrototypeOf(Uint8Array.prototype);
-var viewBuffer = Object.getOwnPropertyDescriptor(typedArrayPrototype, "buffer").get;
-var viewOffset = Object.getOwnPropertyDescriptor(typedArrayPrototype, "byteOffset").get;
-var viewLength = Object.getOwnPropertyDescriptor(typedArrayPrototype, "byteLength").get;
-var Reader = class {
-  constructor(name, lifecycle) {
-    this.name = name;
-    this.lifecycle = lifecycle;
-    lifecycle.budget.retain(256);
-    lifecycle.cleanup(this.close);
-  }
-  name;
-  lifecycle;
-  iterator;
-  ended = false;
-  retained = 0;
-  closed;
-  chunks = [];
-  content;
-  readError;
-  stage = "open";
-  close = () => this.closed ??= Promise.resolve().then(async () => {
-    try {
-      if (!this.ended) await this.iterator?.return?.();
-    } finally {
-      this.iterator = void 0;
-      this.content = void 0;
-      this.chunks.length = 0;
-      this.lifecycle.budget.retain(-this.retained - 256);
-      this.retained = 0;
-      this.lifecycle.forget(this.close);
-    }
-  });
-  copy(value) {
-    if (!(value instanceof Uint8Array)) throw new TypeError("iconv input requires bytes");
-    const buffer = viewBuffer.call(value);
-    const offset = viewOffset.call(value);
-    const size = viewLength.call(value);
-    this.lifecycle.assertOpen();
-    this.lifecycle.budget.inputBytes(size);
-    this.lifecycle.budget.retain(size);
-    try {
-      const copy = new Uint8Array(new Uint8Array(buffer, offset, size));
-      this.retained += size;
-      return copy;
-    } catch (error) {
-      this.lifecycle.budget.retain(-size);
-      throw error;
-    }
-  }
-  async open() {
-    const { budget } = this.lifecycle;
-    await this.lifecycle.operation(async () => {
-      let source;
-      let needsAcquisitionCleanup = false;
-      if (this.name === "-") {
-        source = budget.context.stdin;
-        this.stage = "read";
-      } else {
-        if (this.name === "") throw new FsError("ENOENT", { path: "" });
-        const cwd = budget.context.cwd;
-        this.lifecycle.assertOpen();
-        const path = resolvePath(cwd, pathText(this.name));
-        const fs = budget.context.fs;
-        this.lifecycle.assertOpen();
-        const statMethod = fs.stat;
-        this.lifecycle.assertOpen();
-        const stat = await Reflect.apply(statMethod, fs, [path, { signal: budget.signal }]);
-        this.lifecycle.assertOpen();
-        const type = stat.type;
-        this.lifecycle.assertOpen();
-        if (this.name.endsWith("/") && type !== "directory") throw new FsError("ENOTDIR", { path });
-        this.stage = "read";
-        if (type === "directory") {
-          this.readError = new FsError("EISDIR", { path });
-          return;
-        }
-        if (type !== "file" && type !== "character") throw new FsError("ENOTSUP", { path });
-        const capabilitiesFor = fs.capabilitiesFor;
-        this.lifecycle.assertOpen();
-        const selected = capabilitiesFor ? await Reflect.apply(capabilitiesFor, fs, [path, { signal: budget.signal }]) : void 0;
-        this.lifecycle.assertOpen();
-        const capabilities = selected ?? fs.capabilities;
-        this.lifecycle.assertOpen();
-        const streamingRead = capabilities.streamingRead;
-        this.lifecycle.assertOpen();
-        const readStream = fs.readStream;
-        this.lifecycle.assertOpen();
-        if (readStream && streamingRead !== false) {
-          source = Reflect.apply(readStream, fs, [path, { signal: budget.signal, chunkSize: 16384 }]);
-          needsAcquisitionCleanup = budget.signal.aborted || budget.admission.closed;
-        } else {
-          const maximum = budget.snapshotMaximum();
-          const size = stat.size;
-          this.lifecycle.assertOpen();
-          budget.check(size, maximum, "buffered input bytes");
-          budget.retain(Number.isFinite(maximum) ? maximum : size);
-          try {
-            const readFile = fs.readFile;
-            this.lifecycle.assertOpen();
-            const content = await Reflect.apply(readFile, fs, [path, { signal: budget.signal, ...Number.isFinite(maximum) ? { maxBytes: maximum } : {} }]);
-            this.lifecycle.assertOpen();
-            if (!(content instanceof Uint8Array)) throw new TypeError("iconv input requires bytes");
-            const length = viewLength.call(content);
-            this.lifecycle.assertOpen();
-            budget.check(length, maximum, "buffered input bytes");
-            this.content = this.copy(content);
-            this.ended = true;
-          } finally {
-            budget.retain(-(Number.isFinite(maximum) ? maximum : size));
-          }
-          return;
-        }
-      }
-      if (!needsAcquisitionCleanup) this.lifecycle.assertOpen();
-      const factory = source[Symbol.asyncIterator];
-      if (!needsAcquisitionCleanup) this.lifecycle.assertOpen();
-      this.iterator = Reflect.apply(factory, source, []);
-    });
-  }
-  async all() {
-    if (this.readError) throw this.readError;
-    if (this.content) return this.content;
-    const { budget } = this.lifecycle;
-    let length = 0;
-    while (!this.ended) {
-      const result = await this.lifecycle.operation(() => {
-        const iterator = this.iterator;
-        const next = iterator.next;
-        this.lifecycle.assertOpen();
-        return Reflect.apply(next, iterator, []);
-      });
-      const done = result.done;
-      this.lifecycle.assertOpen();
-      if (done) {
-        this.ended = true;
-        this.iterator = void 0;
-        break;
-      }
-      const value = result.value;
-      this.lifecycle.assertOpen();
-      const owned = this.copy(value);
-      budget.retain(64);
-      this.retained += 64;
-      this.chunks.push(owned);
-      length += owned.length;
-      {
-        const cp = budget.checkpointWork();
-        if (cp) await cp;
-      }
-    }
-    budget.retain(length);
-    this.retained += length;
-    const content = new Uint8Array(length);
-    let offset = 0;
-    for (const chunk of this.chunks) {
-      content.set(chunk, offset);
-      offset += chunk.length;
-      budget.charge(chunk.length + 1);
-      {
-        const cp = budget.checkpointWork();
-        if (cp) await cp;
-      }
-    }
-    budget.retain(-length - this.chunks.length * 64);
-    this.retained -= length + this.chunks.length * 64;
-    this.chunks.length = 0;
-    this.content = content;
-    return content;
-  }
-};
-function fsDetail(error) {
-  const details = {
-    EACCES: "Permission denied",
-    EPERM: "Operation not permitted",
-    ENOENT: "No such file or directory",
-    EISDIR: "Is a directory",
-    ENOTDIR: "Not a directory",
-    EIO: "Input/output error",
-    ELOOP: "Too many levels of symbolic links",
-    ENAMETOOLONG: "File name too long",
-    ENOTSUP: "Operation not supported"
-  };
-  return details[error.code] ?? error.message;
-}
-
-// packages/safe-bash-command-iconv/src/options.ts
-init_platform();
-var aliases = {
-  ASCII: "ascii",
-  "US-ASCII": "ascii",
-  "ANSI_X3.4-1968": "ascii",
-  LATIN1: "latin1",
-  "LATIN-1": "latin1",
-  "ISO-8859-1": "latin1",
-  "ISO8859-1": "latin1",
-  UTF8: "utf8",
-  "UTF-8": "utf8",
-  UTF16: "utf16",
-  "UTF-16": "utf16",
-  UTF16LE: "utf16le",
-  "UTF-16LE": "utf16le",
-  UTF16BE: "utf16be",
-  "UTF-16BE": "utf16be"
-};
-function encoding(value) {
-  const key = value.toUpperCase();
-  if (key.includes("//")) throw new IconvError(`unsupported encoding suffix: ${value}`);
-  const result = Object.hasOwn(aliases, key) ? aliases[key] : void 0;
-  if (!result) throw new IconvError(`unsupported encoding: ${value}`);
-  return result;
-}
-var usage = "Usage: iconv [-lcs?V] [-f NAME] [-t NAME] [-o FILE] [--from-code=NAME]\n             [--to-code=NAME] [--list] [--output=FILE] [--silent] [--verbose]\n             [--help] [--usage] [--version] [FILE...]\n";
-var information = {
-  l: Object.keys(aliases).sort().map((name) => `${name}//
-`).join(""),
-  "?": usage + "Convert text using the safe-bash bounded encoding engine.\n  -f, --from-code=NAME  input encoding\n  -t, --to-code=NAME    output encoding\n  -l, --list            list supported encodings and aliases\n  -c                    omit invalid characters\n  -o, --output=FILE     virtual output file (- for stdout)\n  -s, --silent          suppress warnings\n      --verbose         report input operands\n  -?, --help            show help\n      --usage           show usage\n  -V, --version         show engine identity\n",
-  V: "iconv (safe-bash bounded encoding engine)\n"
-};
-function parse(budget) {
-  const args = budget.arguments();
-  let from, to, output, discard = false, ended = false;
-  let verbose = false;
-  const files = [];
-  for (let index = 0; index < args.length; index++) {
-    const argument = args[index];
-    budget.charge(argument.length + 1);
-    if (ended || argument === "-" || !argument.startsWith("-")) {
-      files.push(argument);
-      continue;
-    }
-    if (argument === "--") {
-      ended = true;
-      continue;
-    }
-    if (argument === "--list") return { information: information.l };
-    if (argument === "--help") return { information: information["?"] };
-    if (argument === "--version") return { information: information.V };
-    if (argument === "--usage") return { information: usage };
-    if (argument === "--silent") continue;
-    if (argument === "--verbose") {
-      verbose = true;
-      continue;
-    }
-    if (argument.startsWith("--")) {
-      const equals = argument.indexOf("=");
-      const option = equals < 0 ? argument : argument.slice(0, equals);
-      if (option !== "--from-code" && option !== "--to-code" && option !== "--output") throw new IconvError(`unsupported option: ${argument}`, 64);
-      const value = equals < 0 ? args[++index] : argument.slice(equals + 1);
-      if (value === void 0) throw new IconvError(`option '${option}' requires an argument`, 64);
-      if (option === "--from-code") from = value;
-      else if (option === "--to-code") to = value;
-      else output = value;
-      continue;
-    }
-    for (let offset = 1; offset < argument.length; offset++) {
-      const flag = argument[offset];
-      if (Object.hasOwn(information, flag)) return { information: information[flag] };
-      if (flag === "c") {
-        discard = true;
-        continue;
-      }
-      if (flag === "s") continue;
-      if (flag !== "f" && flag !== "t" && flag !== "o") throw new IconvError(`invalid option -- '${flag}'`, 64);
-      const value = argument.slice(offset + 1) || args[++index];
-      if (value === void 0) throw new IconvError(`option requires an argument -- '${flag}'`, 64);
-      if (flag === "f") from = value;
-      else if (flag === "t") to = value;
-      else output = value;
-      break;
-    }
-  }
-  let transliterate = false;
-  if (to !== void 0) {
-    const [name, ...suffixes] = to.split("//");
-    for (const suffix of suffixes) {
-      if (suffix.toUpperCase() === "TRANSLIT") transliterate = true;
-      else if (suffix.toUpperCase() === "IGNORE") discard = true;
-      else throw new IconvError(`unsupported encoding suffix: ${to}`);
-    }
-    to = name;
-  }
-  if (from === void 0 || to === void 0 || transliterate) {
-    const env = budget.context.env;
-    budget.assertOpen();
-    let locale = "";
-    for (const name of ["LC_ALL", "LC_CTYPE", "LANG"]) {
-      locale = env[name] || "";
-      budget.assertOpen();
-      budget.check(locale.length, budget.limits.maxArgumentBytes, "locale bytes");
-      budget.charge(locale.length + 1);
-      if (locale) break;
-    }
-    locale ||= "C";
-    if (transliterate && locale !== "C" && locale !== "POSIX") throw new IconvError(`unsupported transliteration locale: ${locale}; supported: C, POSIX, or unset`);
-    let fallback;
-    if (locale === "C" || locale === "POSIX") fallback = "ASCII";
-    else if (locale === "C.UTF-8" || locale === "C.utf8") fallback = "UTF-8";
-    else throw new IconvError(`unsupported default encoding locale: ${locale}; specify -f and -t`);
-    from ??= fallback;
-    to ??= fallback;
-  }
-  return { from: encoding(from), to: encoding(to), discard, transliterate, files: files.length ? files : ["-"], output, verbose };
-}
-
-// packages/safe-bash-command-iconv/src/codec.ts
-init_platform();
-
-// packages/safe-bash-command-iconv/src/transliterations.ts
-init_platform();
-var cTransliterations = Object.freeze({
-  160: " ",
-  169: "(C)",
-  171: "<<",
-  173: "-",
-  174: "(R)",
-  181: "u",
-  184: ",",
-  187: ">>",
-  188: " 1/4 ",
-  189: " 1/2 ",
-  190: " 3/4 ",
-  198: "AE",
-  215: "x",
-  223: "ss",
-  230: "ae",
-  306: "IJ",
-  307: "ij",
-  329: "'n",
-  338: "OE",
-  339: "oe",
-  383: "s",
-  455: "LJ",
-  456: "Lj",
-  457: "lj",
-  458: "NJ",
-  459: "Nj",
-  460: "nj",
-  497: "DZ",
-  498: "Dz",
-  499: "dz",
-  700: "'",
-  710: "^",
-  712: "'",
-  715: "`",
-  717: "_",
-  720: ":",
-  732: "~",
-  880: "H",
-  881: "h",
-  882: "SS",
-  883: "ss",
-  884: "#",
-  885: "#`",
-  886: "W",
-  887: "w",
-  890: "i",
-  891: "s",
-  892: "s",
-  893: "s",
-  895: "J",
-  900: "`",
-  901: "`",
-  902: "A",
-  903: ";",
-  904: "E",
-  905: "I",
-  906: "I",
-  908: "O",
-  910: "Y",
-  911: "O",
-  912: "I",
-  913: "A",
-  914: "V",
-  915: "G",
-  916: "D",
-  917: "E",
-  918: "Z",
-  919: "I",
-  920: "TH",
-  921: "I",
-  922: "K",
-  923: "L",
-  924: "M",
-  925: "N",
-  926: "X",
-  927: "O",
-  928: "P",
-  929: "R",
-  931: "S",
-  932: "T",
-  933: "Y",
-  934: "F",
-  935: "CH",
-  936: "PS",
-  937: "O",
-  938: "I",
-  939: "Y",
-  940: "a",
-  941: "e",
-  942: "i",
-  943: "i",
-  944: "y",
-  945: "a",
-  946: "v",
-  947: "g",
-  948: "d",
-  949: "e",
-  950: "z",
-  951: "i",
-  952: "th",
-  953: "i",
-  954: "k",
-  955: "l",
-  956: "m",
-  957: "n",
-  958: "x",
-  959: "o",
-  960: "p",
-  961: "r",
-  962: "s",
-  963: "s",
-  964: "t",
-  965: "y",
-  966: "f",
-  967: "ch",
-  968: "ps",
-  969: "o",
-  970: "i",
-  971: "y",
-  972: "o",
-  973: "y",
-  974: "o",
-  975: "&",
-  976: "b",
-  977: "th",
-  978: "Y`",
-  979: "Y`",
-  980: "Y`",
-  981: "f",
-  982: "p",
-  983: "&",
-  984: "Q",
-  985: "q",
-  986: "6",
-  987: "6",
-  988: "W",
-  989: "w",
-  990: "90",
-  991: "90",
-  992: "900",
-  993: "900",
-  994: "SH",
-  995: "sh",
-  996: "F",
-  997: "f",
-  998: "KH",
-  999: "kh",
-  1e3: "H",
-  1001: "h",
-  1002: "DJ",
-  1003: "dj",
-  1004: "GJ",
-  1005: "gj",
-  1006: "TI",
-  1007: "ti",
-  1008: "k",
-  1009: "r",
-  1010: "s",
-  1011: "j",
-  1012: "TH",
-  1013: "e",
-  1014: "e",
-  1015: "SH",
-  1016: "sh",
-  1017: "S",
-  1018: "S",
-  1019: "s",
-  1020: "r",
-  1021: "S",
-  1022: "S",
-  1023: "S",
-  1025: "YO",
-  1026: "DJ",
-  1027: "G`",
-  1028: "YE",
-  1029: "Z`",
-  1030: "I",
-  1031: "YI",
-  1032: "J",
-  1033: "L`",
-  1034: "N`",
-  1035: "TSH",
-  1036: "K`",
-  1038: "U`",
-  1039: "DH",
-  1040: "A",
-  1041: "B",
-  1042: "V",
-  1043: "G",
-  1044: "D",
-  1045: "E",
-  1046: "ZH",
-  1047: "Z",
-  1048: "I",
-  1049: "J",
-  1050: "K",
-  1051: "L",
-  1052: "M",
-  1053: "N",
-  1054: "O",
-  1055: "P",
-  1056: "R",
-  1057: "S",
-  1058: "T",
-  1059: "U",
-  1060: "F",
-  1061: "X",
-  1062: "CZ",
-  1063: "CH",
-  1064: "SH",
-  1065: "SHH",
-  1066: "A`",
-  1067: "Y`",
-  1068: "`",
-  1069: "E`",
-  1070: "YU",
-  1071: "YA",
-  1072: "a",
-  1073: "b",
-  1074: "v",
-  1075: "g",
-  1076: "d",
-  1077: "e",
-  1078: "zh",
-  1079: "z",
-  1080: "i",
-  1081: "j",
-  1082: "k",
-  1083: "l",
-  1084: "m",
-  1085: "n",
-  1086: "o",
-  1087: "p",
-  1088: "r",
-  1089: "s",
-  1090: "t",
-  1091: "u",
-  1092: "f",
-  1093: "x",
-  1094: "cz",
-  1095: "ch",
-  1096: "sh",
-  1097: "shh",
-  1098: "``",
-  1099: "y`",
-  1100: "`",
-  1101: "e`",
-  1102: "yu",
-  1103: "ya",
-  1105: "yo",
-  1106: "dj",
-  1107: "g`",
-  1108: "ye",
-  1109: "z`",
-  1110: "i",
-  1111: "yi",
-  1112: "j",
-  1113: "l`",
-  1114: "n`",
-  1115: "tsh",
-  1116: "k`",
-  1118: "u`",
-  1119: "dh",
-  1130: "O`",
-  1131: "o`",
-  1138: "FH",
-  1139: "fh",
-  1140: "YH",
-  1141: "yh",
-  1164: "E`",
-  1165: "e`",
-  1168: "G`",
-  1169: "g`",
-  1170: "GH",
-  1171: "gh",
-  1172: "GH",
-  1173: "gh",
-  1174: "ZH`",
-  1175: "zh`",
-  1178: "K`",
-  1179: "k`",
-  1182: "K`",
-  1183: "k`",
-  1186: "N`",
-  1187: "n`",
-  1188: "NG",
-  1189: "ng",
-  1190: "P`",
-  1191: "p`",
-  1192: "O`",
-  1193: "o`",
-  1194: "C`",
-  1195: "C`",
-  1196: "T`",
-  1197: "t`",
-  1198: "U",
-  1199: "u",
-  1202: "H`",
-  1203: "h`",
-  1204: "TCZ",
-  1205: "tcz",
-  1210: "SH`",
-  1211: "sh`",
-  1212: "CH`",
-  1213: "ch`",
-  1214: "CH`",
-  1215: "ch`",
-  1216: "i",
-  1217: "ZH`",
-  1218: "zh`",
-  1227: "CH`",
-  1228: "ch`",
-  1232: "A`",
-  1233: "a`",
-  1234: "A`",
-  1235: "a`",
-  1238: "E`",
-  1239: "e`",
-  1240: "A`",
-  1241: "a`",
-  1244: "ZH`",
-  1245: "zh`",
-  1246: "Z`",
-  1247: "z`",
-  1248: "Z`",
-  1249: "z`",
-  1252: "I`",
-  1253: "i`",
-  1254: "O`",
-  1255: "o`",
-  1256: "O`",
-  1257: "o`",
-  1264: "U`",
-  1265: "u`",
-  1266: "U`",
-  1267: "u`",
-  1268: "CH`",
-  1269: "ch`",
-  1272: "Y`",
-  1273: "y`",
-  8194: " ",
-  8195: " ",
-  8196: " ",
-  8197: " ",
-  8198: " ",
-  8200: " ",
-  8201: " ",
-  8202: " ",
-  8203: "",
-  8208: "-",
-  8209: "-",
-  8210: "-",
-  8211: "-",
-  8212: "--",
-  8213: "-",
-  8216: "'",
-  8217: "'",
-  8218: ",",
-  8219: "'",
-  8220: '"',
-  8221: '"',
-  8222: ",,",
-  8223: '"',
-  8224: "+",
-  8226: "o",
-  8228: ".",
-  8229: "..",
-  8230: "...",
-  8239: " ",
-  8245: "`",
-  8246: "``",
-  8247: "```",
-  8249: "<",
-  8250: ">",
-  8252: "!!",
-  8260: "/",
-  8263: "??",
-  8264: "?!",
-  8265: "!?",
-  8287: " ",
-  8288: "",
-  8289: "",
-  8290: "",
-  8291: "",
-  8353: "C=",
-  8360: "Rs",
-  8364: "EUR",
-  8377: "INR",
-  8448: "a/c",
-  8449: "a/s",
-  8450: "C",
-  8453: "c/o",
-  8454: "c/u",
-  8458: "g",
-  8459: "H",
-  8460: "H",
-  8461: "H",
-  8462: "h",
-  8464: "I",
-  8465: "I",
-  8466: "L",
-  8467: "l",
-  8469: "N",
-  8470: "No",
-  8473: "P",
-  8474: "Q",
-  8475: "R",
-  8476: "R",
-  8477: "R",
-  8481: "TEL",
-  8482: "(TM)",
-  8484: "Z",
-  8486: "Ohm",
-  8488: "Z",
-  8492: "B",
-  8493: "C",
-  8494: "e",
-  8495: "e",
-  8496: "E",
-  8497: "F",
-  8499: "M",
-  8500: "o",
-  8505: "i",
-  8517: "D",
-  8518: "d",
-  8519: "e",
-  8520: "i",
-  8521: "j",
-  8531: " 1/3 ",
-  8532: " 2/3 ",
-  8533: " 1/5 ",
-  8534: " 2/5 ",
-  8535: " 3/5 ",
-  8536: " 4/5 ",
-  8537: " 1/6 ",
-  8538: " 5/6 ",
-  8539: " 1/8 ",
-  8540: " 3/8 ",
-  8541: " 5/8 ",
-  8542: " 7/8 ",
-  8543: " 1/",
-  8544: "I",
-  8545: "II",
-  8546: "III",
-  8547: "IV",
-  8548: "V",
-  8549: "VI",
-  8550: "VII",
-  8551: "VIII",
-  8552: "IX",
-  8553: "X",
-  8554: "XI",
-  8555: "XII",
-  8556: "L",
-  8557: "C",
-  8558: "D",
-  8559: "M",
-  8560: "i",
-  8561: "ii",
-  8562: "iii",
-  8563: "iv",
-  8564: "v",
-  8565: "vi",
-  8566: "vii",
-  8567: "viii",
-  8568: "ix",
-  8569: "x",
-  8570: "xi",
-  8571: "xii",
-  8572: "l",
-  8573: "c",
-  8574: "d",
-  8575: "m",
-  8592: "<-",
-  8594: "->",
-  8596: "<->",
-  8656: "<=",
-  8658: "=>",
-  8660: "<=>",
-  8722: "-",
-  8725: "/",
-  8726: "\\",
-  8727: "*",
-  8739: "|",
-  8758: ":",
-  8764: "~",
-  8804: "<=",
-  8805: ">=",
-  8810: "<<",
-  8811: ">>",
-  8920: "<<<",
-  8921: ">>>",
-  9216: "NUL",
-  9217: "SOH",
-  9218: "STX",
-  9219: "ETX",
-  9220: "EOT",
-  9221: "ENQ",
-  9222: "ACK",
-  9223: "BEL",
-  9224: "BS",
-  9225: "HT",
-  9226: "LF",
-  9227: "VT",
-  9228: "FF",
-  9229: "CR",
-  9230: "SO",
-  9231: "SI",
-  9232: "DLE",
-  9233: "DC1",
-  9234: "DC2",
-  9235: "DC3",
-  9236: "DC4",
-  9237: "NAK",
-  9238: "SYN",
-  9239: "ETB",
-  9240: "CAN",
-  9241: "EM",
-  9242: "SUB",
-  9243: "ESC",
-  9244: "FS",
-  9245: "GS",
-  9246: "RS",
-  9247: "US",
-  9248: "SP",
-  9249: "DEL",
-  9251: "_",
-  9252: "NL",
-  9312: "(1)",
-  9313: "(2)",
-  9314: "(3)",
-  9315: "(4)",
-  9316: "(5)",
-  9317: "(6)",
-  9318: "(7)",
-  9319: "(8)",
-  9320: "(9)",
-  9321: "(10)",
-  9322: "(11)",
-  9323: "(12)",
-  9324: "(13)",
-  9325: "(14)",
-  9326: "(15)",
-  9327: "(16)",
-  9328: "(17)",
-  9329: "(18)",
-  9330: "(19)",
-  9331: "(20)",
-  9332: "(1)",
-  9333: "(2)",
-  9334: "(3)",
-  9335: "(4)",
-  9336: "(5)",
-  9337: "(6)",
-  9338: "(7)",
-  9339: "(8)",
-  9340: "(9)",
-  9341: "(10)",
-  9342: "(11)",
-  9343: "(12)",
-  9344: "(13)",
-  9345: "(14)",
-  9346: "(15)",
-  9347: "(16)",
-  9348: "(17)",
-  9349: "(18)",
-  9350: "(19)",
-  9351: "(20)",
-  9352: "1.",
-  9353: "2.",
-  9354: "3.",
-  9355: "4.",
-  9356: "5.",
-  9357: "6.",
-  9358: "7.",
-  9359: "8.",
-  9360: "9.",
-  9361: "10.",
-  9362: "11.",
-  9363: "12.",
-  9364: "13.",
-  9365: "14.",
-  9366: "15.",
-  9367: "16.",
-  9368: "17.",
-  9369: "18.",
-  9370: "19.",
-  9371: "20.",
-  9372: "(a)",
-  9373: "(b)",
-  9374: "(c)",
-  9375: "(d)",
-  9376: "(e)",
-  9377: "(f)",
-  9378: "(g)",
-  9379: "(h)",
-  9380: "(i)",
-  9381: "(j)",
-  9382: "(k)",
-  9383: "(l)",
-  9384: "(m)",
-  9385: "(n)",
-  9386: "(o)",
-  9387: "(p)",
-  9388: "(q)",
-  9389: "(r)",
-  9390: "(s)",
-  9391: "(t)",
-  9392: "(u)",
-  9393: "(v)",
-  9394: "(w)",
-  9395: "(x)",
-  9396: "(y)",
-  9397: "(z)",
-  9398: "(A)",
-  9399: "(B)",
-  9400: "(C)",
-  9401: "(D)",
-  9402: "(E)",
-  9403: "(F)",
-  9404: "(G)",
-  9405: "(H)",
-  9406: "(I)",
-  9407: "(J)",
-  9408: "(K)",
-  9409: "(L)",
-  9410: "(M)",
-  9411: "(N)",
-  9412: "(O)",
-  9413: "(P)",
-  9414: "(Q)",
-  9415: "(R)",
-  9416: "(S)",
-  9417: "(T)",
-  9418: "(U)",
-  9419: "(V)",
-  9420: "(W)",
-  9421: "(X)",
-  9422: "(Y)",
-  9423: "(Z)",
-  9424: "(a)",
-  9425: "(b)",
-  9426: "(c)",
-  9427: "(d)",
-  9428: "(e)",
-  9429: "(f)",
-  9430: "(g)",
-  9431: "(h)",
-  9432: "(i)",
-  9433: "(j)",
-  9434: "(k)",
-  9435: "(l)",
-  9436: "(m)",
-  9437: "(n)",
-  9438: "(o)",
-  9439: "(p)",
-  9440: "(q)",
-  9441: "(r)",
-  9442: "(s)",
-  9443: "(t)",
-  9444: "(u)",
-  9445: "(v)",
-  9446: "(w)",
-  9447: "(x)",
-  9448: "(y)",
-  9449: "(z)",
-  9450: "(0)",
-  9472: "-",
-  9474: "|",
-  9484: "+",
-  9488: "+",
-  9492: "+",
-  9496: "+",
-  9500: "+",
-  9508: "+",
-  9516: "+",
-  9524: "+",
-  9532: "+",
-  9702: "o",
-  10868: "::=",
-  10869: "==",
-  10870: "===",
-  12288: " ",
-  12448: "=",
-  12881: "(21)",
-  12882: "(22)",
-  12883: "(23)",
-  12884: "(24)",
-  12885: "(25)",
-  12886: "(26)",
-  12887: "(27)",
-  12888: "(28)",
-  12889: "(29)",
-  12890: "(30)",
-  12891: "(31)",
-  12892: "(32)",
-  12893: "(33)",
-  12894: "(34)",
-  12895: "(35)",
-  12977: "(36)",
-  12978: "(37)",
-  12979: "(38)",
-  12980: "(39)",
-  12981: "(40)",
-  12982: "(41)",
-  12983: "(42)",
-  12984: "(43)",
-  12985: "(44)",
-  12986: "(45)",
-  12987: "(46)",
-  12988: "(47)",
-  12989: "(48)",
-  12990: "(49)",
-  12991: "(50)",
-  13169: "hPa",
-  13170: "da",
-  13171: "AU",
-  13172: "bar",
-  13173: "oV",
-  13174: "pc",
-  13184: "pA",
-  13185: "nA",
-  13186: "uA",
-  13187: "mA",
-  13188: "kA",
-  13189: "KB",
-  13190: "MB",
-  13191: "GB",
-  13192: "cal",
-  13193: "kcal",
-  13194: "pF",
-  13195: "nF",
-  13196: "uF",
-  13197: "ug",
-  13198: "mg",
-  13199: "kg",
-  13200: "Hz",
-  13201: "kHz",
-  13202: "MHz",
-  13203: "GHz",
-  13204: "THz",
-  13205: "ul",
-  13206: "ml",
-  13207: "dl",
-  13208: "kl",
-  13209: "fm",
-  13210: "nm",
-  13211: "um",
-  13212: "mm",
-  13213: "cm",
-  13214: "km",
-  13215: "mm^2",
-  13216: "cm^2",
-  13217: "m^2",
-  13218: "km^2",
-  13219: "mm^3",
-  13220: "cm^3",
-  13221: "m^3",
-  13222: "km^3",
-  13223: "m/s",
-  13224: "m/s^2",
-  13225: "Pa",
-  13226: "kPa",
-  13227: "MPa",
-  13228: "GPa",
-  13229: "rad",
-  13230: "rad/s",
-  13231: "rad/s^2",
-  13232: "ps",
-  13233: "ns",
-  13234: "us",
-  13235: "ms",
-  13236: "pV",
-  13237: "nV",
-  13238: "uV",
-  13239: "mV",
-  13240: "kV",
-  13241: "MV",
-  13242: "pW",
-  13243: "nW",
-  13244: "uW",
-  13245: "mW",
-  13246: "kW",
-  13247: "MW",
-  13250: "a.m.",
-  13251: "Bq",
-  13252: "cc",
-  13253: "cd",
-  13254: "C/kg",
-  13255: "Co.",
-  13256: "dB",
-  13257: "Gy",
-  13258: "ha",
-  13259: "HP",
-  13260: "in",
-  13261: "KK",
-  13262: "KM",
-  13263: "kt",
-  13264: "lm",
-  13265: "ln",
-  13266: "log",
-  13267: "lx",
-  13268: "mb",
-  13269: "mil",
-  13270: "mol",
-  13271: "PH",
-  13272: "p.m.",
-  13273: "PPM",
-  13274: "PR",
-  13275: "sr",
-  13276: "Sv",
-  13277: "Wb",
-  64256: "ff",
-  64257: "fi",
-  64258: "fl",
-  64259: "ffi",
-  64260: "ffl",
-  64262: "st",
-  64297: "+",
-  65024: "",
-  65025: "",
-  65026: "",
-  65027: "",
-  65028: "",
-  65029: "",
-  65030: "",
-  65031: "",
-  65032: "",
-  65033: "",
-  65034: "",
-  65035: "",
-  65036: "",
-  65037: "",
-  65038: "",
-  65039: "",
-  65101: "_",
-  65102: "_",
-  65103: "_",
-  65104: ",",
-  65106: ".",
-  65108: ";",
-  65109: ":",
-  65111: "!",
-  65113: "(",
-  65114: ")",
-  65115: "{",
-  65116: "}",
-  65119: "#",
-  65120: "&",
-  65121: "*",
-  65122: "+",
-  65123: "-",
-  65124: "<",
-  65125: ">",
-  65126: "=",
-  65128: "\\",
-  65129: "$",
-  65130: "%",
-  65131: "@",
-  65279: "",
-  65281: "!",
-  65282: '"',
-  65283: "#",
-  65284: "$",
-  65285: "%",
-  65286: "&",
-  65287: "'",
-  65288: "(",
-  65289: ")",
-  65290: "*",
-  65291: "+",
-  65292: ",",
-  65293: "-",
-  65294: ".",
-  65295: "/",
-  65296: "0",
-  65297: "1",
-  65298: "2",
-  65299: "3",
-  65300: "4",
-  65301: "5",
-  65302: "6",
-  65303: "7",
-  65304: "8",
-  65305: "9",
-  65306: ":",
-  65307: ";",
-  65308: "<",
-  65309: "=",
-  65310: ">",
-  65312: "@",
-  65313: "A",
-  65314: "B",
-  65315: "C",
-  65316: "D",
-  65317: "E",
-  65318: "F",
-  65319: "G",
-  65320: "H",
-  65321: "I",
-  65322: "J",
-  65323: "K",
-  65324: "L",
-  65325: "M",
-  65326: "N",
-  65327: "O",
-  65328: "P",
-  65329: "Q",
-  65330: "R",
-  65331: "S",
-  65332: "T",
-  65333: "U",
-  65334: "V",
-  65335: "W",
-  65336: "X",
-  65337: "Y",
-  65338: "Z",
-  65339: "[",
-  65340: "\\",
-  65341: "]",
-  65342: "^",
-  65343: "_",
-  65344: "`",
-  65345: "a",
-  65346: "b",
-  65347: "c",
-  65348: "d",
-  65349: "e",
-  65350: "f",
-  65351: "g",
-  65352: "h",
-  65353: "i",
-  65354: "j",
-  65355: "k",
-  65356: "l",
-  65357: "m",
-  65358: "n",
-  65359: "o",
-  65360: "p",
-  65361: "q",
-  65362: "r",
-  65363: "s",
-  65364: "t",
-  65365: "u",
-  65366: "v",
-  65367: "w",
-  65368: "x",
-  65369: "y",
-  65370: "z",
-  65371: "{",
-  65372: "|",
-  65373: "}",
-  65374: "~",
-  119808: "A",
-  119809: "B",
-  119810: "C",
-  119811: "D",
-  119812: "E",
-  119813: "F",
-  119814: "G",
-  119815: "H",
-  119816: "I",
-  119817: "J",
-  119818: "K",
-  119819: "L",
-  119820: "M",
-  119821: "N",
-  119822: "O",
-  119823: "P",
-  119824: "Q",
-  119825: "R",
-  119826: "S",
-  119827: "T",
-  119828: "U",
-  119829: "V",
-  119830: "W",
-  119831: "X",
-  119832: "Y",
-  119833: "Z",
-  119834: "a",
-  119835: "b",
-  119836: "c",
-  119837: "d",
-  119838: "e",
-  119839: "f",
-  119840: "g",
-  119841: "h",
-  119842: "i",
-  119843: "j",
-  119844: "k",
-  119845: "l",
-  119846: "m",
-  119847: "n",
-  119848: "o",
-  119849: "p",
-  119850: "q",
-  119851: "r",
-  119852: "s",
-  119853: "t",
-  119854: "u",
-  119855: "v",
-  119856: "w",
-  119857: "x",
-  119858: "y",
-  119859: "z",
-  119860: "A",
-  119861: "B",
-  119862: "C",
-  119863: "D",
-  119864: "E",
-  119865: "F",
-  119866: "G",
-  119867: "H",
-  119868: "I",
-  119869: "J",
-  119870: "K",
-  119871: "L",
-  119872: "M",
-  119873: "N",
-  119874: "O",
-  119875: "P",
-  119876: "Q",
-  119877: "R",
-  119878: "S",
-  119879: "T",
-  119880: "U",
-  119881: "V",
-  119882: "W",
-  119883: "X",
-  119884: "Y",
-  119885: "Z",
-  119886: "a",
-  119887: "b",
-  119888: "c",
-  119889: "d",
-  119890: "e",
-  119891: "f",
-  119892: "g",
-  119894: "i",
-  119895: "j",
-  119896: "k",
-  119897: "l",
-  119898: "m",
-  119899: "n",
-  119900: "o",
-  119901: "p",
-  119902: "q",
-  119903: "r",
-  119904: "s",
-  119905: "t",
-  119906: "u",
-  119907: "v",
-  119908: "w",
-  119909: "x",
-  119910: "y",
-  119911: "z",
-  119912: "A",
-  119913: "B",
-  119914: "C",
-  119915: "D",
-  119916: "E",
-  119917: "F",
-  119918: "G",
-  119919: "H",
-  119920: "I",
-  119921: "J",
-  119922: "K",
-  119923: "L",
-  119924: "M",
-  119925: "N",
-  119926: "O",
-  119927: "P",
-  119928: "Q",
-  119929: "R",
-  119930: "S",
-  119931: "T",
-  119932: "U",
-  119933: "V",
-  119934: "W",
-  119935: "X",
-  119936: "Y",
-  119937: "Z",
-  119938: "a",
-  119939: "b",
-  119940: "c",
-  119941: "d",
-  119942: "e",
-  119943: "f",
-  119944: "g",
-  119945: "h",
-  119946: "i",
-  119947: "j",
-  119948: "k",
-  119949: "l",
-  119950: "m",
-  119951: "n",
-  119952: "o",
-  119953: "p",
-  119954: "q",
-  119955: "r",
-  119956: "s",
-  119957: "t",
-  119958: "u",
-  119959: "v",
-  119960: "w",
-  119961: "x",
-  119962: "y",
-  119963: "z",
-  119964: "A",
-  119966: "C",
-  119967: "D",
-  119970: "G",
-  119973: "J",
-  119974: "K",
-  119977: "N",
-  119978: "O",
-  119979: "P",
-  119980: "Q",
-  119982: "S",
-  119983: "T",
-  119984: "U",
-  119985: "V",
-  119986: "W",
-  119987: "X",
-  119988: "Y",
-  119989: "Z",
-  119990: "a",
-  119991: "b",
-  119992: "c",
-  119993: "d",
-  119995: "f",
-  119997: "h",
-  119998: "i",
-  119999: "j",
-  12e4: "k",
-  120002: "m",
-  120003: "n",
-  120005: "p",
-  120006: "q",
-  120007: "r",
-  120008: "s",
-  120009: "t",
-  120010: "u",
-  120011: "v",
-  120012: "w",
-  120013: "x",
-  120014: "y",
-  120015: "z",
-  120016: "A",
-  120017: "B",
-  120018: "C",
-  120019: "D",
-  120020: "E",
-  120021: "F",
-  120022: "G",
-  120023: "H",
-  120024: "I",
-  120025: "J",
-  120026: "K",
-  120027: "L",
-  120028: "M",
-  120029: "N",
-  120030: "O",
-  120031: "P",
-  120032: "Q",
-  120033: "R",
-  120034: "S",
-  120035: "T",
-  120036: "U",
-  120037: "V",
-  120038: "W",
-  120039: "X",
-  120040: "Y",
-  120041: "Z",
-  120042: "a",
-  120043: "b",
-  120044: "c",
-  120045: "d",
-  120046: "e",
-  120047: "f",
-  120048: "g",
-  120049: "h",
-  120050: "i",
-  120051: "j",
-  120052: "k",
-  120053: "l",
-  120054: "m",
-  120055: "n",
-  120056: "o",
-  120057: "p",
-  120058: "q",
-  120059: "r",
-  120060: "s",
-  120061: "t",
-  120062: "u",
-  120063: "v",
-  120064: "w",
-  120065: "x",
-  120066: "y",
-  120067: "z",
-  120068: "A",
-  120069: "B",
-  120071: "D",
-  120072: "E",
-  120073: "F",
-  120074: "G",
-  120077: "J",
-  120078: "K",
-  120079: "L",
-  120080: "M",
-  120081: "N",
-  120082: "O",
-  120083: "P",
-  120084: "Q",
-  120086: "S",
-  120087: "T",
-  120088: "U",
-  120089: "V",
-  120090: "W",
-  120091: "X",
-  120092: "Y",
-  120094: "a",
-  120095: "b",
-  120096: "c",
-  120097: "d",
-  120098: "e",
-  120099: "f",
-  120100: "g",
-  120101: "h",
-  120102: "i",
-  120103: "j",
-  120104: "k",
-  120105: "l",
-  120106: "m",
-  120107: "n",
-  120108: "o",
-  120109: "p",
-  120110: "q",
-  120111: "r",
-  120112: "s",
-  120113: "t",
-  120114: "u",
-  120115: "v",
-  120116: "w",
-  120117: "x",
-  120118: "y",
-  120119: "z",
-  120120: "A",
-  120121: "B",
-  120123: "D",
-  120124: "E",
-  120125: "F",
-  120126: "G",
-  120128: "I",
-  120129: "J",
-  120130: "K",
-  120131: "L",
-  120132: "M",
-  120134: "O",
-  120138: "S",
-  120139: "T",
-  120140: "U",
-  120141: "V",
-  120142: "W",
-  120143: "X",
-  120144: "Y",
-  120146: "a",
-  120147: "b",
-  120148: "c",
-  120149: "d",
-  120150: "e",
-  120151: "f",
-  120152: "g",
-  120153: "h",
-  120154: "i",
-  120155: "j",
-  120156: "k",
-  120157: "l",
-  120158: "m",
-  120159: "n",
-  120160: "o",
-  120161: "p",
-  120162: "q",
-  120163: "r",
-  120164: "s",
-  120165: "t",
-  120166: "u",
-  120167: "v",
-  120168: "w",
-  120169: "x",
-  120170: "y",
-  120171: "z",
-  120172: "A",
-  120173: "B",
-  120174: "C",
-  120175: "D",
-  120176: "E",
-  120177: "F",
-  120178: "G",
-  120179: "H",
-  120180: "I",
-  120181: "J",
-  120182: "K",
-  120183: "L",
-  120184: "M",
-  120185: "N",
-  120186: "O",
-  120187: "P",
-  120188: "Q",
-  120189: "R",
-  120190: "S",
-  120191: "T",
-  120192: "U",
-  120193: "V",
-  120194: "W",
-  120195: "X",
-  120196: "Y",
-  120197: "Z",
-  120198: "a",
-  120199: "b",
-  120200: "c",
-  120201: "d",
-  120202: "e",
-  120203: "f",
-  120204: "g",
-  120205: "h",
-  120206: "i",
-  120207: "j",
-  120208: "k",
-  120209: "l",
-  120210: "m",
-  120211: "n",
-  120212: "o",
-  120213: "p",
-  120214: "q",
-  120215: "r",
-  120216: "s",
-  120217: "t",
-  120218: "u",
-  120219: "v",
-  120220: "w",
-  120221: "x",
-  120222: "y",
-  120223: "z",
-  120224: "A",
-  120225: "B",
-  120226: "C",
-  120227: "D",
-  120228: "E",
-  120229: "F",
-  120230: "G",
-  120231: "H",
-  120232: "I",
-  120233: "J",
-  120234: "K",
-  120235: "L",
-  120236: "M",
-  120237: "N",
-  120238: "O",
-  120239: "P",
-  120240: "Q",
-  120241: "R",
-  120242: "S",
-  120243: "T",
-  120244: "U",
-  120245: "V",
-  120246: "W",
-  120247: "X",
-  120248: "Y",
-  120249: "Z",
-  120250: "a",
-  120251: "b",
-  120252: "c",
-  120253: "d",
-  120254: "e",
-  120255: "f",
-  120256: "g",
-  120257: "h",
-  120258: "i",
-  120259: "j",
-  120260: "k",
-  120261: "l",
-  120262: "m",
-  120263: "n",
-  120264: "o",
-  120265: "p",
-  120266: "q",
-  120267: "r",
-  120268: "s",
-  120269: "t",
-  120270: "u",
-  120271: "v",
-  120272: "w",
-  120273: "x",
-  120274: "y",
-  120275: "z",
-  120276: "A",
-  120277: "B",
-  120278: "C",
-  120279: "D",
-  120280: "E",
-  120281: "F",
-  120282: "G",
-  120283: "H",
-  120284: "I",
-  120285: "J",
-  120286: "K",
-  120287: "L",
-  120288: "M",
-  120289: "N",
-  120290: "O",
-  120291: "P",
-  120292: "Q",
-  120293: "R",
-  120294: "S",
-  120295: "T",
-  120296: "U",
-  120297: "V",
-  120298: "W",
-  120299: "X",
-  120300: "Y",
-  120301: "Z",
-  120302: "a",
-  120303: "b",
-  120304: "c",
-  120305: "d",
-  120306: "e",
-  120307: "f",
-  120308: "g",
-  120309: "h",
-  120310: "i",
-  120311: "j",
-  120312: "k",
-  120313: "l",
-  120314: "m",
-  120315: "n",
-  120316: "o",
-  120317: "p",
-  120318: "q",
-  120319: "r",
-  120320: "s",
-  120321: "t",
-  120322: "u",
-  120323: "v",
-  120324: "w",
-  120325: "x",
-  120326: "y",
-  120327: "z",
-  120328: "A",
-  120329: "B",
-  120330: "C",
-  120331: "D",
-  120332: "E",
-  120333: "F",
-  120334: "G",
-  120335: "H",
-  120336: "I",
-  120337: "J",
-  120338: "K",
-  120339: "L",
-  120340: "M",
-  120341: "N",
-  120342: "O",
-  120343: "P",
-  120344: "Q",
-  120345: "R",
-  120346: "S",
-  120347: "T",
-  120348: "U",
-  120349: "V",
-  120350: "W",
-  120351: "X",
-  120352: "Y",
-  120353: "Z",
-  120354: "a",
-  120355: "b",
-  120356: "c",
-  120357: "d",
-  120358: "e",
-  120359: "f",
-  120360: "g",
-  120361: "h",
-  120362: "i",
-  120363: "j",
-  120364: "k",
-  120365: "l",
-  120366: "m",
-  120367: "n",
-  120368: "o",
-  120369: "p",
-  120370: "q",
-  120371: "r",
-  120372: "s",
-  120373: "t",
-  120374: "u",
-  120375: "v",
-  120376: "w",
-  120377: "x",
-  120378: "y",
-  120379: "z",
-  120380: "A",
-  120381: "B",
-  120382: "C",
-  120383: "D",
-  120384: "E",
-  120385: "F",
-  120386: "G",
-  120387: "H",
-  120388: "I",
-  120389: "J",
-  120390: "K",
-  120391: "L",
-  120392: "M",
-  120393: "N",
-  120394: "O",
-  120395: "P",
-  120396: "Q",
-  120397: "R",
-  120398: "S",
-  120399: "T",
-  120400: "U",
-  120401: "V",
-  120402: "W",
-  120403: "X",
-  120404: "Y",
-  120405: "Z",
-  120406: "a",
-  120407: "b",
-  120408: "c",
-  120409: "d",
-  120410: "e",
-  120411: "f",
-  120412: "g",
-  120413: "h",
-  120414: "i",
-  120415: "j",
-  120416: "k",
-  120417: "l",
-  120418: "m",
-  120419: "n",
-  120420: "o",
-  120421: "p",
-  120422: "q",
-  120423: "r",
-  120424: "s",
-  120425: "t",
-  120426: "u",
-  120427: "v",
-  120428: "w",
-  120429: "x",
-  120430: "y",
-  120431: "z",
-  120432: "A",
-  120433: "B",
-  120434: "C",
-  120435: "D",
-  120436: "E",
-  120437: "F",
-  120438: "G",
-  120439: "H",
-  120440: "I",
-  120441: "J",
-  120442: "K",
-  120443: "L",
-  120444: "M",
-  120445: "N",
-  120446: "O",
-  120447: "P",
-  120448: "Q",
-  120449: "R",
-  120450: "S",
-  120451: "T",
-  120452: "U",
-  120453: "V",
-  120454: "W",
-  120455: "X",
-  120456: "Y",
-  120457: "Z",
-  120458: "a",
-  120459: "b",
-  120460: "c",
-  120461: "d",
-  120462: "e",
-  120463: "f",
-  120464: "g",
-  120465: "h",
-  120466: "i",
-  120467: "j",
-  120468: "k",
-  120469: "l",
-  120470: "m",
-  120471: "n",
-  120472: "o",
-  120473: "p",
-  120474: "q",
-  120475: "r",
-  120476: "s",
-  120477: "t",
-  120478: "u",
-  120479: "v",
-  120480: "w",
-  120481: "x",
-  120482: "y",
-  120483: "z",
-  120782: "0",
-  120783: "1",
-  120784: "2",
-  120785: "3",
-  120786: "4",
-  120787: "5",
-  120788: "6",
-  120789: "7",
-  120790: "8",
-  120791: "9",
-  120792: "0",
-  120793: "1",
-  120794: "2",
-  120795: "3",
-  120796: "4",
-  120797: "5",
-  120798: "6",
-  120799: "7",
-  120800: "8",
-  120801: "9",
-  120802: "0",
-  120803: "1",
-  120804: "2",
-  120805: "3",
-  120806: "4",
-  120807: "5",
-  120808: "6",
-  120809: "7",
-  120810: "8",
-  120811: "9",
-  120812: "0",
-  120813: "1",
-  120814: "2",
-  120815: "3",
-  120816: "4",
-  120817: "5",
-  120818: "6",
-  120819: "7",
-  120820: "8",
-  120821: "9",
-  120822: "0",
-  120823: "1",
-  120824: "2",
-  120825: "3",
-  120826: "4",
-  120827: "5",
-  120828: "6",
-  120829: "7",
-  120830: "8",
-  120831: "9",
-  917504: "",
-  917505: "",
-  917506: "",
-  917507: "",
-  917508: "",
-  917509: "",
-  917510: "",
-  917511: "",
-  917512: "",
-  917513: "",
-  917514: "",
-  917515: "",
-  917516: "",
-  917517: "",
-  917518: "",
-  917519: "",
-  917520: "",
-  917521: "",
-  917522: "",
-  917523: "",
-  917524: "",
-  917525: "",
-  917526: "",
-  917527: "",
-  917528: "",
-  917529: "",
-  917530: "",
-  917531: "",
-  917532: "",
-  917533: "",
-  917534: "",
-  917535: "",
-  917536: "",
-  917537: "",
-  917538: "",
-  917539: "",
-  917540: "",
-  917541: "",
-  917542: "",
-  917543: "",
-  917544: "",
-  917545: "",
-  917546: "",
-  917547: "",
-  917548: "",
-  917549: "",
-  917550: "",
-  917551: "",
-  917552: "",
-  917553: "",
-  917554: "",
-  917555: "",
-  917556: "",
-  917557: "",
-  917558: "",
-  917559: "",
-  917560: "",
-  917561: "",
-  917562: "",
-  917563: "",
-  917564: "",
-  917565: "",
-  917566: "",
-  917567: "",
-  917568: "",
-  917569: "",
-  917570: "",
-  917571: "",
-  917572: "",
-  917573: "",
-  917574: "",
-  917575: "",
-  917576: "",
-  917577: "",
-  917578: "",
-  917579: "",
-  917580: "",
-  917581: "",
-  917582: "",
-  917583: "",
-  917584: "",
-  917585: "",
-  917586: "",
-  917587: "",
-  917588: "",
-  917589: "",
-  917590: "",
-  917591: "",
-  917592: "",
-  917593: "",
-  917594: "",
-  917595: "",
-  917596: "",
-  917597: "",
-  917598: "",
-  917599: "",
-  917600: "",
-  917601: "",
-  917602: "",
-  917603: "",
-  917604: "",
-  917605: "",
-  917606: "",
-  917607: "",
-  917608: "",
-  917609: "",
-  917610: "",
-  917611: "",
-  917612: "",
-  917613: "",
-  917614: "",
-  917615: "",
-  917616: "",
-  917617: "",
-  917618: "",
-  917619: "",
-  917620: "",
-  917621: "",
-  917622: "",
-  917623: "",
-  917624: "",
-  917625: "",
-  917626: "",
-  917627: "",
-  917628: "",
-  917629: "",
-  917630: "",
-  917631: ""
-});
-
-// packages/safe-bash-command-iconv/src/codec.ts
-var LATIN1_DECODED = Array.from({ length: 256 }, (_, value) => ({ count: 1, value }));
-var BYTE_ENCODED = Array.from({ length: 256 }, (_, value) => [value]);
-function decode(input, offset, encoding2, swap) {
-  const first = input[offset];
-  if (encoding2 === "ascii") return first < 128 ? LATIN1_DECODED[first] : { count: 1, error: "illegal" };
-  if (encoding2 === "latin1") return LATIN1_DECODED[first];
-  if (encoding2 === "utf8") {
-    if (first < 128) return LATIN1_DECODED[first];
-    let count = 0, value = 0;
-    if (first >= 194 && first < 224) {
-      count = 2;
-      value = first & 31;
-    } else if (first >= 224 && first < 240) {
-      count = 3;
-      value = first & 15;
-    } else if (first >= 240 && first < 245) {
-      count = 4;
-      value = first & 7;
-    } else {
-      count = 1;
-      while (count < 5 && offset + count < input.length && (input[offset + count] & 192) === 128) count++;
-      return { count, error: "illegal" };
-    }
-    for (let index = 1; index < count; index++) {
-      if (offset + index >= input.length) return { count: 0, error: "incomplete" };
-      const byte = input[offset + index];
-      if ((byte & 192) !== 128) return { count: index, error: "illegal" };
-      value = value * 64 + (byte & 63);
-    }
-    if (count > 2 && value < 2 ** (5 * count - 4) || value > 1114111 || value >= 55296 && value <= 57343) return { count, error: "illegal" };
-    return { count, value };
-  }
-  if (offset + 1 >= input.length) return { count: 0, error: "incomplete" };
-  const big = encoding2 === "utf16be" || encoding2 === "utf16" && swap;
-  const word = big ? first * 256 + input[offset + 1] : first + input[offset + 1] * 256;
-  if (word < 55296 || word > 57343) return { count: 2, value: word };
-  if (word >= 56320) return { count: 2, error: "illegal" };
-  if (offset + 3 >= input.length) return { count: 0, error: "incomplete" };
-  const next = big ? input[offset + 2] * 256 + input[offset + 3] : input[offset + 2] + input[offset + 3] * 256;
-  if (next < 56320 || next > 57343) return { count: 2, error: "illegal" };
-  return { count: 4, value: 65536 + (word - 55296) * 1024 + next - 56320 };
-}
-function encode(value, encoding2) {
-  if (value > 1114111 || value >= 55296 && value <= 57343) return void 0;
-  if (encoding2 === "ascii" || encoding2 === "latin1") {
-    if (value < (encoding2 === "ascii" ? 128 : 256)) return BYTE_ENCODED[value];
-    if (value >= 917504 && value <= 917631) return [];
-    return void 0;
-  }
-  if (encoding2 === "utf8") {
-    if (value < 128) return BYTE_ENCODED[value];
-    let count = 2;
-    while (count < 4 && value >= 2 ** (5 * count + 1)) count++;
-    const result2 = new Array(count);
-    for (let index = count - 1; index > 0; index--) {
-      result2[index] = 128 | value & 63;
-      value = Math.floor(value / 64);
-    }
-    result2[0] = 256 - 2 ** (8 - count) | value;
-    return result2;
-  }
-  const words = value < 65536 ? [value] : [55296 + Math.floor((value - 65536) / 1024), 56320 + (value - 65536) % 1024];
-  const result = [];
-  for (const word of words) {
-    if (encoding2 === "utf16be") result.push(word >> 8, word & 255);
-    else result.push(word & 255, word >> 8);
-  }
-  return result;
-}
-async function convert(input, options, state, lifecycle) {
-  const { budget } = lifecycle;
-  budget.retain(32768 + 256);
-  const buffer = new Uint8Array(32768);
-  let used = 0, offset = 0, status = 0, batchCount = 0;
-  let suppressed = false, targetSuppressed = false, started = false, firstTargetBatch = true;
-  const flush = async () => {
-    if (used) {
-      await lifecycle.write(buffer.slice(0, used));
-      used = 0;
-      status = 0;
-    }
-  };
-  const flushFullOutput = async () => {
-    await flush();
-    batchCount = 1;
-    suppressed = false;
-    targetSuppressed = false;
-    firstTargetBatch = false;
-  };
-  const append = (bytes, transliterated = false) => {
-    const recursiveBom = transliterated && firstTargetBatch && options.to === "utf16";
-    if (!recursiveBom && bytes.length === 1 && used < buffer.length) {
-      buffer[used++] = bytes[0];
-      return;
-    }
-    if (buffer.length - used < bytes.length + (recursiveBom ? 2 : 0)) {
-      return flushFullOutput().then(() => {
-        buffer.set(bytes, used);
-        used += bytes.length;
-      });
-    }
-    if (recursiveBom) {
-      buffer[used++] = 255;
-      buffer[used++] = 254;
-    }
-    buffer.set(bytes, used);
-    used += bytes.length;
-  };
-  try {
-    state.swap = false;
-    if (options.from === "utf16" && input.length >= 2) {
-      if (input[0] === 254 && input[1] === 255) {
-        state.swap = true;
-        offset = 2;
-      } else if (input[0] === 255 && input[1] === 254) offset = 2;
-    }
-    const asciiDirect = (options.from === "utf8" || options.from === "ascii" || options.from === "latin1") && (options.to === "utf8" || options.to === "ascii" || options.to === "latin1");
-    while (offset < input.length) {
-      if (asciiDirect && input[offset] < 128 && used < buffer.length && batchCount < 8160) {
-        const maxRun = Math.min(input.length - offset, buffer.length - used, 8160 - batchCount, 256);
-        let run = 1;
-        while (run < maxRun && input[offset + run] < 128) run++;
-        budget.charge(run * 16);
-        {
-          const cp = budget.checkpointWork();
-          if (cp) await cp;
-        }
-        buffer.set(input.subarray(offset, offset + run), used);
-        used += run;
-        offset += run;
-        batchCount += run;
-        started = true;
-        if (batchCount === 8160) {
-          batchCount = 0;
-          firstTargetBatch = false;
-          if (targetSuppressed) {
-            status = 1;
-            await flush();
-            suppressed = false;
-            targetSuppressed = false;
-          }
-        }
-        continue;
-      }
-      budget.charge(16);
-      {
-        const cp = budget.checkpointWork();
-        if (cp) await cp;
-      }
-      const decoded = decode(input, offset, options.from, state.swap);
-      let error;
-      if ("error" in decoded) error = decoded.error;
-      else {
-        batchCount++;
-        if (buffer.length - used < (options.to.startsWith("utf16") ? 2 : 1)) await flushFullOutput();
-        if (!started && options.to === "utf16") {
-          const a = append([255, 254]);
-          if (a) await a;
-        }
-        started = true;
-        let bytes = encode(decoded.value, options.to);
-        const transliterated = bytes === void 0 && options.transliterate;
-        if (transliterated) {
-          const replacement = Object.hasOwn(cTransliterations, decoded.value) ? cTransliterations[decoded.value] : "?";
-          budget.charge(replacement.length + 1);
-          const mutableBytes = [];
-          for (const character of replacement) mutableBytes.push(...encode(character.charCodeAt(0), options.to));
-          bytes = mutableBytes;
-        }
-        if (bytes === void 0) {
-          error = "illegal";
-          targetSuppressed = true;
-        } else {
-          const a = append(bytes, transliterated);
-          if (a) await a;
-        }
-      }
-      if (error === "illegal" && options.discard) suppressed = true;
-      else if (error) {
-        await flush();
-        await lifecycle.diagnostic(error === "illegal" ? `illegal input sequence at position ${offset}` : "incomplete character or shift sequence at end of buffer");
-        return { status: 1, fatal: true };
-      }
-      offset += decoded.count;
-      if (batchCount === 8160) {
-        batchCount = 0;
-        firstTargetBatch = false;
-        if (targetSuppressed) {
-          status = 1;
-          await flush();
-          suppressed = false;
-          targetSuppressed = false;
-        }
-      }
-    }
-    if (suppressed) status = 1;
-    await flush();
-    return { status, fatal: false };
-  } finally {
-    budget.retain(-32768 - 256);
-  }
-}
-
-// packages/safe-bash-command-iconv/src/command.ts
-async function transcode(options, lifecycle) {
-  const state = { swap: false };
-  let exitCode = 0, stdinUsed = false;
-  for (const file of options.files) {
-    if (options.verbose && file !== "-") {
-      lifecycle.budget.check(file.length * 3 + 2, lifecycle.budget.limits.maxDiagnosticBytes, "diagnostic bytes");
-      await lifecycle.write(new TextEncoder().encode(`${file}:
-`), true);
-    }
-    if (file === "-" && stdinUsed) {
-      await lifecycle.diagnostic("error while reading the input: Bad file descriptor");
-      return 1;
-    }
-    if (file === "-") stdinUsed = true;
-    const reader = new Reader(file, lifecycle);
-    let fatal = false;
-    try {
-      await reader.open();
-      const input = await reader.all();
-      const result = await convert(input, options, state, lifecycle);
-      exitCode ||= result.status;
-      fatal = result.fatal;
-    } catch (error) {
-      lifecycle.budget.signal.throwIfAborted();
-      if (!(error instanceof FsError2)) throw error;
-      exitCode = 1;
-      fatal = reader.stage === "read";
-      await lifecycle.diagnostic(fatal ? `error while reading the input: ${fsDetail(error)}` : `cannot open input file \`${file}': ${fsDetail(error)}`);
-    }
-    await lifecycle.operation(() => reader.close());
-    if (fatal) break;
-  }
-  return exitCode;
-}
-async function execute(context, limits) {
-  let lifecycle;
-  let fileOutput;
-  const caller = context.signal;
-  caller.throwIfAborted();
-  const stdout = context.stdout;
-  caller.throwIfAborted();
-  const capability = stdout.ownedOutput;
-  caller.throwIfAborted();
-  const consumer = capability?.consumerClosed;
-  caller.throwIfAborted();
-  consumer?.throwIfAborted();
-  const failureHandler = stdout[outputFailure];
-  caller.throwIfAborted();
-  consumer?.throwIfAborted();
-  const registerCleanup = context.registerCleanup;
-  caller.throwIfAborted();
-  consumer?.throwIfAborted();
-  const destination = capability ?? stdout;
-  const write = async (value) => {
-    lifecycle.assertOpen();
-    const selected = fileOutput?.sink ?? destination;
-    const method = selected.write;
-    lifecycle.assertOpen();
-    try {
-      await Reflect.apply(method, selected, [value]);
-    } catch (error) {
-      lifecycle.budget.signal.throwIfAborted();
-      if (!fileOutput || !(error instanceof FsError2)) throw error;
-      throw new IconvError(`error while writing output: ${fsDetail(error)}`);
-    }
-  };
-  const captured = {
-    write,
-    ...capability ? { ownedOutput: { consumerClosed: consumer, write } } : {},
-    ...failureHandler ? { [outputFailure]: failureHandler } : {}
-  };
-  const admission = { closed: false };
-  const output = createOutputOperation({ signal: caller, ...registerCleanup ? { registerCleanup(cleanup) {
-    caller.throwIfAborted();
-    Reflect.apply(registerCleanup, context, [() => {
-      admission.closed = true;
-      return cleanup();
-    }]);
-  } } : {} }, captured);
-  const budget = new Budget(context, limits, output.signal, caller, admission);
-  let failure, primary;
-  let exitCode = 0;
-  try {
-    lifecycle = new Lifecycle(budget, output, captured);
-    const options = parse(budget);
-    if ("information" in options) {
-      await lifecycle.write(new TextEncoder().encode(options.information));
-    } else {
-      if (options.output !== void 0 && options.output !== "-") {
-        try {
-          if (options.output === "") throw new FsError2("ENOENT", { path: "" });
-          const path = resolvePath2(context.cwd, pathText(options.output));
-          fileOutput = await lifecycle.operation(() => openFileOutput({
-            fs: context.fs,
-            signal: budget.signal,
-            registerCleanup: output.registerCleanup.bind(output),
-            outputBudget: "independent"
-          }, path, "w"));
-        } catch (error) {
-          budget.signal.throwIfAborted();
-          if (!(error instanceof FsError2)) throw error;
-          throw new IconvError(`cannot open output file \`${options.output}': ${fsDetail(error)}`);
-        }
-      }
-      exitCode = await transcode(options, lifecycle);
-      if (fileOutput) {
-        try {
-          await lifecycle.operation(() => fileOutput.finish());
-        } catch (error) {
-          budget.signal.throwIfAborted();
-          if (!(error instanceof FsError2)) throw error;
-          throw new IconvError(`error while writing output: ${fsDetail(error)}`);
-        }
-      }
-    }
-  } catch (error) {
-    primary = { reason: error };
-    if (error instanceof IconvError && !output.signal.aborted && lifecycle) {
-      exitCode = error.status;
-      try {
-        await lifecycle.diagnostic(error.message);
-      } catch (reporting) {
-        failure = { reason: new AggregateError([error, reporting], "iconv 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], "iconv execution and cleanup failed") : cleanup };
-  }
-  caller.throwIfAborted();
-  output.signal.throwIfAborted();
-  if (lifecycle?.diagnosticCancellation) throw lifecycle.diagnosticCancellation.reason;
-  if (failure) throw failure.reason;
-  return { exitCode };
-}
-function createIconvCommand(options = {}) {
-  const limits = settings(options);
-  return { name: "iconv", description: "Convert bytes between bounded ASCII, Latin-1, UTF-8 and UTF-16 encodings", execute: (context) => execute(context, limits) };
-}
-
-// packages/safe-bash-command-iconv/src/index.ts
-function createIconvCommand2(options = {}) {
-  const def = createIconvCommand(options);
-  if (options.limits === void 0) builtInDirectContextExecutors.add(def.execute);
-  return def;
-}
-function createIconvCommands(options = {}) {
-  return [createIconvCommand2(options)];
-}
-function iconvCommands(options = {}) {
-  const commands = createIconvCommands(options);
-  return { name: "iconv-commands", setup(host) {
-    for (const command of commands) host.commands.register(command, { replace: options.replace ?? false });
-  } };
-}
-var SYNC_ICONV_ALIASES = {
-  ASCII: "ascii",
-  "US-ASCII": "ascii",
-  "ANSI_X3.4-1968": "ascii",
-  LATIN1: "latin1",
-  "LATIN-1": "latin1",
-  "ISO-8859-1": "latin1",
-  "ISO8859-1": "latin1",
-  UTF8: "utf8",
-  "UTF-8": "utf8"
-};
-function evalSyncIconv(inBytes, opArgs, readFileSync, writeFileSync) {
-  let fromRaw;
-  let toRaw;
-  let outputFile;
-  let discard = false;
-  let ended = false;
-  const files = [];
-  for (let i = 0; i < opArgs.length; i++) {
-    const a = opArgs[i];
-    if (ended || a === "-" || !a.startsWith("-")) {
-      files.push(a);
-      continue;
-    }
-    if (a === "--") {
-      ended = true;
-      continue;
-    }
-    if (a === "--silent" || a === "-s") continue;
-    if (a === "-c") {
-      discard = true;
-      continue;
-    }
-    if (a === "-sc" || a === "-cs") {
-      discard = true;
-      continue;
-    }
-    if (a.startsWith("--from-code=")) {
-      fromRaw = a.slice(12);
-      continue;
-    }
-    if (a === "--from-code" || a === "-f") {
-      fromRaw = opArgs[++i];
-      if (!fromRaw) return void 0;
-      continue;
-    }
-    if (a.startsWith("-f") && a.length > 2) {
-      fromRaw = a.slice(2);
-      continue;
-    }
-    if (a.startsWith("--to-code=")) {
-      toRaw = a.slice(10);
-      continue;
-    }
-    if (a === "--to-code" || a === "-t") {
-      toRaw = opArgs[++i];
-      if (!toRaw) return void 0;
-      continue;
-    }
-    if (a.startsWith("-t") && a.length > 2) {
-      toRaw = a.slice(2);
-      continue;
-    }
-    if (a.startsWith("--output=")) {
-      outputFile = a.slice(9);
-      if (!outputFile) return void 0;
-      continue;
-    }
-    if (a === "--output" || a === "-o") {
-      outputFile = opArgs[++i];
-      if (!outputFile) return void 0;
-      continue;
-    }
-    if (a.startsWith("-o") && a.length > 2) {
-      outputFile = a.slice(2);
-      continue;
-    }
-    return void 0;
-  }
-  if (!fromRaw || !toRaw) return void 0;
-  if (fromRaw.includes("//")) return void 0;
-  const toParts = toRaw.split("//");
-  for (let i = 1; i < toParts.length; i++) {
-    if (toParts[i].toUpperCase() === "IGNORE") discard = true;
-    else return void 0;
-  }
-  const fromEnc = SYNC_ICONV_ALIASES[fromRaw.toUpperCase()];
-  const toEnc = SYNC_ICONV_ALIASES[toParts[0].toUpperCase()];
-  if (!fromEnc || !toEnc) return void 0;
-  let src = inBytes;
-  if (files.length === 1 && files[0] !== "-") {
-    if (!readFileSync) return void 0;
-    const fBytes = readFileSync(files[0]);
-    if (!fBytes || fBytes.byteLength > 16384) return void 0;
-    src = fBytes;
-  } else if (files.length > 1) {
-    if (!readFileSync) return void 0;
-    const parts = [];
-    let totalLen = 0;
-    let stdinUsed = false;
-    for (const f of files) {
-      let chunk;
-      if (f === "-") {
-        if (stdinUsed || !inBytes) return void 0;
-        stdinUsed = true;
-        chunk = inBytes;
-      } else {
-        chunk = readFileSync(f);
-      }
-      if (!chunk || totalLen + chunk.byteLength > 16384) return void 0;
-      parts.push(chunk);
-      totalLen += chunk.byteLength;
-    }
-    const merged = new Uint8Array(totalLen);
-    let pos = 0;
-    for (const p of parts) {
-      merged.set(p, pos);
-      pos += p.byteLength;
-    }
-    src = merged;
-  }
-  if (!src || src.byteLength > 16384) return void 0;
-  const out = [];
-  let offset = 0;
-  while (offset < src.byteLength) {
-    const first = src[offset];
-    let cp = -1;
-    let count = 1;
-    if (fromEnc === "ascii") {
-      if (first < 128) cp = first;
-    } else if (fromEnc === "latin1") {
-      cp = first;
-    } else {
-      if (first < 128) {
-        cp = first;
-      } else if (first >= 194 && first < 224 && offset + 1 < src.byteLength) {
-        const b1 = src[offset + 1];
-        if ((b1 & 192) === 128) {
-          cp = (first & 31) << 6 | b1 & 63;
-          count = 2;
-        }
-      } else if (first >= 224 && first < 240 && offset + 2 < src.byteLength) {
-        const b1 = src[offset + 1], b2 = src[offset + 2];
-        if ((b1 & 192) === 128 && (b2 & 192) === 128) {
-          const val = (first & 15) << 12 | (b1 & 63) << 6 | b2 & 63;
-          if (val >= 2048 && (val < 55296 || val > 57343)) {
-            cp = val;
-            count = 3;
-          }
-        }
-      } else if (first >= 240 && first < 245 && offset + 3 < src.byteLength) {
-        const b1 = src[offset + 1], b2 = src[offset + 2], b3 = src[offset + 3];
-        if ((b1 & 192) === 128 && (b2 & 192) === 128 && (b3 & 192) === 128) {
-          const val = (first & 7) << 18 | (b1 & 63) << 12 | (b2 & 63) << 6 | b3 & 63;
-          if (val >= 65536 && val <= 1114111) {
-            cp = val;
-            count = 4;
-          }
-        }
-      }
-    }
-    if (cp === -1) {
-      if (!discard) return void 0;
-      offset += count;
-      continue;
-    }
-    if (toEnc === "ascii") {
-      if (cp >= 128) {
-        if (!discard) return void 0;
-      } else {
-        out.push(cp);
-      }
-    } else if (toEnc === "latin1") {
-      if (cp >= 256) {
-        if (!discard) return void 0;
-      } else {
-        out.push(cp);
-      }
-    } else {
-      if (cp < 128) out.push(cp);
-      else if (cp < 2048) out.push(192 | cp >> 6, 128 | cp & 63);
-      else if (cp < 65536) out.push(224 | cp >> 12, 128 | cp >> 6 & 63, 128 | cp & 63);
-      else out.push(240 | cp >> 18, 128 | cp >> 12 & 63, 128 | cp >> 6 & 63, 128 | cp & 63);
-    }
-    offset += count;
-  }
-  const outArr = new Uint8Array(out);
-  if (outputFile !== void 0) {
-    if (!writeFileSync || !writeFileSync(outputFile, outArr)) return void 0;
-    return new Uint8Array(0);
-  }
-  if (out.some((byte) => byte === 0 || byte >= 128)) return void 0;
-  return outArr;
-}
-
-export {
-  createIconvCommand2 as createIconvCommand,
-  createIconvCommands,
-  iconvCommands,
-  evalSyncIconv
-};
-//# sourceMappingURL=chunk-BRJTAWP5.js.map