@orieljs/framework 0.1.0-alpha.1 → 0.1.0-alpha.10

package/dist/chunk-7ZQZYDOC.js

@@ -0,0 +1,3253 @@
+import {
+  Application,
+  ConfigRepository,
+  Container
+} from "./chunk-GVNLZZTN.js";
+
+// ../Container/dist/index.js
+import { AsyncLocalStorage } from "async_hooks";
+function describe(abstract) {
+  return typeof abstract === "function" ? abstract.name || "<anonymous class>" : abstract.description;
+}
+var BindingResolutionError = class extends Error {
+  kind = "BindingResolution";
+  name = "BindingResolutionError";
+};
+var CircularDependencyError = class extends Error {
+  constructor(chain) {
+    super(`Circular dependency detected: ${chain.join(" -> ")}`);
+    this.chain = chain;
+  }
+  chain;
+  kind = "CircularDependency";
+  name = "CircularDependencyError";
+};
+var ContainerNotAvailableError = class extends Error {
+  kind = "ContainerNotAvailable";
+  name = "ContainerNotAvailableError";
+  constructor(what) {
+    super(
+      `Cannot resolve [${what}]: no container is available. inject(), helpers and facades only work while the application is running (inside a request, job, command, provider or app.run()). Don't call them at module top level.`
+    );
+  }
+};
+var ALS_KEY = /* @__PURE__ */ Symbol.for("oriel:container.als");
+var GLOBAL_KEY = /* @__PURE__ */ Symbol.for("oriel:container.instance");
+var BUILDING_KEY = /* @__PURE__ */ Symbol.for("oriel:container.building");
+var g = globalThis;
+var storage = g[ALS_KEY] ??= new AsyncLocalStorage();
+var building = g[BUILDING_KEY] ??= {
+  keys: [],
+  names: [],
+  containers: []
+};
+function currentContainer() {
+  return building.containers.at(-1) ?? storage.getStore() ?? g[GLOBAL_KEY];
+}
+function inject(abstract) {
+  const container = currentContainer();
+  if (!container) throw new ContainerNotAvailableError(describe(abstract));
+  return container.make(abstract);
+}
+var globals = globalThis;
+var keyOf = (abstract) => typeof abstract === "function" ? abstract : abstract.id;
+var isClass = (fn) => typeof fn === "function" && /^class[\s{]/.test(Function.prototype.toString.call(fn));
+var Container2 = class _Container {
+  static getInstance() {
+    return globals[GLOBAL_KEY];
+  }
+  static setInstance(container) {
+    globals[GLOBAL_KEY] = container;
+  }
+  shared;
+  root;
+  parent;
+  local = /* @__PURE__ */ new Map();
+  constructor(parent) {
+    this.parent = parent;
+    this.root = parent?.root ?? this;
+    this.shared = parent?.shared ?? { bindings: /* @__PURE__ */ new Map(), extenders: /* @__PURE__ */ new Map(), resolving: /* @__PURE__ */ new Map(), resolved: /* @__PURE__ */ new Set() };
+    this.local.set(keyOf(Container), this);
+    this.local.set(_Container, this);
+  }
+  bind(abstract, concrete) {
+    this.#assertRoot("bind");
+    this.#addBinding(abstract, concrete, "transient");
+  }
+  singleton(abstract, concrete) {
+    this.#assertRoot("singleton");
+    this.#addBinding(abstract, concrete, "singleton");
+  }
+  scoped(abstract, concrete) {
+    this.#assertRoot("scoped");
+    this.#addBinding(abstract, concrete, "scoped");
+  }
+  instance(abstract, instance) {
+    const key = keyOf(abstract);
+    this.local.set(key, instance);
+    if (this === this.root) this.shared.resolved.add(key);
+    return instance;
+  }
+  make(abstract) {
+    const key = keyOf(abstract);
+    const owner = this.#owning(key);
+    if (owner) return owner.local.get(key);
+    const binding = this.shared.bindings.get(key) ?? this.#implicitBinding(abstract);
+    if (binding.lifetime === "scoped" && this === this.root) {
+      throw new BindingResolutionError(
+        `Scoped binding [${describe(abstract)}] was resolved outside a scope. Resolve it inside app.createScope().run(...), and don't inject scoped services into singletons.`
+      );
+    }
+    const builder = binding.lifetime === "singleton" ? this.root : this;
+    const instance = builder.build(abstract, key, binding);
+    if (binding.lifetime === "singleton") this.root.local.set(key, instance);
+    if (binding.lifetime === "scoped") this.local.set(key, instance);
+    return instance;
+  }
+  bound(abstract) {
+    const key = keyOf(abstract);
+    return this.shared.bindings.has(key) || this.#owning(key) !== void 0;
+  }
+  resolved(abstract) {
+    const key = keyOf(abstract);
+    return this.shared.resolved.has(key) || this.#owning(key) !== void 0;
+  }
+  extend(abstract, extender) {
+    this.#assertRoot("extend");
+    const key = keyOf(abstract);
+    const list = this.shared.extenders.get(key) ?? [];
+    list.push(extender);
+    this.shared.extenders.set(key, list);
+    if (this.local.has(key)) this.local.set(key, extender(this.local.get(key), this));
+  }
+  resolving(abstract, callback) {
+    this.#assertRoot("resolving");
+    const key = keyOf(abstract);
+    const list = this.shared.resolving.get(key) ?? [];
+    list.push(callback);
+    this.shared.resolving.set(key, list);
+  }
+  forgetInstance(abstract) {
+    this.local.delete(keyOf(abstract));
+  }
+  /** Scopes are always plain Containers (never subclasses such as Application). */
+  createScope() {
+    return new _Container(this);
+  }
+  run(fn) {
+    return storage.run(this, fn);
+  }
+  /** The nearest container in this -> parent scopes -> root that holds an instance for the key. */
+  #owning(key) {
+    if (this.local.has(key)) return this;
+    return this.parent === void 0 ? void 0 : this.parent.#owning(key);
+  }
+  /** Bindings, extenders and callbacks are app-wide state: a request scope must never write them. */
+  #assertRoot(method) {
+    if (this !== this.root) {
+      throw new Error(
+        `Cannot register bindings on a request scope (${method}). Register them on the application in a service provider; use instance() for per-request values.`
+      );
+    }
+  }
+  #addBinding(abstract, concrete, lifetime) {
+    const key = keyOf(abstract);
+    let factory;
+    if (concrete === void 0) {
+      if (typeof abstract !== "function") throw new TypeError(`bind(${describe(abstract)}) needs a concrete: tokens can't be constructed`);
+      factory = () => new abstract();
+    } else if (isClass(concrete)) {
+      factory = () => new concrete();
+    } else {
+      factory = concrete;
+    }
+    this.shared.bindings.set(key, { lifetime, factory });
+    this.local.delete(key);
+  }
+  #implicitBinding(abstract) {
+    if (typeof abstract === "function") {
+      return { lifetime: "transient", factory: () => new abstract() };
+    }
+    throw new BindingResolutionError(
+      `Target [${abstract.description}] is not bound. Is its service provider registered in bootstrap/providers.ts?`
+    );
+  }
+  build(abstract, key, binding) {
+    const stackIndex = building.keys.indexOf(key);
+    if (stackIndex !== -1) {
+      const chain = [...building.names.slice(stackIndex), describe(abstract)];
+      throw new CircularDependencyError(chain);
+    }
+    building.keys.push(key);
+    building.names.push(describe(abstract));
+    building.containers.push(this);
+    try {
+      let instance = binding.factory(this);
+      for (const extender of this.shared.extenders.get(key) ?? []) instance = extender(instance, this);
+      for (const callback of this.shared.resolving.get(key) ?? []) callback(instance, this);
+      this.shared.resolved.add(key);
+      return instance;
+    } finally {
+      building.keys.pop();
+      building.names.pop();
+      building.containers.pop();
+    }
+  }
+};
+
+// ../Collections/dist/index.js
+function compare(left, operator, right) {
+  switch (operator) {
+    case "=":
+    case "==":
+      return left == right;
+    case "===":
+      return left === right;
+    case "!=":
+    case "<>":
+      return left != right;
+    case "!==":
+      return left !== right;
+    case "<":
+      return left < right;
+    case "<=":
+      return left <= right;
+    case ">":
+      return left > right;
+    case ">=":
+      return left >= right;
+  }
+}
+function ascending(a, b) {
+  const aNil = a === null || a === void 0;
+  const bNil = b === null || b === void 0;
+  if (aNil || bNil) return aNil === bNil ? 0 : aNil ? 1 : -1;
+  if (typeof a === "number" && typeof b === "number") return a - b;
+  if (a instanceof Date && b instanceof Date) return a.getTime() - b.getTime();
+  return String(a).localeCompare(String(b));
+}
+var ItemNotFoundError = class extends Error {
+  name = "ItemNotFoundError";
+  constructor() {
+    super("Item not found.");
+  }
+};
+var MultipleItemsFoundError = class extends Error {
+  constructor(count) {
+    super(`${count} items were found.`);
+    this.count = count;
+  }
+  count;
+  name = "MultipleItemsFoundError";
+};
+var LazyCollection = class _LazyCollection {
+  constructor(source) {
+    this.source = source;
+  }
+  source;
+  static make(source) {
+    return new _LazyCollection(source);
+  }
+  async *[Symbol.asyncIterator]() {
+    yield* this.source();
+  }
+  map(callback) {
+    const self = this;
+    return new _LazyCollection(async function* () {
+      let i = 0;
+      for await (const item of self) yield await callback(item, i++);
+    });
+  }
+  filter(callback) {
+    const self = this;
+    return new _LazyCollection(async function* () {
+      let i = 0;
+      for await (const item of self) if (await callback(item, i++)) yield item;
+    });
+  }
+  take(count) {
+    const self = this;
+    return new _LazyCollection(async function* () {
+      if (count <= 0) return;
+      let taken = 0;
+      for await (const item of self) {
+        yield item;
+        if (++taken >= count) return;
+      }
+    });
+  }
+  chunk(size) {
+    const self = this;
+    return new _LazyCollection(async function* () {
+      if (size <= 0) return;
+      let buffer = [];
+      for await (const item of self) {
+        buffer.push(item);
+        if (buffer.length === size) {
+          yield new Collection(buffer);
+          buffer = [];
+        }
+      }
+      if (buffer.length) yield new Collection(buffer);
+    });
+  }
+  /** Return false from the callback to stop. */
+  async each(callback) {
+    let i = 0;
+    for await (const item of this) if (await callback(item, i++) === false) return;
+  }
+  async first(callback) {
+    for await (const item of this) if (!callback || await callback(item)) return item;
+    return void 0;
+  }
+  async count() {
+    let n = 0;
+    for await (const item of this) {
+      void item;
+      n++;
+    }
+    return n;
+  }
+  async collect() {
+    const items = [];
+    for await (const item of this) items.push(item);
+    return new Collection(items);
+  }
+};
+var read = (item, getter) => typeof getter === "function" ? getter(item) : item?.[getter];
+var isArrayable = (v) => typeof v === "object" && v !== null && typeof v.toArray === "function";
+var numbers = (items, getter) => items.map((item) => getter === void 0 ? item : read(item, getter)).filter((v) => typeof v === "number" && !Number.isNaN(v));
+var isNil = (value2) => value2 === null || value2 === void 0;
+var predicateFor = (value2) => typeof value2 === "function" ? value2 : (item) => item === value2;
+var roundTo = (value2, precision) => Number(`${Math.round(Number(`${value2}e${precision}`))}e-${precision}`);
+var typeNameOf = (value2) => {
+  if (value2 === null) return "null";
+  if (Array.isArray(value2)) return "array";
+  if (typeof value2 === "object") return value2.constructor?.name ?? "object";
+  return typeof value2;
+};
+var isIndex = (index, length) => Number.isInteger(index) && index >= 0 && index < length;
+function compareBy(a, b, key, direction) {
+  const left = read(a, key);
+  const right = read(b, key);
+  const leftNil = isNil(left);
+  const rightNil = isNil(right);
+  if (leftNil || rightNil) return leftNil === rightNil ? 0 : leftNil ? 1 : -1;
+  return (direction === "asc" ? 1 : -1) * ascending(left, right);
+}
+function flattenItems(items, depth) {
+  const result = [];
+  for (const value2 of items) {
+    const item = value2 instanceof Collection ? value2.all() : value2;
+    if (!Array.isArray(item)) result.push(item);
+    else if (depth <= 1) result.push(...item);
+    else result.push(...flattenItems(item, depth - 1));
+  }
+  return result;
+}
+function whereCondition(args) {
+  const [key, operatorOrValue, value2] = args;
+  if (args.length === 1) return (item) => Boolean(read(item, key));
+  if (args.length === 2) return (item) => compare(read(item, key), "=", operatorOrValue);
+  return (item) => compare(read(item, key), operatorOrValue, value2);
+}
+function uniqueWith(values, equal) {
+  const result = [];
+  for (const value2 of values) if (!result.some((seen) => equal(seen, value2))) result.push(value2);
+  return result;
+}
+var loose = (a, b) => a == b;
+var strict = (a, b) => a === b;
+var Collection = class _Collection {
+  items;
+  constructor(items = []) {
+    this.items = [...items];
+  }
+  static make(items = []) {
+    return new _Collection(items);
+  }
+  /** Laravel semantics: callback receives 1..n. */
+  static times(count, callback) {
+    return new _Collection(Array.from({ length: Math.max(0, count) }, (_, i) => callback(i + 1)));
+  }
+  /** The numbers from `from` to `to`, inclusive, counting up or down by `step` (PHP's range()). */
+  static range(from, to, step = 1) {
+    if (step === 0) throw new RangeError("range(): Argument #3 ($step) cannot be 0");
+    const size = Math.abs(step);
+    const numbers2 = [];
+    if (from <= to) for (let n = from; n <= to; n += size) numbers2.push(n);
+    else for (let n = from; n >= to; n -= size) numbers2.push(n);
+    return new _Collection(numbers2);
+  }
+  static wrap(value2) {
+    if (value2 instanceof _Collection) return new _Collection(value2.all());
+    if (Array.isArray(value2)) return new _Collection(value2);
+    return new _Collection(isNil(value2) ? [] : [value2]);
+  }
+  static unwrap(value2) {
+    return value2 instanceof _Collection ? value2.all() : value2;
+  }
+  static empty() {
+    return new _Collection();
+  }
+  /** The decoded JSON: an array's items, nothing for null, else the one value. */
+  static fromJson(json) {
+    return _Collection.wrap(JSON.parse(json));
+  }
+  /** A new collection of the receiver's class (a subclass keeps its class through filter(), sortBy(), …). */
+  newInstance(items = []) {
+    return new this.constructor(items);
+  }
+  [Symbol.iterator]() {
+    return this.items[Symbol.iterator]();
+  }
+  all() {
+    return [...this.items];
+  }
+  count() {
+    return this.items.length;
+  }
+  isEmpty() {
+    return this.items.length === 0;
+  }
+  isNotEmpty() {
+    return this.items.length > 0;
+  }
+  toArray() {
+    return this.items.map((i) => isArrayable(i) ? i.toArray() : i);
+  }
+  toJSON() {
+    return this.all();
+  }
+  toJson() {
+    return JSON.stringify(this);
+  }
+  get(index, defaultValue) {
+    if (Number.isInteger(index) && index >= 0 && index < this.items.length) return this.items[index];
+    return typeof defaultValue === "function" ? defaultValue() : defaultValue;
+  }
+  /** Whether every given index exists. */
+  has(...indexes) {
+    return indexes.flat().every((index) => Number.isInteger(index) && index >= 0 && index < this.items.length);
+  }
+  /** Whether any of the given indexes exists. */
+  hasAny(...indexes) {
+    if (this.isEmpty()) return false;
+    return indexes.flat().some((index) => this.has(index));
+  }
+  search(value2, strict2 = false) {
+    const index = typeof value2 === "function" ? this.items.findIndex(value2) : this.items.findIndex((item) => strict2 ? item === value2 : item == value2);
+    return index === -1 ? false : index;
+  }
+  before(value2, strict2 = false) {
+    const index = this.search(value2, strict2);
+    return index === false || index === 0 ? void 0 : this.items[index - 1];
+  }
+  after(value2, strict2 = false) {
+    const index = this.search(value2, strict2);
+    return index === false ? void 0 : this.items[index + 1];
+  }
+  value(key, defaultValue) {
+    const item = this.items.find((candidate) => Boolean(read(candidate, key)));
+    if (item !== void 0) return read(item, key);
+    return typeof defaultValue === "function" ? defaultValue() : defaultValue;
+  }
+  every(...args) {
+    if (args.length === 1 && typeof args[0] === "function") return this.items.every(args[0]);
+    const condition = whereCondition(args);
+    return this.items.every((item) => condition(item));
+  }
+  contains(keyOrValue, operatorOrValue, value2) {
+    if (arguments.length === 3) return this.items.some(whereCondition([keyOrValue, operatorOrValue, value2]));
+    if (arguments.length === 2) return this.items.some((item) => read(item, keyOrValue) === operatorOrValue);
+    if (typeof keyOrValue === "function") return this.items.some(keyOrValue);
+    return this.items.includes(keyOrValue);
+  }
+  some(...args) {
+    return Reflect.apply(this.contains, this, args);
+  }
+  containsStrict(...args) {
+    return Reflect.apply(this.contains, this, args);
+  }
+  doesntContain(...args) {
+    return !Reflect.apply(this.contains, this, args);
+  }
+  doesntContainStrict(...args) {
+    return !Reflect.apply(this.contains, this, args);
+  }
+  /** Whether there is exactly one item (that passes the callback). */
+  containsOneItem(callback) {
+    return (callback ? this.items.filter(callback) : this.items).length === 1;
+  }
+  sole(...args) {
+    const items = this.matching(args);
+    if (items.length === 0) throw new ItemNotFoundError();
+    if (items.length > 1) throw new MultipleItemsFoundError(items.length);
+    return items[0];
+  }
+  firstOrFail(...args) {
+    const items = this.matching(args);
+    if (items.length === 0) throw new ItemNotFoundError();
+    return items[0];
+  }
+  /** The items a callback or a where condition (sole(), firstOrFail()) selects; every item without arguments. */
+  matching(args) {
+    if (args.length === 0 || args[0] === void 0) return this.items;
+    if (args.length === 1) return this.items.filter(args[0]);
+    return this.items.filter(whereCondition(args));
+  }
+  // ---------------------------------------------------------------- transforming
+  map(callback) {
+    return new _Collection(this.items.map(callback));
+  }
+  flatMap(callback) {
+    return new _Collection(
+      this.items.flatMap((item, i) => {
+        const out = callback(item, i);
+        return out instanceof _Collection ? out.all() : out;
+      })
+    );
+  }
+  filter(callback) {
+    return this.newInstance(this.items.filter(callback ?? ((item) => Boolean(item))));
+  }
+  reject(callback) {
+    return this.newInstance(this.items.filter((item, i) => !callback(item, i)));
+  }
+  /** Return false from the callback to stop. */
+  each(callback) {
+    for (let i = 0; i < this.items.length; i++) if (callback(this.items[i], i) === false) break;
+    return this;
+  }
+  reduce(callback, initial) {
+    return this.items.reduce(callback, initial);
+  }
+  first(callback, defaultValue) {
+    if (!callback) return this.items[0];
+    const index = this.items.findIndex(callback);
+    return index === -1 ? defaultValue : this.items[index];
+  }
+  last(callback, defaultValue) {
+    if (!callback) return this.items.at(-1);
+    const index = this.items.findLastIndex(callback);
+    return index === -1 ? defaultValue : this.items[index];
+  }
+  where(...args) {
+    return this.filter(whereCondition(args));
+  }
+  /** where() with strict comparison (===). */
+  whereStrict(key, value2) {
+    return this.filter((item) => read(item, key) === value2);
+  }
+  firstWhere(...args) {
+    return this.items.find(whereCondition(args));
+  }
+  whereIn(key, values) {
+    const set = new Set(values);
+    return this.filter((item) => set.has(read(item, key)));
+  }
+  /** whereIn() under Laravel's strict name (whereIn() already compares strictly). */
+  whereInStrict(key, values) {
+    return this.whereIn(key, values);
+  }
+  whereNotIn(key, values) {
+    const set = new Set(values);
+    return this.filter((item) => !set.has(read(item, key)));
+  }
+  whereNotInStrict(key, values) {
+    return this.whereNotIn(key, values);
+  }
+  /** Items whose key (or the item itself) is null or undefined (a missing key counts as null). */
+  whereNull(key) {
+    return this.filter((item) => isNil(key === void 0 ? item : read(item, key)));
+  }
+  whereNotNull(key) {
+    return this.filter((item) => !isNil(key === void 0 ? item : read(item, key)));
+  }
+  /** Items whose key is within the first and last values, inclusive. */
+  whereBetween(key, values) {
+    return this.where(key, ">=", values[0]).where(key, "<=", values.at(-1));
+  }
+  whereNotBetween(key, values) {
+    return this.filter((item) => {
+      const value2 = read(item, key);
+      return value2 < values[0] || value2 > values.at(-1);
+    });
+  }
+  /** Items that are instances of the class (or of any of the classes). */
+  whereInstanceOf(type2) {
+    const types = [type2].flat();
+    return this.filter((item) => types.some((cls) => item instanceof cls));
+  }
+  pluck(key) {
+    return this.map((item) => read(item, key));
+  }
+  keyBy(key) {
+    return Object.fromEntries(this.items.map((item) => [String(read(item, key)), item]));
+  }
+  groupBy(key) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const item of this.items) {
+      const name = String(read(item, key));
+      groups.set(name, (groups.get(name) ?? this.newInstance()).push(item));
+    }
+    return Object.fromEntries(groups);
+  }
+  mapWithKeys(callback) {
+    return Object.fromEntries(this.items.map(callback));
+  }
+  duplicates(key) {
+    return this.repeated(key, loose);
+  }
+  duplicatesStrict(key) {
+    return this.repeated(key, strict);
+  }
+  /** Laravel's duplicates(): each value after the first of its kind. */
+  repeated(key, equal) {
+    const values = this.items.map((item) => key === void 0 ? item : read(item, key));
+    const unique = uniqueWith(values, equal);
+    const duplicates = [];
+    for (const value2 of values) {
+      if (unique.length && equal(value2, unique[0])) unique.shift();
+      else duplicates.push(value2);
+    }
+    return new _Collection(duplicates);
+  }
+  /** The items that aren't in the given items (strict comparison). */
+  diff(items) {
+    const other = new Set(items);
+    return this.filter((item) => !other.has(item));
+  }
+  /** diff() with a comparator that returns 0 for equal items. */
+  diffUsing(items, callback) {
+    const other = [...items];
+    return this.filter((item) => !other.some((candidate) => callback(item, candidate) === 0));
+  }
+  /** The items that are also in the given items (strict comparison). */
+  intersect(items) {
+    const other = new Set(items);
+    return this.filter((item) => other.has(item));
+  }
+  intersectUsing(items, callback) {
+    const other = [...items];
+    return this.filter((item) => other.some((candidate) => callback(item, candidate) === 0));
+  }
+  // ---------------------------------------------------------------- ordering and slicing
+  /** Sorted with the default ascending order (numbers, dates, then strings), or by a comparator. */
+  sort(callback) {
+    return this.newInstance([...this.items].sort(callback ?? ((a, b) => ascending(a, b))));
+  }
+  sortDesc() {
+    return this.newInstance([...this.items].sort((a, b) => ascending(b, a)));
+  }
+  sortBy(keyOrSteps, direction = "asc") {
+    const steps = Array.isArray(keyOrSteps) ? keyOrSteps : [[keyOrSteps, direction]];
+    const comparators = steps.map((step) => {
+      if (typeof step === "function" && step.length >= 2) return step;
+      const [key, order = "asc"] = Array.isArray(step) ? step : [step];
+      return (a, b) => compareBy(a, b, key, order);
+    });
+    return this.newInstance(
+      this.items.map((item, index) => ({ item, index })).sort((a, b) => {
+        for (const comparator of comparators) {
+          const result = comparator(a.item, b.item);
+          if (result) return result;
+        }
+        return a.index - b.index;
+      }).map((x) => x.item)
+    );
+  }
+  sortByDesc(key) {
+    return this.sortBy(key, "desc");
+  }
+  sum(key) {
+    return numbers(this.items, key).reduce((a, b) => a + b, 0);
+  }
+  avg(key) {
+    const values = numbers(this.items, key);
+    return values.length ? values.reduce((a, b) => a + b, 0) / values.length : void 0;
+  }
+  min(key) {
+    const values = numbers(this.items, key);
+    return values.length ? Math.min(...values) : void 0;
+  }
+  max(key) {
+    const values = numbers(this.items, key);
+    return values.length ? Math.max(...values) : void 0;
+  }
+  /** avg() under Laravel's other name. */
+  average(key) {
+    return this.avg(key);
+  }
+  /** The middle number (the mean of the two middle ones for an even count), ignoring null and non-numbers. */
+  median(key) {
+    const values = numbers(this.items, key).sort((a, b) => a - b);
+    if (!values.length) return void 0;
+    const middle = Math.floor(values.length / 2);
+    return values.length % 2 ? values[middle] : (values[middle - 1] + values[middle]) / 2;
+  }
+  mode(key) {
+    if (this.isEmpty()) return void 0;
+    const counts = /* @__PURE__ */ new Map();
+    for (const item of this.items) {
+      const value2 = key === void 0 ? item : read(item, key);
+      counts.set(value2, (counts.get(value2) ?? 0) + 1);
+    }
+    const highest = Math.max(...counts.values());
+    return [...counts].filter(([, count]) => count === highest).map(([value2]) => value2);
+  }
+  /** The share of items that pass the callback, as a percentage rounded to `precision` places; undefined when empty. */
+  percentage(callback, precision = 2) {
+    if (this.isEmpty()) return void 0;
+    return roundTo(this.items.filter(callback).length / this.items.length * 100, precision);
+  }
+  /** How many items have each value, key value or callback result: [1, 2, 2].countBy() → { 1: 1, 2: 2 }. */
+  countBy(key) {
+    const counts = /* @__PURE__ */ new Map();
+    for (const item of this.items) {
+      const value2 = String(key === void 0 ? item : read(item, key));
+      counts.set(value2, (counts.get(value2) ?? 0) + 1);
+    }
+    return Object.fromEntries(counts);
+  }
+  /** Groups the callback's [key, value] pairs: values under the same key are collected in arrays. */
+  mapToDictionary(callback) {
+    const dictionary = /* @__PURE__ */ new Map();
+    this.items.forEach((item, index) => {
+      const [key, value2] = callback(item, index);
+      const name = String(key);
+      const values = dictionary.get(name) ?? [];
+      values.push(value2);
+      dictionary.set(name, values);
+    });
+    return Object.fromEntries(dictionary);
+  }
+  /** mapToDictionary() with each group as a collection. */
+  mapToGroups(callback) {
+    return Object.fromEntries(Object.entries(this.mapToDictionary(callback)).map(([key, values]) => [key, new _Collection(values)]));
+  }
+  /** A new instance of the class for each item: new cls(item, index). */
+  mapInto(cls) {
+    return this.map((item, index) => new cls(item, index));
+  }
+  /** Maps nested arrays (or collections) with their items as the arguments, then the index. */
+  mapSpread(callback) {
+    return this.map((chunk, index) => callback(...[...chunk instanceof _Collection ? chunk.all() : chunk, index]));
+  }
+  /** each() with the nested items as the arguments, then the index. Return false to stop. */
+  eachSpread(callback) {
+    return this.each((chunk, index) => callback(...[...chunk instanceof _Collection ? chunk.all() : chunk, index]));
+  }
+  /** reduce() with several carried values: the reducer gets them, then the item and index, and returns them as an array. */
+  reduceSpread(callback, ...initial) {
+    let result = initial;
+    this.items.forEach((item, index) => {
+      result = callback(...result, item, index);
+      if (!Array.isArray(result)) {
+        throw new TypeError(`${this.constructor.name}::reduceSpread expects reducer to return an array, but got a '${typeNameOf(result)}' instead.`);
+      }
+    });
+    return result;
+  }
+  /** The first item of each value (strict comparison), or of each key or callback value. */
+  unique(key) {
+    const seen = /* @__PURE__ */ new Set();
+    return this.filter((item) => {
+      const v = key === void 0 ? item : read(item, key);
+      if (seen.has(v)) return false;
+      seen.add(v);
+      return true;
+    });
+  }
+  /** unique() under Laravel's strict name (unique() already compares strictly). */
+  uniqueStrict(key) {
+    return this.unique(key);
+  }
+  chunk(size) {
+    if (size <= 0) return new _Collection();
+    const chunks = [];
+    for (let i = 0; i < this.items.length; i += size) chunks.push(this.newInstance(this.items.slice(i, i + size)));
+    return new _Collection(chunks);
+  }
+  /** Negative count takes from the end. */
+  take(count) {
+    return this.newInstance(count < 0 ? this.items.slice(count) : this.items.slice(0, count));
+  }
+  skip(count) {
+    return this.newInstance(this.items.slice(count));
+  }
+  /** PHP's array_slice(): a negative offset counts from the end; a negative length leaves that many off the end. */
+  slice(offset, length) {
+    const size = this.items.length;
+    const start = offset < 0 ? Math.max(0, size + offset) : Math.min(offset, size);
+    const end = length === void 0 ? size : length < 0 ? size + length : start + length;
+    return this.newInstance(this.items.slice(start, Math.max(start, end)));
+  }
+  values() {
+    return this.newInstance(this.items);
+  }
+  /** Mutates, like Laravel. */
+  push(...values) {
+    this.items.push(...values);
+    return this;
+  }
+  concat(values) {
+    return this.newInstance([...this.items, ...values]);
+  }
+  partition(callback) {
+    return [this.filter(callback), this.reject(callback)];
+  }
+  reverse() {
+    return this.newInstance([...this.items].reverse());
+  }
+  shuffle() {
+    const items = [...this.items];
+    for (let i = items.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      [items[i], items[j]] = [items[j], items[i]];
+    }
+    return this.newInstance(items);
+  }
+  random(count) {
+    const requested = typeof count === "function" ? count(this) : count;
+    const wanted = requested ?? 1;
+    if (wanted > this.items.length) {
+      throw new RangeError(`You requested ${wanted} items, but there are only ${this.items.length} items available.`);
+    }
+    if (requested === void 0) return this.items[Math.floor(Math.random() * this.items.length)];
+    const indexes = [...this.items.keys()];
+    for (let i = indexes.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      [indexes[i], indexes[j]] = [indexes[j], indexes[i]];
+    }
+    return this.newInstance(indexes.slice(0, Math.max(0, wanted)).sort((a, b) => a - b).map((index) => this.items[index]));
+  }
+  /** Every step-th item, starting at offset. */
+  nth(step, offset = 0) {
+    return this.newInstance(this.items.slice(offset).filter((_, position) => position % step === 0));
+  }
+  /** Pads to `size` items with the value; a negative size pads at the start (PHP's array_pad()). */
+  pad(size, value2) {
+    const missing = Math.abs(size) - this.items.length;
+    if (missing <= 0) return new _Collection(this.items);
+    const padding = Array.from({ length: missing }, () => value2);
+    return new _Collection(size < 0 ? [...padding, ...this.items] : [...this.items, ...padding]);
+  }
+  /** The items of one page: forPage(2, 15). */
+  forPage(page, perPage) {
+    return this.slice(Math.max(0, (page - 1) * perPage), perPage);
+  }
+  /** `count` groups of nearly equal size, the first ones larger. */
+  split(count) {
+    const groups = [];
+    if (this.isEmpty()) return new _Collection(groups);
+    const size = Math.floor(this.items.length / count);
+    const remain = this.items.length % count;
+    let start = 0;
+    for (let i = 0; i < count; i++) {
+      const length = size + (i < remain ? 1 : 0);
+      if (!length) continue;
+      groups.push(this.newInstance(this.items.slice(start, start + length)));
+      start += length;
+    }
+    return new _Collection(groups);
+  }
+  /** `count` groups, every group full except the last. */
+  splitIn(count) {
+    return this.chunk(Math.ceil(this.items.length / count));
+  }
+  /** Overlapping windows of `size` items, `step` apart: [1, 2, 3].sliding(2) → [[1, 2], [2, 3]]. */
+  sliding(size = 2, step = 1) {
+    const windows = Math.floor((this.items.length - size) / step) + 1;
+    return _Collection.times(windows, (number) => this.slice((number - 1) * step, size));
+  }
+  /** Chunks that grow while the callback (value, index, the current chunk) returns true. */
+  chunkWhile(callback) {
+    const chunks = [];
+    let chunk = this.newInstance();
+    this.items.forEach((item, index) => {
+      if (index > 0 && !callback(item, index, chunk)) {
+        chunks.push(chunk);
+        chunk = this.newInstance();
+      }
+      chunk.push(item);
+    });
+    if (chunk.isNotEmpty()) chunks.push(chunk);
+    return new _Collection(chunks);
+  }
+  takeUntil(value2) {
+    const stop = this.items.findIndex(predicateFor(value2));
+    return this.newInstance(stop === -1 ? this.items : this.items.slice(0, stop));
+  }
+  takeWhile(value2) {
+    const keep = predicateFor(value2);
+    const stop = this.items.findIndex((item, index) => !keep(item, index));
+    return this.newInstance(stop === -1 ? this.items : this.items.slice(0, stop));
+  }
+  skipUntil(value2) {
+    const start = this.items.findIndex(predicateFor(value2));
+    return this.newInstance(start === -1 ? [] : this.items.slice(start));
+  }
+  skipWhile(value2) {
+    const skip = predicateFor(value2);
+    const start = this.items.findIndex((item, index) => !skip(item, index));
+    return this.newInstance(start === -1 ? [] : this.items.slice(start));
+  }
+  /** The items at the given indexes, in collection order. */
+  only(...indexes) {
+    const wanted = new Set(indexes.flat());
+    return this.newInstance(this.items.filter((_, index) => wanted.has(index)));
+  }
+  /** The items except those at the given indexes. */
+  except(...indexes) {
+    const unwanted = new Set(indexes.flat());
+    return this.newInstance(this.items.filter((_, index) => !unwanted.has(index)));
+  }
+  /** The indexes: 0, 1, 2, … */
+  keys() {
+    return new _Collection(this.items.keys());
+  }
+  pop(count) {
+    if (count === void 0) return this.items.pop();
+    const removed = [];
+    while (removed.length < count && this.items.length) removed.push(this.items.pop());
+    return this.newInstance(removed);
+  }
+  shift(count) {
+    if (count !== void 0 && count < 0) throw new RangeError("Number of shifted items may not be less than zero.");
+    if (count === void 0) return this.items.shift();
+    return this.newInstance(this.items.splice(0, count));
+  }
+  /** Adds an item at the start (mutates). */
+  prepend(value2) {
+    this.items.unshift(value2);
+    return this;
+  }
+  /** Adds items at the start, in the given order (mutates). */
+  unshift(...values) {
+    this.items.unshift(...values);
+    return this;
+  }
+  /** Adds one item at the end (mutates). */
+  add(item) {
+    this.items.push(item);
+    return this;
+  }
+  /** Sets the item at an index (mutates); an index at or past the end appends. */
+  put(index, value2) {
+    if (!Number.isInteger(index) || index < 0) throw new RangeError(`Invalid collection index [${index}].`);
+    if (index < this.items.length) this.items[index] = value2;
+    else this.items.push(value2);
+    return this;
+  }
+  pull(index, defaultValue) {
+    if (isIndex(index, this.items.length)) return this.items.splice(index, 1)[0];
+    return typeof defaultValue === "function" ? defaultValue() : defaultValue;
+  }
+  /** Removes the items at the given indexes (mutates); the later items move up. */
+  forget(...indexes) {
+    const remove = [...new Set(indexes.flat())].filter((index) => isIndex(index, this.items.length)).sort((a, b) => b - a);
+    for (const index of remove) this.items.splice(index, 1);
+    return this;
+  }
+  /**
+   * Removes `length` items from `offset` (mutates), inserting the replacement there, and returns the removed items
+   * (PHP's array_splice(): a negative offset counts from the end; a negative length leaves that many at the end).
+   */
+  splice(offset, length, replacement = []) {
+    const size = this.items.length;
+    const start = offset < 0 ? Math.max(0, size + offset) : Math.min(offset, size);
+    const count = length === void 0 ? size - start : length < 0 ? Math.max(0, size + length - start) : length;
+    return this.newInstance(this.items.splice(start, count, ...replacement));
+  }
+  /** Replaces every item with the callback's result (mutates) and returns this collection, typed with the new items. */
+  transform(callback) {
+    const items = this.items;
+    items.forEach((item, index) => {
+      items[index] = callback(item, index);
+    });
+    return this;
+  }
+  /**
+   * A copy with items replaced by index: an array from index 0, or { index: value }; past the end appends, and a
+   * negative or fractional index throws a RangeError, as put() does.
+   */
+  replace(items) {
+    const copy = this.newInstance(this.items);
+    const entries = Symbol.iterator in items ? [...items].map((value2, index) => [index, value2]) : Object.entries(items).map(([index, value2]) => [Number(index), value2]);
+    for (const [index, value2] of [...entries].sort((a, b) => a[0] - b[0])) copy.put(index, value2);
+    return copy;
+  }
+  // ---------------------------------------------------------------- building collections
+  /** One level of nested arrays and collections, merged (other items are dropped). */
+  collapse() {
+    const result = [];
+    for (const item of this.items) {
+      if (item instanceof _Collection) result.push(...item.all());
+      else if (Array.isArray(item)) result.push(...item);
+    }
+    return new _Collection(result);
+  }
+  flatten(depth = Infinity) {
+    return new _Collection(flattenItems(this.items, depth));
+  }
+  /** Every combination of the items with the lists' items: [1, 2] × ['a'] → [[1, 'a'], [2, 'a']]. */
+  crossJoin(...lists) {
+    let rows = this.items.map((item) => [item]);
+    for (const list of lists) {
+      const values = [...list];
+      rows = rows.flatMap((row) => values.map((value2) => [...row, value2]));
+    }
+    return new _Collection(rows);
+  }
+  /** Pairs items by index with the lists' items, as collections; the shorter lists give undefined. */
+  zip(...lists) {
+    const arrays = lists.map((list) => [...list]);
+    const length = Math.max(this.items.length, ...arrays.map((array) => array.length));
+    return _Collection.times(length, (number) => new _Collection([this.items[number - 1], ...arrays.map((array) => array[number - 1])]));
+  }
+  /** The items as keys for the values: ['name', 'age'].combine(['George', 29]) → { name: 'George', age: 29 }. */
+  combine(values) {
+    const list = [...values];
+    if (list.length !== this.items.length) {
+      throw new RangeError("combine(): the keys and the values must have the same number of items.");
+    }
+    return Object.fromEntries(this.items.map((key, index) => [String(key), list[index]]));
+  }
+  /** Each item as a key for its index: ['a', 'b'] → { a: 0, b: 1 }. */
+  flip() {
+    return Object.fromEntries(this.items.map((item, index) => [String(item), index]));
+  }
+  /** The items followed by the given ones (a list merges by appending). */
+  merge(items) {
+    return this.concat(items);
+  }
+  /** The items repeated `multiplier` times. */
+  multiply(multiplier) {
+    return this.newInstance(Array.from({ length: Math.max(0, multiplier) }, () => this.items).flat());
+  }
+  /**
+   * Each item reduced to the given keys it has: select(['name', 'role']). An item has a key when `key in item` or
+   * reading it gives a value, so a model's attributes, which its proxy serves on read, are kept.
+   */
+  select(...keys) {
+    const names = keys.flat();
+    return this.map((item) => {
+      const picked = {};
+      if (typeof item !== "object" || item === null) return picked;
+      for (const key of names) {
+        const value2 = item[key];
+        if (key in item || value2 !== void 0) picked[key] = value2;
+      }
+      return picked;
+    });
+  }
+  /** A LazyCollection over a copy of the items: later changes to this collection don't reach it. */
+  lazy() {
+    const items = this.all();
+    return LazyCollection.make(() => items);
+  }
+  /** A base collection with the same items. */
+  collect() {
+    return new _Collection(this.items);
+  }
+  implode(keyOrGlue, glue) {
+    if (typeof keyOrGlue === "function") return this.items.map(keyOrGlue).join(glue);
+    if (glue === void 0) return this.items.join(keyOrGlue);
+    return this.items.map((item) => read(item, keyOrGlue)).join(glue);
+  }
+  /** implode() with a different glue before the last item: join(', ', ' and ') → 'a, b and c'. */
+  join(glue, finalGlue = "") {
+    if (finalGlue === "" || this.items.length < 2) return this.implode(glue);
+    return `${this.items.slice(0, -1).join(glue)}${finalGlue}${String(this.items.at(-1))}`;
+  }
+  /**
+   * Runs the callback (collection, value) when the value is truthy, else the default; a function value is called with
+   * the collection first. Returns what the callback returns, or the collection when it returns nothing.
+   */
+  when(value2, callback, otherwise) {
+    const resolved = typeof value2 === "function" ? value2(this) : value2;
+    const result = resolved ? callback(this, resolved) : otherwise?.(this, resolved);
+    return result ?? this;
+  }
+  /** when() with the condition reversed. */
+  unless(value2, callback, otherwise) {
+    const resolved = typeof value2 === "function" ? value2(this) : value2;
+    const result = !resolved ? callback(this, resolved) : otherwise?.(this, resolved);
+    return result ?? this;
+  }
+  whenEmpty(callback, otherwise) {
+    return this.when(this.isEmpty(), (collection) => callback(collection), otherwise && ((collection) => otherwise(collection)));
+  }
+  whenNotEmpty(callback, otherwise) {
+    return this.when(this.isNotEmpty(), (collection) => callback(collection), otherwise && ((collection) => otherwise(collection)));
+  }
+  /** whenNotEmpty() under Laravel's other name. */
+  unlessEmpty(callback, otherwise) {
+    return this.whenNotEmpty(callback, otherwise);
+  }
+  /** whenEmpty() under Laravel's other name. */
+  unlessNotEmpty(callback, otherwise) {
+    return this.whenEmpty(callback, otherwise);
+  }
+  pipe(callback) {
+    return callback(this);
+  }
+  /** new cls(collection). */
+  pipeInto(cls) {
+    return new cls(this);
+  }
+  pipeThrough(callbacks) {
+    return callbacks.reduce((carry, callback) => callback(carry), this);
+  }
+  tap(callback) {
+    callback(this);
+    return this;
+  }
+  /**
+   * Throws a TypeError unless every item is an instance of one of the classes or of one of the type names (typeof's,
+   * plus 'null' and 'array'), with Laravel's message. Returns the collection, typed with the checked items.
+   */
+  ensure(type2) {
+    const allowed = [type2].flat();
+    this.items.forEach((item, index) => {
+      const name = typeNameOf(item);
+      const ok = allowed.some((entry) => typeof entry === "string" ? entry === name || entry === "object" && typeof item === "object" && item !== null && !Array.isArray(item) : item instanceof entry);
+      if (!ok) {
+        const names = allowed.map((entry) => typeof entry === "string" ? entry : entry.name).join(", ");
+        throw new TypeError(`Collection should only include [${names}] items, but '${name}' found at position ${index}.`);
+      }
+    });
+    return this;
+  }
+  /** Logs the items (and any extra values) with console.log and returns the collection. */
+  dump(...values) {
+    console.log(this.all(), ...values);
+    return this;
+  }
+  /** JSON with four-space indentation (PHP's JSON_PRETTY_PRINT). */
+  toPrettyJson() {
+    return JSON.stringify(this, null, 4);
+  }
+};
+function collect(items = []) {
+  return new Collection(items);
+}
+
+// ../Support/dist/index.js
+import { randomBytes, randomUUID } from "crypto";
+import pluralize from "pluralize";
+import { setTimeout as sleep } from "timers/promises";
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var TABLE = new Map(
+  Object.entries({
+    "\xC1": "A",
+    "\xE1": "a",
+    "\xC4": "A",
+    "\xE4": "a",
+    "\xC0": "A",
+    "\xE0": "a",
+    "\xC2": "A",
+    "\xE2": "a",
+    "\xC9": "E",
+    "\xE9": "e",
+    "\xCB": "E",
+    "\xEB": "e",
+    "\xC8": "E",
+    "\xE8": "e",
+    "\xCA": "E",
+    "\xEA": "e",
+    "\xCD": "I",
+    "\xED": "i",
+    "\xCF": "I",
+    "\xEF": "i",
+    "\xCC": "I",
+    "\xEC": "i",
+    "\xCE": "I",
+    "\xEE": "i",
+    "\xD3": "O",
+    "\xF3": "o",
+    "\xD6": "O",
+    "\xF6": "o",
+    "\xD2": "O",
+    "\xF2": "o",
+    "\xD4": "O",
+    "\xF4": "o",
+    "\xDA": "U",
+    "\xFA": "u",
+    "\xDC": "U",
+    "\xFC": "u",
+    "\xD9": "U",
+    "\xF9": "u",
+    "\xDB": "U",
+    "\xFB": "u",
+    "\xDD": "Y",
+    "\xFD": "y",
+    "\u0178": "Y",
+    "\u0410": "A",
+    "\u0411": "B",
+    "\u0412": "V",
+    "\u0413": "G",
+    "\u0414": "D",
+    "\u0403": "Gj",
+    "\u0415": "E",
+    "\u0416": "Z",
+    "\u0417": "Z",
+    "\u0405": "Dz",
+    "\u0418": "I",
+    "\u0408": "j",
+    "\u041A": "K",
+    "\u041B": "L",
+    "\u0409": "Lj",
+    "\u041C": "M",
+    "\u041D": "N",
+    "\u040A": "Nj",
+    "\u041E": "O",
+    "\u041F": "P",
+    "\u0420": "R",
+    "\u0421": "S",
+    "\u0422": "T",
+    "\u040C": "Kj",
+    "\u0423": "U",
+    "\u0424": "F",
+    "\u0425": "X",
+    "\u0426": "C",
+    "\u0427": "C",
+    "\u040F": "Dz",
+    "\u0428": "S",
+    "\u0430": "a",
+    "\u0431": "b",
+    "\u0432": "v",
+    "\u0433": "g",
+    "\u0434": "d",
+    "\u0453": "gj",
+    "\u0435": "e",
+    "\u0436": "z",
+    "\u0437": "z",
+    "\u0455": "dz",
+    "\u0438": "i",
+    "\u0458": "j",
+    "\u043A": "k",
+    "\u043B": "l",
+    "\u0459": "lj",
+    "\u043C": "m",
+    "\u043D": "n",
+    "\u045A": "nj",
+    "\u043E": "o",
+    "\u043F": "p",
+    "\u0440": "r",
+    "\u0441": "s",
+    "\u0442": "t",
+    "\u045C": "kj",
+    "\u0443": "u",
+    "\u0444": "f",
+    "\u0445": "x",
+    "\u0446": "c",
+    "\u0447": "c",
+    "\u045F": "dz",
+    "\u0448": "s",
+    "\xE6": "ae",
+    "\u01FD": "ae",
+    "\xC3": "A",
+    "\xC5": "A",
+    "\u01FA": "A",
+    "\u0102": "A",
+    "\u01CD": "A",
+    "\xC6": "AE",
+    "\u01FC": "AE",
+    "\xE3": "a",
+    "\xE5": "a",
+    "\u01FB": "a",
+    "\u0103": "a",
+    "\u01CE": "a",
+    "\xAA": "a",
+    "\u0108": "C",
+    "\u010A": "C",
+    "\xC7": "C",
+    "\xE7": "c",
+    "\u0109": "c",
+    "\u010B": "c",
+    "\xD0": "D",
+    "\u0110": "D",
+    "\xF0": "d",
+    "\u0111": "d",
+    "\u0114": "E",
+    "\u0116": "E",
+    "\u0115": "e",
+    "\u0117": "e",
+    "\u0192": "f",
+    "\u011C": "G",
+    "\u0120": "G",
+    "\u011D": "g",
+    "\u0121": "g",
+    "\u0124": "H",
+    "\u0126": "H",
+    "\u0125": "h",
+    "\u0127": "h",
+    "\u0128": "I",
+    "\u012C": "I",
+    "\u01CF": "I",
+    "\u012E": "I",
+    "\u0132": "IJ",
+    "\u0129": "i",
+    "\u012D": "i",
+    "\u01D0": "i",
+    "\u012F": "i",
+    "\u0133": "ij",
+    "\u0134": "J",
+    "\u0135": "j",
+    "\u0139": "L",
+    "\u013D": "L",
+    "\u013F": "L",
+    "\u013A": "l",
+    "\u013E": "l",
+    "\u0140": "l",
+    "\xD1": "N",
+    "\xF1": "n",
+    "\u0149": "n",
+    "\xD5": "O",
+    "\u014C": "O",
+    "\u014E": "O",
+    "\u01D1": "O",
+    "\u0150": "O",
+    "\u01A0": "O",
+    "\xD8": "O",
+    "\u01FE": "O",
+    "\u0152": "OE",
+    "\xF5": "o",
+    "\u014D": "o",
+    "\u014F": "o",
+    "\u01D2": "o",
+    "\u0151": "o",
+    "\u01A1": "o",
+    "\xF8": "o",
+    "\u01FF": "o",
+    "\xBA": "o",
+    "\u0153": "oe",
+    "\u0154": "R",
+    "\u0156": "R",
+    "\u0155": "r",
+    "\u0157": "r",
+    "\u015C": "S",
+    "\u0218": "S",
+    "\u015D": "s",
+    "\u0219": "s",
+    "\u017F": "s",
+    "\u0162": "T",
+    "\u021A": "T",
+    "\u0166": "T",
+    "\xDE": "TH",
+    "\u0163": "t",
+    "\u021B": "t",
+    "\u0167": "t",
+    "\xFE": "th",
+    "\u0168": "U",
+    "\u016C": "U",
+    "\u0170": "U",
+    "\u0172": "U",
+    "\u01AF": "U",
+    "\u01D3": "U",
+    "\u01D5": "U",
+    "\u01D7": "U",
+    "\u01D9": "U",
+    "\u01DB": "U",
+    "\u0169": "u",
+    "\u016D": "u",
+    "\u0171": "u",
+    "\u0173": "u",
+    "\u01B0": "u",
+    "\u01D4": "u",
+    "\u01D6": "u",
+    "\u01D8": "u",
+    "\u01DA": "u",
+    "\u01DC": "u",
+    "\u0174": "W",
+    "\u0175": "w",
+    "\u0176": "Y",
+    "\xFF": "y",
+    "\u0177": "y",
+    "\u0391\u03A5": "AU",
+    "\u0391\u038E": "AU",
+    "\u0391\u03C5": "Au",
+    "\u0391\u03CD": "Au",
+    "\u0395\u038A": "I",
+    "\u0395\u0399": "I",
+    "\u0395\u03B9": "Ei",
+    "\u0395\u03A5": "EF",
+    "\u0395\u038E": "EU",
+    "\u0395\u03AF": "I",
+    "\u0395\u03C5": "Ef",
+    "\u0395\u03CD": "Eu",
+    "\u039F\u0399": "I",
+    "\u039F\u038A": "I",
+    "\u039F\u03A5": "U",
+    "\u039F\u038E": "OU",
+    "\u039F\u03B9": "Oi",
+    "\u039F\u03AF": "I",
+    "\u039F\u03C5": "Oy",
+    "\u039F\u03CD": "Ou",
+    "\u03A5\u0399": "I",
+    "\u038E\u0399": "I",
+    "\u03A5\u03B9": "Yi",
+    "\u038E\u03B9": "I",
+    "\u03A5\u038A": "I",
+    "\u03A5\u03AF": "I",
+    "\u03B1\u03C5": "au",
+    "\u03B1\u03CD": "au",
+    "\u03B5\u03AF": "i",
+    "\u03B5\u03B9": "ei",
+    "\u03B5\u03C5": "ef",
+    "\u03B5\u03CD": "eu",
+    "\u03BF\u03B9": "oi",
+    "\u03BF\u03AF": "i",
+    "\u03BF\u03C5": "oy",
+    "\u03BF\u03CD": "ou",
+    "\u03C5\u03B9": "yi",
+    "\u03CD\u03B9": "i",
+    "\u03C5\u03AF": "i",
+    "\u0391": "A",
+    "\u0386": "A",
+    "\u0392": "B",
+    "\u0394": "D",
+    "\u0395": "E",
+    "\u0388": "E",
+    "\u03A6": "F",
+    "\u0393": "G",
+    "\u0397": "H",
+    "\u0389": "I",
+    "\u0399": "I",
+    "\u038A": "I",
+    "\u03AA": "I",
+    "\u039A": "K",
+    "\u039E": "Ks",
+    "\u039B": "L",
+    "\u039C": "M",
+    "\u039D": "N",
+    "\u03A0": "P",
+    "\u039F": "O",
+    "\u038C": "O",
+    "\u03A8": "Ps",
+    "\u03A1": "R",
+    "\u03A3": "S",
+    "\u03A4": "T",
+    "\u0398": "Th",
+    "\u03A9": "O",
+    "\u038F": "W",
+    "\u03A7": "X",
+    "\u03D2": "Y",
+    "\u03A5": "Y",
+    "\u038E": "Y",
+    "\u03AB": "Y",
+    "\u0396": "Z",
+    "\u03B1": "a",
+    "\u03AC": "a",
+    "\u03B2": "v",
+    "\u03B4": "d",
+    "\u03B5": "e",
+    "\u03AD": "e",
+    "\u03C6": "f",
+    "\u03B3": "gh",
+    "\u03B7": "i",
+    "\u03AE": "i",
+    "\u03B9": "i",
+    "\u03AF": "i",
+    "\u03CA": "i",
+    "\u0390": "i",
+    "\u03BA": "k",
+    "\u03BE": "ks",
+    "\u03BB": "l",
+    "\u03BC": "m",
+    "\u03BD": "n",
+    "\u03BF": "o",
+    "\u03CC": "o",
+    "\u03C0": "p",
+    "\u03C8": "ps",
+    "\u03C1": "r",
+    "\u03C3": "s",
+    "\u03C2": "s",
+    "\u03C4": "t",
+    "\u03D1": "th",
+    "\u03B8": "th",
+    "\u03D0": "v",
+    "\u03C9": "o",
+    "\u03CE": "w",
+    "\u03C7": "kh",
+    "\u03C5": "i",
+    "\u03CD": "y",
+    "\u03B0": "y",
+    "\u03CB": "y",
+    "\u03B6": "z",
+    "\u0905": "a",
+    "\u0906": "aa",
+    "\u090F": "e",
+    "\u0908": "ii",
+    "\u090D": "ei",
+    "\u090E": "ae",
+    "\u0910": "ai",
+    "\u0907": "i",
+    "\u0913": "o",
+    "\u0911": "oi",
+    "\u0912": "oii",
+    "\u090A": "uu",
+    "\u0914": "ou",
+    "\u0909": "u",
+    "\u092C": "B",
+    "\u092D": "Bha",
+    "\u091A": "Ca",
+    "\u091B": "Chha",
+    "\u0921": "Da",
+    "\u0922": "Dha",
+    "\u092B": "Fa",
+    "\u092B\u093C": "Fi",
+    "\u0917": "Ga",
+    "\u0918": "Gha",
+    "\u0917\u093C": "Ghi",
+    "\u0939": "Ha",
+    "\u091C": "Ja",
+    "\u091D": "Jha",
+    "\u0915": "Ka",
+    "\u0916": "Kha",
+    "\u0916\u093C": "Khi",
+    "\u0932": "L",
+    "\u0933": "Li",
+    "\u090C": "Li",
+    "\u0934": "Lii",
+    "\u0961": "Lii",
+    "\u092E": "Ma",
+    "\u0928": "Na",
+    "\u0919": "Na",
+    "\u091E": "Nia",
+    "\u0923": "Nae",
+    "\u0929": "Ni",
+    "\u0950": "oms",
+    "\u092A": "Pa",
+    "\u0915\u093C": "Qi",
+    "\u0930": "Ra",
+    "\u090B": "Ri",
+    "\u0960": "Ri",
+    "\u0931": "Ri",
+    "\u0938": "Sa",
+    "\u0936": "Sha",
+    "\u0937": "Shha",
+    "\u091F": "Ta",
+    "\u0924": "Ta",
+    "\u0920": "Tha",
+    "\u0926": "Tha",
+    "\u0925": "Tha",
+    "\u0927": "Thha",
+    "\u0921\u093C": "ugDha",
+    "\u0922\u093C": "ugDhha",
+    "\u0935": "Va",
+    "\u092F": "Ya",
+    "\u092F\u093C": "Yi",
+    "\u091C\u093C": "Za",
+    "\u0531": "A",
+    "\u0532": "B",
+    "\u0533": "G",
+    "\u0534": "D",
+    "\u0535": "E",
+    "\u0536": "Z",
+    "\u0537": "E",
+    "\u0538": "Y",
+    "\u0539": "Th",
+    "\u053A": "Zh",
+    "\u053B": "I",
+    "\u053C": "L",
+    "\u053D": "Kh",
+    "\u053E": "Ts",
+    "\u053F": "K",
+    "\u0540": "H",
+    "\u0541": "Dz",
+    "\u0542": "Gh",
+    "\u0543": "Tch",
+    "\u0544": "M",
+    "\u0545": "Y",
+    "\u0546": "N",
+    "\u0547": "Sh",
+    "\u0548": "Vo",
+    "\u0549": "Ch",
+    "\u054A": "P",
+    "\u054B": "J",
+    "\u054C": "R",
+    "\u054D": "S",
+    "\u054E": "V",
+    "\u054F": "T",
+    "\u0550": "R",
+    "\u0551": "C",
+    "\u0552": "u",
+    "\u0553": "Ph",
+    "\u0554": "Q",
+    "\u0587": "ev",
+    "\u0555": "O",
+    "\u0556": "F",
+    "\u0561": "a",
+    "\u0562": "b",
+    "\u0563": "g",
+    "\u0564": "d",
+    "\u0565": "e",
+    "\u0566": "z",
+    "\u0567": "e",
+    "\u0568": "y",
+    "\u0569": "th",
+    "\u056A": "zh",
+    "\u056B": "i",
+    "\u056C": "l",
+    "\u056D": "kh",
+    "\u056E": "ts",
+    "\u056F": "k",
+    "\u0570": "h",
+    "\u0571": "dz",
+    "\u0572": "gh",
+    "\u0573": "tch",
+    "\u0574": "m",
+    "\u0575": "y",
+    "\u0576": "n",
+    "\u0577": "sh",
+    "\u0578": "vo",
+    "\u0579": "ch",
+    "\u057A": "p",
+    "\u057B": "j",
+    "\u057C": "r",
+    "\u057D": "s",
+    "\u057E": "v",
+    "\u057F": "t",
+    "\u0580": "r",
+    "\u0581": "c",
+    "\u0582": "u",
+    "\u0583": "ph",
+    "\u0584": "q",
+    "\u0585": "o",
+    "\u0586": "f",
+    "\u017D": "Z",
+    "\u0147": "N",
+    "\u015E": "S",
+    "\u017E": "z",
+    "\u0148": "n",
+    "\u015F": "s",
+    "\u0131": "i",
+    "\u0130": "I",
+    "\u011F": "g",
+    "\u011E": "G",
+    "\u044C\u043E": "yo",
+    "\u0419": "i",
+    "\u0429": "Shh",
+    "\u042A": "Ie",
+    "\u042C": "",
+    "\u042E": "Iu",
+    "\u042F": "Ia",
+    "\u0439": "i",
+    "\u0449": "shh",
+    "\u044A": "ie",
+    "\u044C": "",
+    "\u044E": "iu",
+    "\u044F": "ia",
+    "\u0112": "E",
+    "\u0113": "e",
+    "\u102D\u1010\u103A": "eik",
+    "\u102F\u1010\u103A": "ok",
+    "\u102F\u1014\u103A": "on",
+    "\u1031\u1010\u103A": "it",
+    "\u102F\u1012\u103A": "ait",
+    "\u102C\u1014\u103A": "an",
+    "\u102D\u1014\u103A": "ein",
+    "\u103D\u1010\u103A": "ut",
+    "\u1031\u102B\u103A": "aw",
+    "\u103D\u1014\u103A": "un",
+    "\u102D\u1015\u103A": "eik",
+    "\u102F\u1015\u103A": "ok",
+    "\u103D\u1015\u103A": "ut",
+    "\u102D\u1019\u103A": "ein",
+    "\u102F\u1019\u103A": "on",
+    "\u1031\u102C\u103A": "aw",
+    "\u103D\u1019\u103A": "un",
+    "\u1000\u103A": "et",
+    "\u1031\u102B": "aw",
+    "\u1031\u102C": "aw",
+    "\u103B\u103D": "ywa",
+    "\u103C\u103D": "yw",
+    "\u102D\u102F": "o",
+    "\u102F\u1036": "on",
+    "\u1010\u103A": "at",
+    "\u1004\u103A": "in",
+    "\u100A\u103A": "i",
+    "\u1012\u103A": "d",
+    "\u1014\u103A": "an",
+    "\u1015\u103A": "at",
+    "\u1019\u103A": "an",
+    "\u1005\u103B": "za",
+    "\u101A\u103A": "e",
+    "\u1009\u103A": "in",
+    "\u1005\u103A": "it",
+    "\u102D\u1036": "ein",
+    "\u1032": "e",
+    "\u1038": "",
+    "\u102C": "a",
+    "\u102B": "a",
+    "\u1031": "e",
+    "\u1036": "an",
+    "\u102D": "i",
+    "\u102E": "i",
+    "\u102F": "u",
+    "\u1030": "u",
+    "\u103A": "at",
+    "\u1039": "",
+    "\u1037": "",
+    "\u1000": "k",
+    "\u1049": "9",
+    "\u1010": "t",
+    "\u101B": "ya",
+    "\u101A": "y",
+    "\u1019": "m",
+    "\u1018": "ba",
+    "\u1017": "b",
+    "\u1016": "pa",
+    "\u1015": "p",
+    "\u1014": "n",
+    "\u1013": "da",
+    "\u1012": "d",
+    "\u1011": "ta",
+    "\u100F": "na",
+    "\u101D": "w",
+    "\u100E": "da",
+    "\u100D": "d",
+    "\u100C": "ta",
+    "\u100B": "t",
+    "\u100A": "ny",
+    "\u1007": "z",
+    "\u1006": "sa",
+    "\u1005": "s",
+    "\u1004": "ng",
+    "\u1003": "ga",
+    "\u1002": "g",
+    "\u101C": "l",
+    "\u101E": "th",
+    "\u1048": "8",
+    "\u1029": "aw",
+    "\u1001": "kh",
+    "\u1046": "6",
+    "\u1045": "5",
+    "\u1044": "4",
+    "\u1043": "3",
+    "\u1042": "2",
+    "\u1041": "1",
+    "\u1040": "0",
+    "\u104C": "hnaik",
+    "\u104D": "ywae",
+    "\u102A": "aw",
+    "\u1026": "-u",
+    "\u101F": "h",
+    "\u1009": "u",
+    "\u1024": "-i",
+    "\u1023": "i",
+    "\u104F": "-e",
+    "\u1027": "e",
+    "\u103E": "h",
+    "\u103D": "w",
+    "\u103B": "ya",
+    "\u103C": "y",
+    "\u1021": "a",
+    "\u1020": "la",
+    "\u1047": "7",
+    "D\u017D": "DZ",
+    "D\u017E": "Dz",
+    "d\u017E": "dz",
+    "\u01F1": "DZ",
+    "\u01F2": "Dz",
+    "\u01F3": "dz",
+    "\u01C7": "LJ",
+    "\u01C8": "Lj",
+    "\u01C9": "lj",
+    "\u01CA": "NJ",
+    "\u01CB": "Nj",
+    "\u01CC": "nj",
+    "\u010D": "c",
+    "\u010C": "C",
+    "\u0107": "c",
+    "\u0106": "C",
+    "\u0161": "s",
+    "\u0160": "S",
+    "\u10D0": "a",
+    "\u10D1": "b",
+    "\u10D2": "g",
+    "\u10D3": "d",
+    "\u10D4": "e",
+    "\u10D5": "v",
+    "\u10D6": "z",
+    "\u10D7": "t",
+    "\u10D8": "i",
+    "\u10D9": "k",
+    "\u10DA": "l",
+    "\u10DB": "m",
+    "\u10DC": "n",
+    "\u10DD": "o",
+    "\u10DE": "p",
+    "\u10DF": "zh",
+    "\u10E0": "r",
+    "\u10E1": "s",
+    "\u10E2": "t",
+    "\u10E3": "u",
+    "\u10E4": "f",
+    "\u10E5": "q",
+    "\u10E6": "gh",
+    "\u10E7": "y",
+    "\u10E8": "sh",
+    "\u10E9": "ch",
+    "\u10EA": "ts",
+    "\u10EB": "dz",
+    "\u10EC": "ts",
+    "\u10ED": "ch",
+    "\u10EE": "kh",
+    "\u10EF": "j",
+    "\u10F0": "h",
+    "\u0401": "E",
+    "\u0451": "e",
+    "\u042B": "Y",
+    "\u044B": "y",
+    "\u042D": "E",
+    "\u044D": "e",
+    "\u0406": "I",
+    "\u0456": "i",
+    "\u0472": "F",
+    "\u0473": "f",
+    "\u0462": "E",
+    "\u0463": "e",
+    "\u0474": "I",
+    "\u0475": "i",
+    "\u0404": "Je",
+    "\u0454": "je",
+    "\u0464": "Je",
+    "\u0465": "je",
+    "\uA64A": "U",
+    "\uA64B": "u",
+    "\u0460": "O",
+    "\u0461": "o",
+    "\u047E": "Ot",
+    "\u047F": "ot",
+    "\u046A": "U",
+    "\u046B": "u",
+    "\u0466": "Ja",
+    "\u0467": "ja",
+    "\u046C": "Ju",
+    "\u046D": "ju",
+    "\u0468": "Ja",
+    "\u0469": "Ja",
+    "\u046E": "Ks",
+    "\u046F": "ks",
+    "\u0470": "Ps",
+    "\u0471": "ps",
+    "\u0490": "G",
+    "\u0491": "g",
+    "\u0407": "Yi",
+    "\u0457": "yi",
+    "\u04D8": "A",
+    "\u0492": "G",
+    "\u049A": "Q",
+    "\u04A2": "N",
+    "\u04E8": "O",
+    "\u04B0": "U",
+    "\u04AE": "U",
+    "\u04BA": "H",
+    "\u04D9": "a",
+    "\u0493": "g",
+    "\u049B": "q",
+    "\u04A3": "n",
+    "\u04E9": "o",
+    "\u04B1": "u",
+    "\u04AF": "u",
+    "\u04BB": "h",
+    "\u010F": "d",
+    "\u010E": "D",
+    "\u011B": "e",
+    "\u011A": "E",
+    "\u0159": "r",
+    "\u0158": "R",
+    "\u0165": "t",
+    "\u0164": "T",
+    "\u016F": "u",
+    "\u016E": "U",
+    "\u0105": "a",
+    "\u0119": "e",
+    "\u0142": "l",
+    "\u0144": "n",
+    "\u015B": "s",
+    "\u017A": "z",
+    "\u017C": "z",
+    "\u0104": "A",
+    "\u0118": "E",
+    "\u0141": "L",
+    "\u0143": "N",
+    "\u015A": "S",
+    "\u0179": "Z",
+    "\u017B": "Z",
+    "\u0101": "a",
+    "\u0123": "g",
+    "\u012B": "i",
+    "\u0137": "k",
+    "\u013C": "l",
+    "\u0146": "n",
+    "\u016B": "u",
+    "\u0100": "A",
+    "\u0122": "G",
+    "\u012A": "I",
+    "\u0136": "k",
+    "\u013B": "L",
+    "\u0145": "N",
+    "\u016A": "U",
+    "\u1EA2": "A",
+    "\u1EA0": "A",
+    "\u1EAE": "A",
+    "\u1EB0": "A",
+    "\u1EB2": "A",
+    "\u1EB4": "A",
+    "\u1EB6": "A",
+    "\u1EA4": "A",
+    "\u1EA6": "A",
+    "\u1EA8": "A",
+    "\u1EAA": "A",
+    "\u1EAC": "A",
+    "\u1EA3": "a",
+    "\u1EA1": "a",
+    "\u1EAF": "a",
+    "\u1EB1": "a",
+    "\u1EB3": "a",
+    "\u1EB5": "a",
+    "\u1EB7": "a",
+    "\u1EA5": "a",
+    "\u1EA7": "a",
+    "\u1EA9": "a",
+    "\u1EAB": "a",
+    "\u1EAD": "a",
+    "\u1EBA": "E",
+    "\u1EBC": "E",
+    "\u1EB8": "E",
+    "\u1EBE": "E",
+    "\u1EC0": "E",
+    "\u1EC2": "E",
+    "\u1EC4": "E",
+    "\u1EC6": "E",
+    "\u1EBB": "e",
+    "\u1EBD": "e",
+    "\u1EB9": "e",
+    "\u1EBF": "e",
+    "\u1EC1": "e",
+    "\u1EC3": "e",
+    "\u1EC5": "e",
+    "\u1EC7": "e",
+    "\u1EC8": "I",
+    "\u1ECA": "I",
+    "\u1EC9": "i",
+    "\u1ECB": "i",
+    "\u1ECE": "O",
+    "\u1ECC": "O",
+    "\u1ED0": "O",
+    "\u1ED2": "O",
+    "\u1ED4": "O",
+    "\u1ED6": "O",
+    "\u1ED8": "O",
+    "\u1EDA": "O",
+    "\u1EDC": "O",
+    "\u1EDE": "O",
+    "\u1EE0": "O",
+    "\u1EE2": "O",
+    "\u1ECF": "o",
+    "\u1ECD": "o",
+    "\u1ED1": "o",
+    "\u1ED3": "o",
+    "\u1ED5": "o",
+    "\u1ED7": "o",
+    "\u1ED9": "o",
+    "\u1EDB": "o",
+    "\u1EDD": "o",
+    "\u1EDF": "o",
+    "\u1EE1": "o",
+    "\u1EE3": "o",
+    "\u1EE6": "U",
+    "\u1EE4": "U",
+    "\u1EE8": "U",
+    "\u1EEA": "U",
+    "\u1EEC": "U",
+    "\u1EEE": "U",
+    "\u1EF0": "U",
+    "\u1EE7": "u",
+    "\u1EE5": "u",
+    "\u1EE9": "u",
+    "\u1EEB": "u",
+    "\u1EED": "u",
+    "\u1EEF": "u",
+    "\u1EF1": "u",
+    "\u1EF2": "Y",
+    "\u1EF6": "Y",
+    "\u1EF8": "Y",
+    "\u1EF4": "Y",
+    "\u1EF3": "y",
+    "\u1EF7": "y",
+    "\u1EF9": "y",
+    "\u1EF5": "y",
+    "\u0627": "a",
+    "\u0628": "b",
+    "\u067E": "p",
+    "\u062A": "t",
+    "\u062B": "th",
+    "\u062C": "g",
+    "\u0686": "ch",
+    "\u062D": "h",
+    "\u062E": "kh",
+    "\u062F": "d",
+    "\u0630": "th",
+    "\u0631": "r",
+    "\u0632": "z",
+    "\u0633": "s",
+    "\u0634": "sh",
+    "\u0635": "s",
+    "\u0636": "d",
+    "\u0637": "t",
+    "\u0638": "th",
+    "\u0639": "aa",
+    "\u063A": "gh",
+    "\u0641": "f",
+    "\u0642": "k",
+    "\u06A9": "k",
+    "\u06AF": "g",
+    "\u0644": "l",
+    "\u0698": "zh",
+    "\u0643": "k",
+    "\u0645": "m",
+    "\u0646": "n",
+    "\u0647": "h",
+    "\u0648": "o",
+    "\u06CC": "y",
+    "\u0622": "a",
+    "\u0660": "0",
+    "\u0661": "1",
+    "\u0662": "2",
+    "\u0663": "3",
+    "\u0664": "4",
+    "\u0665": "5",
+    "\u0666": "6",
+    "\u0667": "7",
+    "\u0668": "8",
+    "\u0669": "9",
+    "\u0623": "a",
+    "\u064A": "y",
+    "\u0625": "a",
+    "\u0624": "o",
+    "\u0626": "y",
+    "\u0621": "aa",
+    "\u0452": "dj",
+    "\u045B": "c",
+    "\u0402": "Dj",
+    "\u040B": "C",
+    "\u0259": "e",
+    "\u018F": "E",
+    "\xDF": "ss",
+    "\u1E9E": "SS",
+    "\u09AD\u09CD\u09B2": "vl",
+    "\u09AA\u09B6": "psh",
+    "\u09AC\u09CD\u09A7": "bdh",
+    "\u09AC\u09CD\u099C": "bj",
+    "\u09AC\u09CD\u09A6": "bd",
+    "\u09AC\u09CD\u09AC": "bb",
+    "\u09AC\u09CD\u09B2": "bl",
+    "\u09AD": "v",
+    "\u09AC": "b",
+    "\u099A\u09CD\u099E": "cNG",
+    "\u099A\u09CD\u099B": "cch",
+    "\u099A\u09CD\u099A": "cc",
+    "\u099B": "ch",
+    "\u099A": "c",
+    "\u09A7\u09CD\u09A8": "dhn",
+    "\u09A7\u09CD\u09AE": "dhm",
+    "\u09A6\u09CD\u0998": "dgh",
+    "\u09A6\u09CD\u09A7": "ddh",
+    "\u09A6\u09CD\u09AD": "dv",
+    "\u09A6\u09CD\u09AE": "dm",
+    "\u09A1\u09CD\u09A1": "DD",
+    "\u09A2": "Dh",
+    "\u09A7": "dh",
+    "\u09A6\u09CD\u0997": "dg",
+    "\u09A6\u09CD\u09A6": "dd",
+    "\u09A1": "D",
+    "\u09A6": "d",
+    "\u0964": ".",
+    "\u0998\u09CD\u09A8": "Ghn",
+    "\u0997\u09CD\u09A7": "Gdh",
+    "\u0997\u09CD\u09A3": "GN",
+    "\u0997\u09CD\u09A8": "Gn",
+    "\u0997\u09CD\u09AE": "Gm",
+    "\u0997\u09CD\u09B2": "Gl",
+    "\u099C\u09CD\u099E": "jNG",
+    "\u0998": "Gh",
+    "\u0997": "g",
+    "\u09B9\u09CD\u09A3": "hN",
+    "\u09B9\u09CD\u09A8": "hn",
+    "\u09B9\u09CD\u09AE": "hm",
+    "\u09B9\u09CD\u09B2": "hl",
+    "\u09B9": "h",
+    "\u099C\u09CD\u099D": "jjh",
+    "\u099D": "jh",
+    "\u099C\u09CD\u099C": "jj",
+    "\u099C": "j",
+    "\u0995\u09CD\u09B7": "ksh",
+    "\u0995\u09B6": "ksh",
+    "\u0995\u09CD\u0995": "kk",
+    "\u0995\u09CD\u099F": "kT",
+    "\u0995\u09CD\u09A4": "kt",
+    "\u0995\u09CD\u09B2": "kl",
+    "\u0995\u09CD\u09B8": "ks",
+    "\u0996": "kh",
+    "\u0995": "k",
+    "\u09B2\u09CD\u09AD": "lv",
+    "\u09B2\u09CD\u09A7": "ldh",
+    "\u09B2\u0996": "lkh",
+    "\u09B2\u0998": "lgh",
+    "\u09B2\u09AB": "lph",
+    "\u09B2\u09CD\u0995": "lk",
+    "\u09B2\u09CD\u0997": "lg",
+    "\u09B2\u09CD\u099F": "lT",
+    "\u09B2\u09CD\u09A1": "lD",
+    "\u09B2\u09CD\u09AA": "lp",
+    "\u09B2\u09CD\u09AE": "lm",
+    "\u09B2\u09CD\u09B2": "ll",
+    "\u09B2\u09CD\u09AC": "lb",
+    "\u09B2": "l",
+    "\u09AE\u09CD\u09A5": "mth",
+    "\u09AE\u09CD\u09AB": "mf",
+    "\u09AE\u09CD\u09AD": "mv",
+    "\u09AE\u09CD\u09A8": "mn",
+    "\u09AE\u09CD\u09AA": "mp",
+    "\u09AE\u09CD\u09AE": "mm",
+    "\u09AE\u09CD\u09B2": "ml",
+    "\u09AE\u09CD\u09AC": "mb",
+    "\u09AE": "m",
+    "\u09E6": "0",
+    "\u09E7": "1",
+    "\u09E8": "2",
+    "\u09E9": "3",
+    "\u09EA": "4",
+    "\u09EB": "5",
+    "\u09EC": "6",
+    "\u09ED": "7",
+    "\u09EE": "8",
+    "\u09EF": "9",
+    "\u099E\u09CD\u099B": "nch",
+    "\u0999\u09CD\u0998": "ngh",
+    "\u0999\u09CD\u0996": "nkh",
+    "\u099E\u09CD\u099D": "njh",
+    "\u099E\u09CD\u099A": "nc",
+    "\u0999\u09CD\u0995": "nk",
+    "\u0999\u09CD\u09B7": "Ngx",
+    "\u0999\u09CD\u0997": "ngo",
+    "\u0999\u09CD\u09AE": "Ngm",
+    "\u099E\u09CD\u099C": "nj",
+    "\u09A8\u09CD\u09A7": "ndh",
+    "\u09A8\u09CD\u09A0": "nTh",
+    "\u09A3\u09CD\u09A0": "NTh",
+    "\u09A8\u09CD\u09A5": "nth",
+    "\u09A3\u09CD\u09A2": "NDh",
+    "\u09A8\u09B6": "nsh",
+    "\u0999\u09B0": "Ngr",
+    "\u099E\u09B0": "NGr",
+    "\u0982\u09B0": "ngr",
+    "\u0999": "Ng",
+    "\u099E": "NG",
+    "\u0982": "ng",
+    "\u09A8\u09CD\u09A8": "nn",
+    "\u09A3\u09CD\u09A3": "NN",
+    "\u09A3\u09CD\u09A8": "Nn",
+    "\u09A8\u09CD\u09AE": "nm",
+    "\u09A3\u09CD\u09AE": "Nm",
+    "\u09A8\u09CD\u09A6": "nd",
+    "\u09A8\u09CD\u099F": "nT",
+    "\u09A3\u09CD\u099F": "NT",
+    "\u09A8\u09CD\u09A1": "nD",
+    "\u09A3\u09CD\u09A1": "ND",
+    "\u09A8\u09CD\u09A4": "nt",
+    "\u09A8\u09CD\u09B8": "ns",
+    "\u09A8": "n",
+    "\u09A3": "N",
+    "\u09C8": "OI",
+    "\u09CC": "OU",
+    "\u09CB": "O",
+    "\u0990": "OI",
+    "\u0994": "OU",
+    "\u0985": "o",
+    "\u0993": "oo",
+    "\u09AB\u09CD\u09B2": "fl",
+    "\u09AA\u09CD\u099F": "pT",
+    "\u09AA\u09CD\u09A4": "pt",
+    "\u09AA\u09CD\u09A8": "pn",
+    "\u09AA\u09CD\u09AA": "pp",
+    "\u09AA\u09CD\u09B2": "pl",
+    "\u09AA\u09CD\u09B8": "ps",
+    "\u09AB": "f",
+    "\u09AA": "p",
+    "\u09C3": "rri",
+    "\u098B": "rri",
+    "\u09CD\u09B0\u09B0": "rr",
+    "\u09DC\u09CD\u0997": "Rg",
+    "\u09DD": "Rh",
+    "\u09DC": "R",
+    "\u09B0": "r",
+    "\u09CD\u09B0": "r",
+    "\u09B6\u09CD\u099B": "Sch",
+    "\u09B7\u09CD\u09A0": "ShTh",
+    "\u09B7\u09CD\u09AB": "Shf",
+    "\u09B8\u09CD\u0996": "skh",
+    "\u09B8\u09CD\u09A5": "sth",
+    "\u09B8\u09CD\u09AB": "sf",
+    "\u09B6\u09CD\u099A": "Sc",
+    "\u09B6\u09CD\u09A4": "St",
+    "\u09B6\u09CD\u09A8": "Sn",
+    "\u09B6\u09CD\u09AE": "Sm",
+    "\u09B6\u09CD\u09B2": "Sl",
+    "\u09B7\u09CD\u0995": "Shk",
+    "\u09B7\u09CD\u099F": "ShT",
+    "\u09B7\u09CD\u09A3": "ShN",
+    "\u09B7\u09CD\u09AA": "Shp",
+    "\u09B7\u09CD\u09AE": "Shm",
+    "\u09B8\u09CD\u0995": "sk",
+    "\u09B8\u09CD\u099F": "sT",
+    "\u09B8\u09CD\u09A4": "st",
+    "\u09B8\u09CD\u09A8": "sn",
+    "\u09B8\u09CD\u09AA": "sp",
+    "\u09B8\u09CD\u09AE": "sm",
+    "\u09B8\u09CD\u09B2": "sl",
+    "\u09B6": "S",
+    "\u09B7": "Sh",
+    "\u09B8": "s",
+    "\u09C1": "u",
+    "\u0989": "u",
+    "\u0985\u09CD\u09AF": "oZ",
+    "\u09A4\u09CD\u09A5": "tth",
+    "\u09CE": "tt",
+    "\u099F\u09CD\u099F": "TT",
+    "\u099F\u09CD\u09AE": "Tm",
+    "\u09A0": "Th",
+    "\u09A4\u09CD\u09A8": "tn",
+    "\u09A4\u09CD\u09AE": "tm",
+    "\u09A5": "th",
+    "\u09A4\u09CD\u09A4": "tt",
+    "\u099F": "T",
+    "\u09A4": "t",
+    "\u09BE": "a",
+    "\u0986": "a",
+    "\u09DF\u09BE": "ya",
+    "\u09DF": "y",
+    "\u09BF": "i",
+    "\u0987": "i",
+    "\u09C0": "ee",
+    "\u0988": "ee",
+    "\u09C2": "uu",
+    "\u098A": "uu",
+    "\u09C7": "e",
+    "\u098F": "e",
+    "\u09AF": "z",
+    "\u09CD\u09AF": "Z",
+    "\u0987\u09DF": "y",
+    "\u0993\u09DF": "w",
+    "\u09CD\u09AC": "w",
+    "\u0983": ":",
+    "\u0981": "nn",
+    "\u09CD\u200C": "",
+    "\u02DA": "0",
+    "\xB9": "1",
+    "\xB2": "2",
+    "\xB3": "3",
+    "\u2074": "4",
+    "\u2075": "5",
+    "\u2076": "6",
+    "\u2077": "7",
+    "\u2078": "8",
+    "\u2079": "9",
+    "\u2080": "0",
+    "\u2081": "1",
+    "\u2082": "2",
+    "\u2083": "3",
+    "\u2084": "4",
+    "\u2085": "5",
+    "\u2086": "6",
+    "\u2087": "7",
+    "\u2088": "8",
+    "\u2089": "9",
+    "\u0BE6": "0",
+    "\u0BE7": "1",
+    "\u0BE8": "2",
+    "\u0BE9": "3",
+    "\u0BEA": "4",
+    "\u0BEB": "5",
+    "\u0BEC": "6",
+    "\u0BED": "7",
+    "\u0BEE": "8",
+    "\u0BEF": "9",
+    "\u0BF0": "10",
+    "\u0BF1": "100",
+    "\u0BF2": "1000",
+    "\uA732": "AA",
+    "\uA733": "aa",
+    "\uA734": "AO",
+    "\uA735": "ao",
+    "\uA736": "AU",
+    "\uA737": "au",
+    "\uA738": "AV",
+    "\uA739": "av",
+    "\uA73A": "av",
+    "\uA73B": "av",
+    "\uA73C": "AY",
+    "\uA73D": "ay",
+    "\u0238": "db",
+    "\u02A3": "dz",
+    "\u02A5": "dz",
+    "\u02A4": "dezh",
+    "\u{1F670}": "et",
+    "\uFB00": "ff",
+    "\uFB03": "ffi",
+    "\uFB04": "ffl",
+    "\uFB01": "fi",
+    "\uFB02": "fl",
+    "\u02A9": "feng",
+    "\u02AA": "ls",
+    "\u02AB": "lz",
+    "\u026E": "lezh",
+    "\u0239": "qp",
+    "\u02A8": "tc",
+    "\u02A6": "ts",
+    "\u02A7": "tesh",
+    "\uA74E": "OO",
+    "\uA74F": "oo",
+    "\uFB06": "st",
+    "\uFB05": "st",
+    "\uA728": "TZ",
+    "\uA729": "tz",
+    "\u1D6B": "ue",
+    "A\u03B9": "Ai",
+    "\u03B1\u03B9": "ai",
+    "\u1F00": "a",
+    "\u1F01": "a",
+    "\u1F02": "a",
+    "\u1F03": "a",
+    "\u1F04": "a",
+    "\u1F05": "a",
+    "\u1F06": "a",
+    "\u1F07": "a",
+    "\u1F08": "A",
+    "\u1F09": "A",
+    "\u1F0A": "A",
+    "\u1F0B": "A",
+    "\u1F0C": "A",
+    "\u1F0D": "A",
+    "\u1F0E": "A",
+    "\u1F0F": "A",
+    "\u1FB0": "a",
+    "\u1FB1": "a",
+    "\u1FB2": "a",
+    "\u1FB3": "a",
+    "\u1FB4": "a",
+    "\u1FB6": "a",
+    "\u1FB7": "a",
+    "\u1FB8": "A",
+    "\u1FB9": "A",
+    "\u1FBA": "A",
+    "\u1FBB": "A",
+    "\u1FBC": "A",
+    "A\u0327": "A",
+    "a\u0327": "a",
+    "\u023A": "A",
+    "\u2C65": "a",
+    "\u0226": "A",
+    "\u0227": "a",
+    "\u0181": "B",
+    "C\u0308": "C",
+    "c\u0308": "c",
+    "C\u0328": "C",
+    "c\u0328": "c",
+    "\u023B": "C",
+    "\u023C": "c",
+    "C\u0300": "C",
+    "c\u0300": "c",
+    "C\u0323": "C",
+    "c\u0323": "c",
+    "C\u0304": "C",
+    "c\u0304": "c",
+    "C\u0303": "C",
+    "c\u0303": "c",
+    "\u0228": "E",
+    "\u0229": "e",
+    "\u0246": "E",
+    "\u0247": "e",
+    "I\u0327": "I",
+    "i\u0327": "i",
+    "\u0197": "I",
+    "\u0268": "i",
+    "i": "i",
+    "J\u0301\u0301": "J",
+    "j\u0301": "j",
+    "J\u0300\u0300": "J",
+    "j\u0300": "j",
+    "J\u0308": "J",
+    "j\u0308": "j",
+    "J\u0327": "J",
+    "j\u0327": "j",
+    "J\u0328": "J",
+    "j\u0328": "j",
+    "\u0248": "J",
+    "\u0249": "j",
+    "J\u030C": "J",
+    "\u01F0": "j",
+    "J\u0307": "J",
+    "j": "j",
+    "J\u0323": "J",
+    "j\u0323": "j",
+    "J\u0304": "J",
+    "j\u0304": "j",
+    "J\u0303": "J",
+    "j\u0303": "j",
+    "\u0138": "k",
+    "L\u0300": "L",
+    "l\u0300": "l",
+    "L\u0302": "L",
+    "l\u0302": "l",
+    "L\u0308": "L",
+    "l\u0308": "l",
+    "L\u0328": "L",
+    "l\u0328": "l",
+    "\u023D": "L",
+    "\u019A": "l",
+    "L\u0307": "L",
+    "l\u0307": "l",
+    "\u1E36": "L",
+    "\u1E37": "l",
+    "L\u0304": "L",
+    "l\u0304": "l",
+    "L\u0303": "L",
+    "l\u0303": "l",
+    "\u014A": "N",
+    "\u014B": "n",
+    "\u01F8": "N",
+    "\u01F9": "n",
+    "N\u0302": "N",
+    "n\u0302": "n",
+    "N\u0308": "N",
+    "n\u0308": "n",
+    "N\u0328": "N",
+    "n\u0328": "n",
+    "\uA7A4": "N",
+    "\uA7A5": "n",
+    "\u1E44": "N",
+    "\u1E45": "n",
+    "\u1E46": "N",
+    "\u1E47": "n",
+    "N\u0304": "N",
+    "n\u0304": "n",
+    "O\u0327": "O",
+    "o\u0327": "o",
+    "\u01EA": "O",
+    "\u01EB": "o",
+    "\u019F": "O",
+    "\u0275": "o",
+    "\u022E": "O",
+    "\u022F": "o",
+    "S\u0300": "S",
+    "s\u0300": "s",
+    "\u015C\u0300": "S",
+    "S\u0308": "S",
+    "s\u0308": "s",
+    "S\u0328": "S",
+    "s\u0328": "s",
+    "\uA7A8": "S",
+    "\uA7A9": "s",
+    "\u1E60": "S",
+    "\u1E61": "s",
+    "\u1E62": "S",
+    "\u1E63": "s",
+    "S\u0304": "S",
+    "s\u0304": "s",
+    "S\u0303": "S",
+    "s\u0303": "s",
+    "T\u0301": "T",
+    "t\u0301": "t",
+    "T\u0300": "T",
+    "t\u0300": "t",
+    "T\u0302": "T",
+    "t\u0302": "t",
+    "T\u0308": "T",
+    "\u1E97": "t",
+    "T\u0328": "T",
+    "t\u0328": "t",
+    "\u023E": "T",
+    "\u2C66": "t",
+    "\u1E6A": "T",
+    "\u1E6B": "t",
+    "\u1E6C": "T",
+    "\u1E6D": "t",
+    "T\u0304": "T",
+    "t\u0304": "t",
+    "T\u0303": "T",
+    "t\u0303": "t",
+    "U\u0327": "U",
+    "u\u0327": "u",
+    "\u0244": "U",
+    "\u0289": "u",
+    "U\u0307": "U",
+    "u\u0307": "u",
+    "\u01B1": "U",
+    "\u028A": "u",
+    "\u1E80": "W",
+    "\u1E81": "w",
+    "\u1E82": "W",
+    "\u1E83": "w",
+    "\u1E84": "W",
+    "\u1E85": "w",
+    "\uA656": "Ja",
+    "\uA657": "ja",
+    "Y\u0327": "Y",
+    "y\u0327": "y",
+    "Y\u0328": "Y",
+    "y\u0328": "y",
+    "\u024E": "Y",
+    "\u024F": "y",
+    "Y\u030C": "Y",
+    "y\u030C": "y",
+    "\u1E8E": "Y",
+    "\u1E8F": "y",
+    "\u0232": "Y",
+    "\u0233": "y",
+    "Z\u0300": "Z",
+    "z\u0300": "z",
+    "\u1E90": "Z",
+    "\u1E91": "z",
+    "Z\u0308": "Z",
+    "z\u0308": "z",
+    "Z\u0327": "Z",
+    "z\u0327": "z",
+    "Z\u0328": "Z",
+    "z\u0328": "z",
+    "\u01B5": "Z",
+    "\u01B6": "z",
+    "\u1E92": "Z",
+    "\u1E93": "z",
+    "Z\u0304": "Z",
+    "z\u0304": "z",
+    "Z\u0303": "Z",
+    "z\u0303": "z",
+    "\xA0": " ",
+    "\u1680": " ",
+    "\u2000": " ",
+    "\u2001": " ",
+    "\u2002": " ",
+    "\u2003": " ",
+    "\u2004": " ",
+    "\u2005": " ",
+    "\u2006": " ",
+    "\u2007": " ",
+    "\u2008": " ",
+    "\u2009": " ",
+    "\u200A": " ",
+    "\u2028": " ",
+    "\u2029": " ",
+    "\u200B": " ",
+    "\u202F": " ",
+    "\u205F": " ",
+    "\u3000": " ",
+    "\uFFA0": " ",
+    "\xAB": "<<",
+    "\xBB": ">>",
+    "\u2018": "'",
+    "\u2019": "'",
+    "\u201A": "'",
+    "\u201B": "'",
+    "\u201C": '"',
+    "\u201D": '"',
+    "\u201E": '"',
+    "\u201F": '"',
+    "\u2039": "'",
+    "\u203A": "'",
+    "\u2013": "-",
+    "\u2014": "-",
+    "\u2026": "...",
+    "\u20AC": "EUR",
+    "$": "$",
+    "\u20A2": "Cr",
+    "\u20A3": "Fr.",
+    "\xA3": "PS",
+    "\u20A4": "L.",
+    "\u2133": "M",
+    "\u20A5": "mil",
+    "\u20A6": "N",
+    "\u20A7": "Pts",
+    "\u20A8": "Rs",
+    "\u0DBB\u0DD4": "LKR",
+    "\u0BB0\u0BC2": "LKR",
+    "\u0BF9": "Rs",
+    "\u0930\u0942": "NPR",
+    "\u20B9": "Rs",
+    "\u0AF1": "Rs",
+    "\u20A9": "W",
+    "\u20AA": "NS",
+    "\u20B8": "KZT",
+    "\u20AB": "D",
+    "\u058F": "AMD",
+    "\u20AD": "K",
+    "\u20BA": "TL",
+    "\u20BC": "AZN",
+    "\u20AE": "T",
+    "\u20AF": "Dr",
+    "\u20B2": "PYG",
+    "\u20BE": "GEL",
+    "\u20B3": "ARA",
+    "\u20B4": "UAH",
+    "\u20BD": "RUB",
+    "\u20B5": "GHS",
+    "\u20A1": "CL",
+    "\xA2": "c",
+    "\xA5": "YEN",
+    "\u5186": "JPY",
+    "\u09F3": "BDT",
+    "\u5143": "CNY",
+    "\uFDFC": "SAR",
+    "\u17DB": "KR",
+    "\u20A0": "ECU",
+    "\xA4": "$?",
+    "\u0E3F": "THB",
+    "\u060B": "AFN"
+  })
+);
+var UNSUPPORTED = /[^\x09\x10\x13\x0A\x0D\x20-\x7E]/gu;
+function toAscii(value2) {
+  const characters = value2.match(UNSUPPORTED) ?? [];
+  const done = /* @__PURE__ */ new Set();
+  let result = value2;
+  const replace = (run) => {
+    const ascii2 = TABLE.get(run);
+    if (ascii2 === void 0 || done.has(run) || !result.includes(run)) return;
+    done.add(run);
+    result = result.replaceAll(run, ascii2);
+  };
+  for (const size of [3, 2]) {
+    for (let index = 0; index + size <= characters.length; index++) replace(characters.slice(index, index + size).join(""));
+  }
+  for (const character of characters) replace(character);
+  return result.replace(/\n\r|\n|\r|\t/g, " ").replace(UNSUPPORTED, "");
+}
+var INVISIBLE = "\\u0009\\u0020\\u00a0\\u00ad\\u034f\\u061c\\u115f\\u1160\\u17b4\\u17b5\\u180e\\u2000-\\u200f\\u202f\\u205f\\u2060-\\u2065\\u206a-\\u206f\\u3000\\u2800\\u3164\\ufeff\\uffa0\\u{1d159}\\u{1d173}-\\u{1d17a}\\u{e0020}";
+var LEADING = new RegExp(`^[\\s\\0\\v${INVISIBLE}]+`, "u");
+var TRAILING = new RegExp(`[\\s\\0\\v${INVISIBLE}]+$`, "u");
+var TRUE_VALUES = /* @__PURE__ */ new Set(["1", "true", "on", "yes"]);
+var startTrimmed = (value2, characters) => {
+  let start = 0;
+  while (start < value2.length && characters.includes(value2[start])) start++;
+  return value2.slice(start);
+};
+var endTrimmed = (value2, characters) => {
+  let end = value2.length;
+  while (end > 0 && characters.includes(value2[end - 1])) end--;
+  return value2.slice(0, end);
+};
+var Stringable = class _Stringable {
+  #value;
+  constructor(value2 = "") {
+    this.#value = value2;
+  }
+  after(search) {
+    return new _Stringable(Str.after(this.#value, search));
+  }
+  afterLast(search) {
+    return new _Stringable(Str.afterLast(this.#value, search));
+  }
+  append(...values) {
+    return new _Stringable(this.#value + values.join(""));
+  }
+  ascii() {
+    return new _Stringable(Str.ascii(this.#value));
+  }
+  before(search) {
+    return new _Stringable(Str.before(this.#value, search));
+  }
+  beforeLast(search) {
+    return new _Stringable(Str.beforeLast(this.#value, search));
+  }
+  between(from, to) {
+    return new _Stringable(Str.between(this.#value, from, to));
+  }
+  camel() {
+    return new _Stringable(Str.camel(this.#value));
+  }
+  contains(needles) {
+    return Str.contains(this.#value, needles);
+  }
+  endsWith(needles) {
+    return Str.endsWith(this.#value, needles);
+  }
+  /** The same string as `value` (a string or another Stringable). */
+  exactly(value2) {
+    return this.#value === String(value2);
+  }
+  /** The parts between the delimiters, as a Collection (PHP's explode()). */
+  explode(delimiter) {
+    return new Collection(this.#value.split(delimiter));
+  }
+  finish(cap) {
+    return new _Stringable(Str.finish(this.#value, cap));
+  }
+  /** Wildcard match, as Str.is(): `*` matches anything. */
+  is(pattern) {
+    return Str.is(pattern, this.#value);
+  }
+  isEmpty() {
+    return this.#value === "";
+  }
+  isNotEmpty() {
+    return this.#value !== "";
+  }
+  kebab() {
+    return new _Stringable(Str.kebab(this.#value));
+  }
+  lcfirst() {
+    return new _Stringable(Str.lcfirst(this.#value));
+  }
+  /** The number of characters (code points, as PHP's mb_strlen()). */
+  length() {
+    return [...this.#value].length;
+  }
+  limit(limit = 100, end = "...") {
+    return new _Stringable(Str.limit(this.#value, limit, end));
+  }
+  lower() {
+    return new _Stringable(this.#value.toLowerCase());
+  }
+  /** Strips whitespace and invisible characters from the start, or the characters given. */
+  ltrim(characters) {
+    return new _Stringable(characters === void 0 ? this.#value.replace(LEADING, "") : startTrimmed(this.#value, characters));
+  }
+  plural(count = 2) {
+    return new _Stringable(Str.plural(this.#value, count));
+  }
+  prepend(...values) {
+    return new _Stringable(values.join("") + this.#value);
+  }
+  /** Replaces every occurrence of the search string (or of each of several) with `replace`. */
+  replace(search, replace) {
+    let value2 = this.#value;
+    for (const needle of [search].flat()) if (needle !== "") value2 = value2.replaceAll(needle, replace);
+    return new _Stringable(value2);
+  }
+  /** Strips whitespace and invisible characters from the end, or the characters given. */
+  rtrim(characters) {
+    return new _Stringable(characters === void 0 ? this.#value.replace(TRAILING, "") : endTrimmed(this.#value, characters));
+  }
+  singular() {
+    return new _Stringable(Str.singular(this.#value));
+  }
+  slug(separator = "-") {
+    return new _Stringable(Str.slug(this.#value, separator));
+  }
+  snake(delimiter = "_") {
+    return new _Stringable(Str.snake(this.#value, delimiter));
+  }
+  start(prefix) {
+    return new _Stringable(Str.start(this.#value, prefix));
+  }
+  startsWith(needles) {
+    return Str.startsWith(this.#value, needles);
+  }
+  studly() {
+    return new _Stringable(Str.studly(this.#value));
+  }
+  title() {
+    return new _Stringable(Str.title(this.#value));
+  }
+  /** PHP's filter_var(FILTER_VALIDATE_BOOLEAN): '1', 'true', 'on' and 'yes' (any case, trimmed) are true. */
+  toBoolean() {
+    return TRUE_VALUES.has(this.#value.trim().toLowerCase());
+  }
+  /** PHP's floatval(): the leading number, else 0. */
+  toFloat() {
+    const parsed = Number.parseFloat(this.#value);
+    return Number.isNaN(parsed) ? 0 : parsed;
+  }
+  /** PHP's intval(): the leading digits, else 0. */
+  toInteger() {
+    const parsed = Number.parseInt(this.#value.trim(), 10);
+    return Number.isNaN(parsed) ? 0 : parsed;
+  }
+  toJSON() {
+    return this.#value;
+  }
+  toString() {
+    return this.#value;
+  }
+  /** Strips whitespace and invisible characters from both ends (Laravel's Str::trim()), or the characters given. */
+  trim(characters) {
+    return this.ltrim(characters).rtrim(characters);
+  }
+  ucfirst() {
+    return new _Stringable(Str.ucfirst(this.#value));
+  }
+  upper() {
+    return new _Stringable(this.#value.toUpperCase());
+  }
+  value() {
+    return this.#value;
+  }
+};
+var words = (value2) => value2.replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").split(/[^A-Za-z\d]+/).filter(Boolean);
+var ALPHANUM = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+var CROCKFORD = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+var UUID = /^[\da-fA-F]{8}-[\da-fA-F]{4}-[\da-fA-F]{4}-[\da-fA-F]{4}-[\da-fA-F]{12}$/;
+var ULID = /^[0-7][0-9A-HJKMNP-TV-Z]{25}$/i;
+var escapeRegex = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var escapeClass = (s) => s.replace(/[\\\]^-]/g, "\\$&");
+var trimCharacters = (value2, characters) => {
+  const set = new Set(characters);
+  let start = 0;
+  let end = value2.length;
+  while (start < end && set.has(value2[start])) start++;
+  while (end > start && set.has(value2[end - 1])) end--;
+  return value2.slice(start, end);
+};
+var timestamp48 = (time) => {
+  const ms = time.getTime();
+  if (!(ms >= 0 && ms <= 2 ** 48 - 1)) throw new TypeError("The timestamp must be between 1970-01-01 and 10889-08-02.");
+  return ms;
+};
+var anyOf = (needles) => (Array.isArray(needles) ? needles : [needles]).filter((n) => n !== "");
+var Str = {
+  /** Laravel's Str::of(): the value as a Stringable, for chaining: Str.of(title).trim().slug(). */
+  of: (value2 = "") => new Stringable(value2 === null || value2 === void 0 ? "" : String(value2)),
+  ucfirst: (v) => v.charAt(0).toUpperCase() + v.slice(1),
+  lcfirst: (v) => v.charAt(0).toLowerCase() + v.slice(1),
+  studly: (v) => words(v).map((w) => Str.ucfirst(w.toLowerCase())).join(""),
+  camel: (v) => Str.lcfirst(Str.studly(v)),
+  snake: (v, delimiter = "_") => words(v).map((w) => w.toLowerCase()).join(delimiter),
+  kebab: (v) => Str.snake(v, "-"),
+  title: (v) => v.toLowerCase().replace(/(^|\s)\S/g, (m) => m.toUpperCase()),
+  /** Laravel's Str::ascii(): the value in plain ASCII ('Café' → 'Cafe', 'Ελληνικά' → 'Ellinika'), as for English. */
+  ascii: (v) => toAscii(v),
+  /**
+   * Laravel's Str::slug(): transliterated to ASCII first (unless `language` is null), '@' read as 'at', then lower-cased
+   * letters and digits joined by the separator: 'Café crème' → 'cafe-creme'. What has no ASCII form is dropped.
+   */
+  slug: (title, separator = "-", language = "en", dictionary = { "@": "at" }) => {
+    let value2 = language === null ? title : toAscii(title);
+    const flip = separator === "-" ? "_" : "-";
+    value2 = value2.replace(new RegExp(`[${escapeClass(flip)}]+`, "gu"), separator);
+    for (const [key, word] of Object.entries(dictionary)) value2 = value2.replaceAll(key, `${separator}${word}${separator}`);
+    value2 = value2.toLowerCase().replace(new RegExp(`[^${escapeClass(separator)}\\p{L}\\p{N}\\s]+`, "gu"), "");
+    value2 = value2.replace(new RegExp(`[${escapeClass(separator)}\\s]+`, "gu"), separator);
+    return trimCharacters(value2, separator);
+  },
+  plural: (v, count = 2) => pluralize(v, count),
+  singular: (v) => pluralize.singular(v),
+  random: (length = 16) => {
+    let out = "";
+    while (out.length < length) {
+      for (const byte of randomBytes(length)) {
+        if (byte < 248 && out.length < length) out += ALPHANUM[byte % 62];
+      }
+    }
+    return out;
+  },
+  uuid: () => randomUUID(),
+  /**
+   * A version 7 UUID (RFC 9562): the time in milliseconds first, so ids from later milliseconds sort after earlier ones
+   * (within one millisecond the order is random). Throws a TypeError for a time before 1970, after 10889 or invalid.
+   */
+  uuid7: (time = /* @__PURE__ */ new Date()) => {
+    const ms = timestamp48(time);
+    const bytes = randomBytes(16);
+    bytes.writeUIntBE(ms, 0, 6);
+    bytes[6] = 112 | bytes[6] & 15;
+    bytes[8] = 128 | bytes[8] & 63;
+    const hex = bytes.toString("hex");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+  },
+  /**
+   * A ULID: 26 upper-case Crockford characters, ten for the time in milliseconds and sixteen random, so ids from later
+   * milliseconds sort after earlier ones. Throws a TypeError for a time before 1970, after 10889 or invalid.
+   */
+  ulid: (time = /* @__PURE__ */ new Date()) => {
+    let out = "";
+    for (let ms = timestamp48(time), i = 0; i < 10; i++, ms = Math.floor(ms / 32)) out = CROCKFORD[ms % 32] + out;
+    let random = BigInt(`0x${randomBytes(10).toString("hex")}`);
+    let tail = "";
+    for (let i = 0; i < 16; i++, random >>= 5n) tail = CROCKFORD[Number(random & 31n)] + tail;
+    return out + tail;
+  },
+  /** Laravel's Str::isUuid(): five groups of hex digits, any version. */
+  isUuid: (value2) => typeof value2 === "string" && UUID.test(value2),
+  /** Laravel's Str::isUlid(): 26 Crockford characters in either case, the first at most 7. */
+  isUlid: (value2) => typeof value2 === "string" && ULID.test(value2),
+  /** Wildcard match: `*` matches anything; everything else is literal. */
+  is: (pattern, value2) => pattern === value2 || new RegExp(`^${pattern.split("*").map(escapeRegex).join(".*")}$`, "s").test(value2),
+  startsWith: (v, needles) => anyOf(needles).some((n) => v.startsWith(n)),
+  endsWith: (v, needles) => anyOf(needles).some((n) => v.endsWith(n)),
+  contains: (v, needles) => anyOf(needles).some((n) => v.includes(n)),
+  after: (v, search) => search === "" || !v.includes(search) ? v : v.slice(v.indexOf(search) + search.length),
+  afterLast: (v, search) => search === "" || !v.includes(search) ? v : v.slice(v.lastIndexOf(search) + search.length),
+  before: (v, search) => search === "" || !v.includes(search) ? v : v.slice(0, v.indexOf(search)),
+  beforeLast: (v, search) => search === "" || !v.includes(search) ? v : v.slice(0, v.lastIndexOf(search)),
+  between: (v, from, to) => Str.beforeLast(Str.after(v, from), to),
+  limit: (v, limit = 100, end = "...") => v.length <= limit ? v : v.slice(0, limit).trimEnd() + end,
+  start: (v, prefix) => v.startsWith(prefix) ? v : prefix + v,
+  finish: (v, cap) => v.endsWith(cap) ? v : v + cap
+};
+var FORBIDDEN = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+var isWalkable = (v) => typeof v === "object" && v !== null;
+var segments = (key) => key.split(".");
+var Arr = {
+  get(target, key, defaultValue) {
+    if (key === void 0 || key === "") return target;
+    let current = target;
+    for (const segment of segments(key)) {
+      if (!isWalkable(current) || !Object.hasOwn(current, segment)) return defaultValue;
+      current = current[segment];
+    }
+    return current;
+  },
+  has(target, key) {
+    const missing = /* @__PURE__ */ Symbol("missing");
+    return Arr.get(target, key, missing) !== missing;
+  },
+  set(target, key, value2) {
+    const parts = segments(key);
+    if (parts.some((p) => FORBIDDEN.has(p))) throw new Error(`Refusing to set unsafe key "${key}"`);
+    let current = target;
+    parts.slice(0, -1).forEach((segment) => {
+      if (!isWalkable(current[segment])) current[segment] = {};
+      current = current[segment];
+    });
+    current[parts.at(-1)] = value2;
+    return target;
+  },
+  forget(target, key) {
+    const parts = segments(key);
+    const parent = parts.length === 1 ? target : Arr.get(target, parts.slice(0, -1).join("."));
+    if (isWalkable(parent)) delete parent[parts.at(-1)];
+  },
+  dot(target, prefix = "") {
+    const out = {};
+    for (const [k, v] of Object.entries(target)) {
+      const path = prefix + k;
+      if (isWalkable(v) && Object.keys(v).length > 0) Object.assign(out, Arr.dot(v, `${path}.`));
+      else out[path] = v;
+    }
+    return out;
+  },
+  undot(flat) {
+    const out = {};
+    for (const [k, v] of Object.entries(flat)) Arr.set(out, k, v);
+    return out;
+  },
+  only(target, keys) {
+    return Object.fromEntries(keys.filter((k) => Object.hasOwn(target, k)).map((k) => [k, target[k]]));
+  },
+  except(target, keys) {
+    const skip = new Set(keys);
+    return Object.fromEntries(Object.entries(target).filter(([k]) => !skip.has(k)));
+  },
+  wrap(value2) {
+    if (value2 === null || value2 === void 0) return [];
+    return Array.isArray(value2) ? value2 : [value2];
+  },
+  first(items, predicate, defaultValue) {
+    const index = predicate ? items.findIndex(predicate) : items.length > 0 ? 0 : -1;
+    return index === -1 ? defaultValue : items[index];
+  },
+  last(items, predicate, defaultValue) {
+    const index = predicate ? items.findLastIndex(predicate) : items.length - 1;
+    return index === -1 ? defaultValue : items[index];
+  }
+};
+var ServiceProvider = class {
+  constructor(app2) {
+    this.app = app2;
+  }
+  app;
+  register() {
+  }
+  boot() {
+  }
+  /** Package defaults under `key`; values the app already set win (shallow merge, like Laravel). */
+  mergeConfigFrom(defaults, key) {
+    const config2 = this.app.make(ConfigRepository);
+    config2.set(key, { ...defaults, ...config2.get(key, {}) });
+  }
+};
+function facade(abstract, extras) {
+  const container = () => {
+    const c = currentContainer();
+    if (!c) throw new ContainerNotAvailableError(describe(abstract));
+    return c;
+  };
+  const statics = {
+    getFacadeRoot: () => container().make(abstract),
+    swap: (instance) => void container().instance(abstract, instance)
+  };
+  const proxy = new Proxy({}, {
+    get(_target, prop) {
+      if (typeof prop === "symbol" || prop === "then") return void 0;
+      if (extras && Object.hasOwn(extras, prop)) {
+        const extra = extras[prop];
+        return typeof extra === "function" ? extra.bind(proxy) : extra;
+      }
+      if (Object.hasOwn(statics, prop)) return statics[prop];
+      const root = statics.getFacadeRoot();
+      const value2 = Reflect.get(root, prop, root);
+      return typeof value2 === "function" ? value2.bind(root) : value2;
+    }
+  });
+  return proxy;
+}
+var ClassRegistry = class {
+  byName = /* @__PURE__ */ new Map();
+  byClass = /* @__PURE__ */ new Map();
+  register(cls, name = cls.name) {
+    const existingName = this.byClass.get(cls);
+    if (existingName !== void 0) return existingName;
+    if (!name) throw new Error('Anonymous classes need an explicit name: registry.register(cls, "Some.Name")');
+    const existing = this.byName.get(name);
+    if (existing && existing !== cls) {
+      throw new Error(`"${name}" is already registered to a different class. Pass an explicit name: register(cls, "Module.${name}")`);
+    }
+    this.byName.set(name, cls);
+    this.byClass.set(cls, name);
+    return name;
+  }
+  nameOf(cls) {
+    return this.byClass.get(cls);
+  }
+  resolve(name) {
+    const cls = this.byName.get(name);
+    if (!cls) throw new Error(`No class registered as "${name}". Is it registered by its service provider?`);
+    return cls;
+  }
+  has(name) {
+    return this.byName.has(name);
+  }
+};
+var SCOPE_METHODS = /* @__PURE__ */ new Set(["make", "instance", "bound", "resolved", "forgetInstance", "createScope", "run"]);
+var scopedViews = /* @__PURE__ */ new WeakMap();
+function viewFrom(scope, application) {
+  let view = scopedViews.get(scope);
+  if (view === void 0) {
+    view = new Proxy(application, {
+      get(target, property) {
+        const source = SCOPE_METHODS.has(property) ? scope : target;
+        const member = Reflect.get(source, property, source);
+        return typeof member === "function" ? member.bind(source) : member;
+      }
+    });
+    scopedViews.set(scope, view);
+  }
+  return view;
+}
+function app(abstract) {
+  if (abstract !== void 0) return inject(abstract);
+  const application = inject(Application);
+  const current = currentContainer();
+  return current === void 0 || current === application ? application : viewFrom(current, application);
+}
+function config(keyOrValues, defaultValue) {
+  const repository = inject(ConfigRepository);
+  if (keyOrValues === void 0) return repository;
+  if (typeof keyOrValues === "string") return repository.get(keyOrValues, defaultValue);
+  repository.set(keyOrValues);
+  return void 0;
+}
+var now = () => /* @__PURE__ */ new Date();
+var value = (v) => typeof v === "function" ? v() : v;
+function tap(target, callback) {
+  callback(target);
+  return target;
+}
+async function retry(times, fn, sleepMs = 0, when) {
+  for (let attempt = 1; ; attempt++) {
+    try {
+      return await fn(attempt);
+    } catch (error) {
+      if (attempt >= times || when && !when(error)) throw error;
+      const ms = typeof sleepMs === "function" ? sleepMs(attempt) : sleepMs;
+      if (ms > 0) await sleep(ms);
+    }
+  }
+}
+var LINES = {
+  "auth.failed": "These credentials do not match our records.",
+  "auth.password": "The provided password is incorrect.",
+  "auth.throttle": "Too many login attempts. Please try again in :seconds seconds.",
+  "passwords.reset": "Your password has been reset.",
+  "passwords.sent": "We have emailed your password reset link.",
+  "passwords.throttled": "Please wait before retrying.",
+  "passwords.token": "This password reset token is invalid.",
+  "passwords.user": "We can't find a user with that email address."
+};
+function __(key, replace = {}) {
+  let line = LINES[key] ?? key;
+  const names = Object.keys(replace).sort((a, b) => b.length - a.length);
+  for (const name of names) {
+    const value2 = String(replace[name]);
+    const capitalized = name.charAt(0).toUpperCase() + name.slice(1);
+    line = line.replaceAll(`:${capitalized}`, value2.charAt(0).toUpperCase() + value2.slice(1)).replaceAll(`:${name.toUpperCase()}`, value2.toUpperCase()).replaceAll(`:${name}`, value2);
+  }
+  return line;
+}
+var fileType_exports = {};
+__export(fileType_exports, {
+  AVIF: () => AVIF,
+  BINARY_AND_MARKUP_TYPES: () => BINARY_AND_MARKUP_TYPES,
+  BMP: () => BMP,
+  EMPTY: () => EMPTY,
+  GIF: () => GIF,
+  HTML: () => HTML,
+  JPEG: () => JPEG,
+  PDF: () => PDF,
+  PNG: () => PNG,
+  RASTER_IMAGES: () => RASTER_IMAGES,
+  SNIFF_BYTES: () => SNIFF_BYTES,
+  SVG: () => SVG,
+  TEXT: () => TEXT,
+  UNKNOWN: () => UNKNOWN,
+  WEBP: () => WEBP,
+  XML: () => XML,
+  detectFileType: () => detectFileType
+});
+var type = (mime, ...extensions) => Object.freeze({ mime, extensions: Object.freeze(extensions) });
+var JPEG = type("image/jpeg", "jpg", "jpeg");
+var PNG = type("image/png", "png");
+var GIF = type("image/gif", "gif");
+var WEBP = type("image/webp", "webp");
+var AVIF = type("image/avif", "avif");
+var BMP = type("image/bmp", "bmp");
+var SVG = type("image/svg+xml", "svg");
+var PDF = type("application/pdf", "pdf");
+var HTML = type("text/html", "html", "htm");
+var XML = type("text/xml", "xml");
+var TEXT = type("text/plain", "txt");
+var UNKNOWN = type("application/octet-stream");
+var EMPTY = type("application/x-empty");
+var RASTER_IMAGES = new Set([JPEG, PNG, GIF, WEBP, AVIF, BMP].map(({ mime }) => mime));
+var BINARY_AND_MARKUP_TYPES = [JPEG, PNG, GIF, WEBP, AVIF, BMP, SVG, PDF, HTML, XML];
+var SNIFF_BYTES = 1024 * 1024;
+var MARKUP_SNIFF_BYTES = 64 * 1024;
+var MAX_PROLOG_ITEMS = 64;
+var BINARY_BYTES = new Uint8Array(256).fill(1, 0, 32);
+for (const byte of [7, 8, 9, 10, 11, 12, 13, 27]) BINARY_BYTES[byte] = 0;
+BINARY_BYTES[127] = 1;
+var FTYP_SCAN_BYTES = 1024;
+var BMP_HEADER_SIZES = /* @__PURE__ */ new Set([12, 40, 52, 56, 64, 108, 124]);
+var ascii = (bytes, offset, length) => String.fromCharCode(...bytes.subarray(offset, offset + length));
+var startsWith = (bytes, signature) => bytes.length >= signature.length && signature.every((byte, i) => bytes[i] === byte);
+var u32be = (bytes, offset) => (bytes[offset] << 24 | bytes[offset + 1] << 16 | bytes[offset + 2] << 8 | bytes[offset + 3]) >>> 0;
+var u32le = (bytes, offset) => (bytes[offset] | bytes[offset + 1] << 8 | bytes[offset + 2] << 16 | bytes[offset + 3] << 24) >>> 0;
+function detectFileType(bytes) {
+  if (bytes.length === 0) return EMPTY;
+  if (startsWith(bytes, [255, 216, 255])) return JPEG;
+  if (startsWith(bytes, [137, 80, 78, 71, 13, 10, 26, 10])) return PNG;
+  const head = ascii(bytes, 0, 6);
+  if (head === "GIF87a" || head === "GIF89a") return GIF;
+  if (ascii(bytes, 0, 4) === "RIFF" && ascii(bytes, 8, 4) === "WEBP") return WEBP;
+  if (isAvif(bytes)) return AVIF;
+  if (ascii(bytes, 0, 2) === "BM" && bytes.length >= 18 && BMP_HEADER_SIZES.has(u32le(bytes, 14))) return BMP;
+  if (ascii(bytes, 0, 5) === "%PDF-") return PDF;
+  return detectText(bytes);
+}
+function isAvif(bytes) {
+  if (bytes.length < 16 || ascii(bytes, 4, 4) !== "ftyp") return false;
+  const isAvifBrand = (offset) => {
+    const brand = ascii(bytes, offset, 4);
+    return brand === "avif" || brand === "avis";
+  };
+  if (isAvifBrand(8)) return true;
+  const end = Math.min(u32be(bytes, 0), bytes.length, FTYP_SCAN_BYTES);
+  for (let offset = 16; offset + 4 <= end; offset += 4) {
+    if (isAvifBrand(offset)) return true;
+  }
+  return false;
+}
+function detectText(bytes) {
+  const end = Math.min(bytes.length, SNIFF_BYTES);
+  for (let i = 0; i < end; i++) {
+    if (BINARY_BYTES[bytes[i]] === 1) return UNKNOWN;
+  }
+  const content = new TextDecoder().decode(bytes.subarray(0, MARKUP_SNIFF_BYTES)).trimStart();
+  if (!content.startsWith("<")) return TEXT;
+  const root = rootElement(content);
+  if (root === "svg" || root?.endsWith(":svg")) return SVG;
+  if (root === "html") return HTML;
+  return content.startsWith("<?xml") ? XML : HTML;
+}
+function rootElement(markup) {
+  let rest = markup;
+  for (let items = 0; ; items++) {
+    const skip = prologItemLength(rest);
+    if (skip === 0) return /^<([A-Za-z_][\w.:-]*)/.exec(rest)?.[1]?.toLowerCase();
+    if (skip === -1 || items === MAX_PROLOG_ITEMS) return void 0;
+    rest = rest.slice(skip).trimStart();
+  }
+}
+function prologItemLength(rest) {
+  const through = (index, length) => index === -1 ? -1 : index + length;
+  if (rest.startsWith("<?")) return through(rest.indexOf("?>"), 2);
+  if (rest.startsWith("<!--")) return through(rest.indexOf("-->"), 3);
+  if (/^<!doctype/i.test(rest)) {
+    const close = rest.indexOf(">");
+    if (close === -1) return -1;
+    const subset = rest.slice(0, close).indexOf("[");
+    if (subset === -1) return close + 1;
+    const subsetEnd = rest.indexOf("]", subset);
+    return subsetEnd === -1 ? -1 : through(rest.indexOf(">", subsetEnd), 1);
+  }
+  return 0;
+}
+
+export {
+  BindingResolutionError,
+  CircularDependencyError,
+  ContainerNotAvailableError,
+  currentContainer,
+  inject,
+  Container2 as Container,
+  ItemNotFoundError,
+  MultipleItemsFoundError,
+  LazyCollection,
+  Collection,
+  collect,
+  Stringable,
+  Str,
+  Arr,
+  ServiceProvider,
+  facade,
+  ClassRegistry,
+  app,
+  config,
+  now,
+  value,
+  tap,
+  retry,
+  __,
+  fileType_exports
+};
+/*!
+ * Laravel's Str::ascii() table for English: the transliterations of voku/portable-ascii 2.0, merged as its to_ascii()
+ * merges them for the 'en' language (runs of up to three characters; longer runs never apply to 'en'). The keys are
+ * written as \u escapes so this file stays plain ASCII.
+ *
+ * voku/portable-ascii: Copyright (C) 2019 Lars Moelleken
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+ * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+ * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+//# sourceMappingURL=chunk-7ZQZYDOC.js.map