poe-code 15.0.14 → 15.0.16

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

@@ -0,0 +1,2609 @@
+import {
+  resolvePath
+} from "./chunk-DPJWEGIX.js";
+import {
+  createOutputOperation
+} from "./chunk-PZMJ4EC3.js";
+import {
+  FsError,
+  PublicDiagnostic,
+  getCommandArguments,
+  outputFailure,
+  shellValueByteLength,
+  shellValueBytes,
+  yieldTurn
+} from "./chunk-5VBLSPNM.js";
+import {
+  init_platform
+} from "./chunk-2KL6W6NB.js";
+
+// packages/safe-bash/src/commands/iconv/index.ts
+init_platform();
+
+// packages/safe-bash/src/commands/iconv/command.ts
+init_platform();
+
+// packages/safe-bash/src/commands/iconv/internal.ts
+init_platform();
+function settings(options) {
+  const limits = {
+    maxArguments: 4096,
+    maxArgumentBytes: 65536,
+    maxInputBytes: 8388608,
+    maxBufferedBytes: 33554432,
+    maxOutputBytes: 67108864,
+    maxDiagnosticBytes: 65536,
+    maxWork: 134217728,
+    maxChunks: 65536,
+    maxEmptyChunks: 4096,
+    ...options.limits
+  };
+  for (const [name, value] of Object.entries(limits)) {
+    if (!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;
+  }
+  context;
+  limits;
+  signal;
+  callerSignal;
+  admission;
+  work = 0;
+  checkpoint = 0;
+  retained = 0;
+  input = 0;
+  output = 0;
+  diagnostics = 0;
+  chunks = 0;
+  empties = 0;
+  assertOpen() {
+    this.signal.throwIfAborted();
+    if (this.admission.closed) throw new IconvError("command is closed");
+  }
+  check(value, maximum, label) {
+    if (!Number.isSafeInteger(value) || value < 0 || value > maximum) throw new IconvError(`${label} limit exceeded`);
+  }
+  charge(amount = 1) {
+    this.assertOpen();
+    this.check(this.work + amount, this.limits.maxWork, "work");
+    this.work += amount;
+  }
+  async checkpointWork() {
+    this.assertOpen();
+    if (this.work - this.checkpoint >= 4096) {
+      this.checkpoint = this.work;
+      await yieldTurn(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/src/commands/iconv/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/src/commands/iconv/reader.ts
+init_platform();
+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(maximum);
+          try {
+            const readFile = fs.readFile;
+            this.lifecycle.assertOpen();
+            const content = await Reflect.apply(readFile, fs, [path, { signal: budget.signal, 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(-maximum);
+          }
+          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;
+      await budget.checkpointWork();
+    }
+    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);
+      await budget.checkpointWork();
+    }
+    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/src/commands/iconv/options.ts
+init_platform();
+function encoding(value) {
+  const key = value.toUpperCase();
+  const 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"
+  };
+  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;
+}
+function parse(budget) {
+  const args = budget.arguments();
+  let from, to, discard = false, ended = 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.startsWith("--")) throw new IconvError(`unsupported option: ${argument}`, 64);
+    for (let offset = 1; offset < argument.length; offset++) {
+      const flag = argument[offset];
+      if (flag === "c") {
+        discard = true;
+        continue;
+      }
+      if (flag !== "f" && flag !== "t") 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 to = value;
+      break;
+    }
+  }
+  const transliterate = to?.toUpperCase().endsWith("//TRANSLIT") ?? false;
+  if (transliterate) to = to.slice(0, -10);
+  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 : ["-"] };
+}
+
+// packages/safe-bash/src/commands/iconv/codec.ts
+init_platform();
+
+// packages/safe-bash/src/commands/iconv/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/src/commands/iconv/codec.ts
+function decode(input, offset, encoding2, swap) {
+  const first = input[offset];
+  if (encoding2 === "ascii") return first < 128 ? { count: 1, value: first } : { count: 1, error: "illegal" };
+  if (encoding2 === "latin1") return { count: 1, value: first };
+  if (encoding2 === "utf8") {
+    if (first < 128) return { count: 1, value: 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 < 248) {
+      count = 4;
+      value = first & 7;
+    } else if (first >= 248 && first < 252) {
+      count = 5;
+      value = first & 3;
+    } else if (first >= 252 && first < 254) {
+      count = 6;
+      value = first & 1;
+    } 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 >= 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 (encoding2 === "ascii" || encoding2 === "latin1") {
+    if (value < (encoding2 === "ascii" ? 128 : 256)) return [value];
+    if (value >= 917504 && value <= 917631) return [];
+    return void 0;
+  }
+  if (encoding2 === "utf8") {
+    if (value < 128) return [value];
+    let count = 2;
+    while (count < 6 && 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;
+  }
+  if (value > 1114111) return void 0;
+  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.subarray(0, used));
+      used = 0;
+      status = 0;
+    }
+  };
+  const flushFullOutput = async () => {
+    await flush();
+    batchCount = 1;
+    suppressed = false;
+    targetSuppressed = false;
+    firstTargetBatch = false;
+  };
+  const append = async (bytes, transliterated = false) => {
+    let recursiveBom = transliterated && firstTargetBatch && options.to === "utf16";
+    if (buffer.length - used < bytes.length + (recursiveBom ? 2 : 0)) {
+      await flushFullOutput();
+      recursiveBom = false;
+    }
+    if (recursiveBom) {
+      buffer[used++] = 255;
+      buffer[used++] = 254;
+    }
+    buffer.set(bytes, used);
+    used += bytes.length;
+  };
+  try {
+    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;
+    }
+    while (offset < input.length) {
+      budget.charge(16);
+      await budget.checkpointWork();
+      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") await append([255, 254]);
+        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);
+          bytes = [];
+          for (const character of replacement) bytes.push(...encode(character.charCodeAt(0), options.to));
+        }
+        if (bytes === void 0) {
+          error = "illegal";
+          targetSuppressed = true;
+        } else await append(bytes, transliterated);
+      }
+      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/src/commands/iconv/command.ts
+async function transcode(options, lifecycle) {
+  const state = { swap: false };
+  let exitCode = 0, stdinUsed = false;
+  for (const file of options.files) {
+    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 FsError)) 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;
+  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 method = destination.write;
+    lifecycle.assertOpen();
+    await Reflect.apply(method, destination, [value]);
+  };
+  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);
+    exitCode = await transcode(parse(budget), lifecycle);
+  } 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/src/commands/iconv/index.ts
+function createIconvCommands(options = {}) {
+  return [createIconvCommand(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 });
+  } };
+}
+
+export {
+  createIconvCommand,
+  createIconvCommands,
+  iconvCommands
+};
+//# sourceMappingURL=chunk-A4UXQKWZ.js.map