@orieljs/framework 0.1.0-alpha.3 → 0.1.0-alpha.5

package/dist/chunk-HU43NADT.js

@@ -1,745 +0,0 @@
-import {
-  Application,
-  ConfigRepository,
-  Container
-} from "./chunk-S7YC43IH.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 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 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)));
-  }
-  [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);
-  }
-  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 new _Collection(this.items.filter(callback ?? ((item) => Boolean(item))));
-  }
-  reject(callback) {
-    return new _Collection(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(key, operatorOrValue, value2) {
-    const [op, expected] = arguments.length === 2 ? ["=", operatorOrValue] : [operatorOrValue, value2];
-    return this.filter((item) => compare(read(item, key), op, expected));
-  }
-  firstWhere(key, operatorOrValue, value2) {
-    const [op, expected] = arguments.length === 2 ? ["=", operatorOrValue] : [operatorOrValue, value2];
-    return this.items.find((item) => compare(read(item, key), op, expected));
-  }
-  whereIn(key, values) {
-    const set = new Set(values);
-    return this.filter((item) => set.has(read(item, key)));
-  }
-  whereNotIn(key, values) {
-    const set = new Set(values);
-    return this.filter((item) => !set.has(read(item, key)));
-  }
-  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 = {};
-    for (const item of this.items) (groups[String(read(item, key))] ??= new _Collection()).push(item);
-    return groups;
-  }
-  mapWithKeys(callback) {
-    return Object.fromEntries(this.items.map(callback));
-  }
-  sortBy(key, direction = "asc") {
-    const sign = direction === "asc" ? 1 : -1;
-    return new _Collection(
-      this.items.map((item, index) => ({ item, index, value: read(item, key) })).sort((a, b) => {
-        const aNil = a.value === null || a.value === void 0;
-        const bNil = b.value === null || b.value === void 0;
-        if (aNil || bNil) return aNil === bNil ? a.index - b.index : aNil ? 1 : -1;
-        return sign * ascending(a.value, b.value) || 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;
-  }
-  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;
-    });
-  }
-  chunk(size) {
-    if (size <= 0) return new _Collection();
-    const chunks = [];
-    for (let i = 0; i < this.items.length; i += size) chunks.push(new _Collection(this.items.slice(i, i + size)));
-    return new _Collection(chunks);
-  }
-  /** Negative count takes from the end. */
-  take(count) {
-    return new _Collection(count < 0 ? this.items.slice(count) : this.items.slice(0, count));
-  }
-  skip(count) {
-    return new _Collection(this.items.slice(count));
-  }
-  slice(offset, length) {
-    return new _Collection(this.items.slice(offset, length === void 0 ? void 0 : offset + length));
-  }
-  values() {
-    return new _Collection(this.items);
-  }
-  contains(keyOrValue, value2) {
-    if (arguments.length === 2) return this.items.some((item) => read(item, keyOrValue) === value2);
-    if (typeof keyOrValue === "function") return this.items.some(keyOrValue);
-    return this.items.includes(keyOrValue);
-  }
-  /** Mutates, like Laravel. */
-  push(...values) {
-    this.items.push(...values);
-    return this;
-  }
-  concat(values) {
-    return new _Collection([...this.items, ...values]);
-  }
-  partition(callback) {
-    return [this.filter(callback), this.reject(callback)];
-  }
-  implode(keyOrGlue, glue) {
-    if (glue === void 0) return this.items.join(keyOrGlue);
-    return this.items.map((item) => read(item, keyOrGlue)).join(glue);
-  }
-  when(condition, callback) {
-    return condition ? callback(this) : this;
-  }
-  pipe(callback) {
-    return callback(this);
-  }
-  tap(callback) {
-    callback(this);
-    return this;
-  }
-};
-function collect(items = []) {
-  return new Collection(items);
-}
-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);
-  }
-};
-
-// ../Support/dist/index.js
-import { randomBytes, randomUUID } from "crypto";
-import pluralize from "pluralize";
-import { setTimeout as sleep } from "timers/promises";
-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 escapeRegex = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-var anyOf = (needles) => (Array.isArray(needles) ? needles : [needles]).filter((n) => n !== "");
-var Str = {
-  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()),
-  slug: (v, separator = "-") => v.normalize("NFKD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[^a-z\d]+/g, separator).replace(new RegExp(`^${escapeRegex(separator)}+|${escapeRegex(separator)}+$`, "g"), ""),
-  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(),
-  /** 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);
-    }
-  }
-}
-
-export {
-  BindingResolutionError,
-  CircularDependencyError,
-  ContainerNotAvailableError,
-  currentContainer,
-  inject,
-  Container2 as Container,
-  Collection,
-  collect,
-  LazyCollection,
-  Str,
-  Arr,
-  ServiceProvider,
-  facade,
-  ClassRegistry,
-  app,
-  config,
-  now,
-  value,
-  tap,
-  retry
-};
-//# sourceMappingURL=chunk-HU43NADT.js.map