@fnioc/di 1.0.0 → 2.0.0

package/dist/index.js

@@ -1,23 +1,521 @@
-// @fnioc/di — the ioc runtime engine.
-//
-// Consumes the plain-data ABI emitted by @fnioc/transformer (or hand-fed via
-// @fnioc/core's authoring surfaces) and resolves the dependency graph. Never
-// touches a TypeScript type — works purely on string tokens and the positional
-// DepRecord signatures in the global WeakMap.
-//
-// Phase 2A scope: registration, the scope chain + tagged lifetimes, resolution
-// with the captive-dependency rule, greedy signature selection, cycle
-// detection, the useFactory/useValue overrides, and native disposal.
-//
-// Phase 2D.2 adds factory injection (a ctor param typed `() => IFoo` becomes an
-// injected callable) and hole-filling (a caller-supplied parameter filled
-// positionally at factory call time).
-export { DiBuilder } from "./builder.js";
-export { Scope } from "./scope.js";
-export { DiError, UnregisteredTokenError, MissingScopeError, MissingMetadataError, NoSatisfiableSignatureError, FactoryTargetError, CircularDependencyError, AsyncDisposalRequiredError, } from "./errors.js";
-// Re-exported from @fnioc/core for one-import authoring ergonomics. These are
-// pure metadata writers with zero resolution dependency; living in `core` keeps
-// the ABI self-contained, but consumers writing both registrations and manual
-// annotations get them from a single import here.
-export { signature, forCtor, hole } from "@fnioc/core";
-//# sourceMappingURL=index.js.map
+// ../core/src/store.ts
+var hole = null;
+var GLOBAL_KEY = Symbol.for("fnioc:deps");
+var globals = globalThis;
+var store = globals[GLOBAL_KEY] ??= new Map;
+// ../core/src/defineDeps.ts
+function isFactoryRef(slot) {
+  return typeof slot === "object" && slot !== null && typeof slot.factory === "string";
+}
+function isScopeRef(slot) {
+  return typeof slot === "object" && slot !== null && slot.scope === true;
+}
+function slotsEqual(a, b) {
+  const aIsRef = isFactoryRef(a);
+  const bIsRef = isFactoryRef(b);
+  if (aIsRef || bIsRef) {
+    return aIsRef && bIsRef && a.factory === b.factory;
+  }
+  const aIsScope = isScopeRef(a);
+  const bIsScope = isScopeRef(b);
+  if (aIsScope || bIsScope) {
+    return aIsScope && bIsScope;
+  }
+  return a === b;
+}
+function signaturesEqual(a, b) {
+  if (a.length !== b.length)
+    return false;
+  for (let i = 0;i < a.length; i++) {
+    if (!slotsEqual(a[i], b[i]))
+      return false;
+  }
+  return true;
+}
+function defineDeps(target, signatures) {
+  const existing = store.get(target);
+  if (existing !== undefined) {
+    const merged = [...existing.signatures];
+    for (const sig of signatures) {
+      if (!merged.some((s) => signaturesEqual(s, sig))) {
+        merged.push(sig);
+      }
+    }
+    store.set(target, { signatures: merged });
+  } else {
+    store.set(target, { signatures });
+  }
+}
+function getDeps(target) {
+  return store.get(target);
+}
+// ../core/src/signature.ts
+function signature(...tokens) {
+  return (value, _context) => {
+    defineDeps(value, [tokens.slice()]);
+  };
+}
+// ../core/src/forCtor.ts
+function forCtor(ctor) {
+  const builder = {
+    signature(...tokens) {
+      defineDeps(ctor, [tokens.slice()]);
+      return builder;
+    }
+  };
+  return builder;
+}
+// src/errors.ts
+class DiError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+  }
+}
+
+class UnregisteredTokenError extends DiError {
+  token;
+  constructor(token) {
+    super(`No registration found for token "${token}". Register it with ` + `services.add(...) before resolving.`);
+    this.token = token;
+  }
+}
+
+class MissingScopeError extends DiError {
+  token;
+  scope;
+  availableScopes;
+  constructor(token, scope, availableScopes) {
+    super(`Cannot resolve "${token}": its lifetime is tagged "${scope}", but no ` + `ancestor scope with that name exists in the resolving chain ` + `(available: ${availableScopes.length > 0 ? availableScopes.map((s) => `"${s}"`).join(" → ") : "none"}). ` + `This usually means a longer-lived service depends on a ` + `shorter-lived one (e.g. a "singleton" needing a "request"). Never ` + `auto-created — fix the registration's lifetime or create the scope.`);
+    this.token = token;
+    this.scope = scope;
+    this.availableScopes = availableScopes;
+  }
+}
+
+class MissingMetadataError extends DiError {
+  token;
+  ctorName;
+  constructor(token, ctorName) {
+    super(`No dep metadata found for ${ctorName} (resolving "${token}"). The ` + `constructor has parameters but no @signature, forCtor, or ` + `transformer-generated defineDeps call was found. Use ` + `forCtor(...).signature(...) or register it with useFactory to wire ` + `it manually.`);
+    this.token = token;
+    this.ctorName = ctorName;
+  }
+}
+
+class NoSatisfiableSignatureError extends DiError {
+  token;
+  ctorName;
+  unsatisfiable;
+  constructor(token, ctorName, unsatisfiable) {
+    super(`No satisfiable constructor signature for ${ctorName} (resolving ` + `"${token}"). Every candidate signature names a dependency that is ` + `not registered in the owning scope` + (unsatisfiable.length > 0 ? `; unsatisfiable tokens: ${unsatisfiable.map((t) => `"${t}"`).join(", ")}` : "") + `. Register the missing dependencies, or provide a useFactory ` + `override.`);
+    this.token = token;
+    this.ctorName = ctorName;
+    this.unsatisfiable = unsatisfiable;
+  }
+}
+
+class CircularDependencyError extends DiError {
+  path;
+  constructor(path) {
+    super(`Circular dependency detected:
+  ${path.join(" → ")}`);
+    this.path = path;
+  }
+}
+
+class FactoryTargetError extends DiError {
+  factoryToken;
+  reason;
+  constructor(factoryToken, reason) {
+    super(reason === "unregistered" ? `Cannot inject a factory for "${factoryToken}": no registration ` + `found for it. A factory parameter (typed \`() => IFoo\`) needs ` + `the target registered as a class with ` + `services.add(...) before it can build instances.` : `Cannot inject a factory for "${factoryToken}": it is registered ` + `as a useValue/useFactory override, not a class. A factory builds ` + `its target with \`new\`, so the target must be a class ` + `registration. Resolve it directly instead of as a factory, or ` + `register the class with services.add(...).`);
+    this.factoryToken = factoryToken;
+    this.reason = reason;
+  }
+}
+
+class AsyncDisposalRequiredError extends DiError {
+  constructor() {
+    super(`Cannot dispose synchronously: this scope owns a Promise-valued ` + `instance (an async useFactory result). Awaiting it is required ` + `before disposal — call disposeAsync() instead of dispose().`);
+  }
+}
+
+// src/scope.ts
+function isDisposable(value) {
+  return value != null && (typeof value === "object" || typeof value === "function") && typeof value[Symbol.dispose] === "function";
+}
+function isAsyncDisposable(value) {
+  return value != null && (typeof value === "object" || typeof value === "function") && typeof value[Symbol.asyncDispose] === "function";
+}
+function isThenable(value) {
+  return value != null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+}
+function isFactoryRef2(slot) {
+  return slot !== null && typeof slot === "object" && typeof slot.factory === "string";
+}
+function isScopeRef2(slot) {
+  return slot !== null && typeof slot === "object" && slot.scope === true;
+}
+
+class Scope {
+  name;
+  parent;
+  baseRegistrations;
+  localRegistrations = new Map;
+  instances = new Map;
+  ownedOrder = [];
+  disposed = false;
+  constructor(name, parent, baseRegistrations) {
+    this.name = name;
+    this.parent = parent;
+    this.baseRegistrations = baseRegistrations;
+  }
+  static appendTo(map, token, registration) {
+    const existing = map.get(token);
+    if (existing === undefined) {
+      map.set(token, [registration]);
+    } else {
+      existing.push(registration);
+    }
+  }
+  createScope(childName) {
+    return new Scope(childName, this, this.baseRegistrations);
+  }
+  appendScopedLocal(token, base) {
+    Scope.appendTo(this.localRegistrations, token, base);
+    const map = this.localRegistrations;
+    return {
+      as(scope) {
+        if (scope === undefined)
+          return;
+        Scope.appendTo(map, token, { ...base, scope });
+      }
+    };
+  }
+  add(token, ctor) {
+    return this.appendScopedLocal(token, {
+      kind: "class",
+      ctor,
+      scope: undefined
+    });
+  }
+  addFactory(token, factory) {
+    return this.appendScopedLocal(token, {
+      kind: "factory",
+      factory,
+      scope: undefined
+    });
+  }
+  addValue(token, value) {
+    Scope.appendTo(this.localRegistrations, token, {
+      kind: "value",
+      useValue: value
+    });
+    return this;
+  }
+  resolve(token) {
+    if (token === undefined) {
+      throw new TypeError("resolve<T>() requires the @fnioc/transformer plugin (no token at " + "runtime). Without it, resolve with an explicit token: " + 'resolve<T>("my:token").');
+    }
+    return this.resolveWith(token, []);
+  }
+  resolveFactory(token) {
+    return this.makeFactory({ factory: token });
+  }
+  lookup(token) {
+    let node = this;
+    while (node !== undefined) {
+      const local = node.localRegistrations.get(token);
+      if (local !== undefined && local.length > 0)
+        return local[local.length - 1];
+      node = node.parent;
+    }
+    const base = this.baseRegistrations.get(token);
+    return base !== undefined && base.length > 0 ? base[base.length - 1] : undefined;
+  }
+  findOwner(scope) {
+    let node = this;
+    while (node !== undefined) {
+      if (node.name === scope)
+        return node;
+      node = node.parent;
+    }
+    return;
+  }
+  chainNames() {
+    const names = [];
+    let node = this;
+    while (node !== undefined) {
+      names.push(node.name);
+      node = node.parent;
+    }
+    return names;
+  }
+  resolveWith(token, stack) {
+    if (stack.includes(token)) {
+      throw new CircularDependencyError([...stack, token]);
+    }
+    const registration = this.lookup(token);
+    if (registration === undefined) {
+      throw new UnregisteredTokenError(token);
+    }
+    if (registration.kind === "value") {
+      return registration.useValue;
+    }
+    if (registration.scope === undefined) {
+      stack.push(token);
+      try {
+        return this.instantiate(token, registration, this, stack);
+      } finally {
+        stack.pop();
+      }
+    }
+    const owner = this.findOwner(registration.scope);
+    if (owner === undefined) {
+      throw new MissingScopeError(token, registration.scope, this.chainNames());
+    }
+    if (owner.instances.has(token)) {
+      return owner.instances.get(token);
+    }
+    stack.push(token);
+    try {
+      const instance = owner.instantiate(token, registration, owner, stack);
+      owner.instances.set(token, instance);
+      owner.ownedOrder.push(instance);
+      return instance;
+    } finally {
+      stack.pop();
+    }
+  }
+  instantiate(token, registration, owningScope, stack) {
+    if (registration.kind === "factory") {
+      return owningScope.invokeFactory(token, registration.factory, stack);
+    }
+    return owningScope.construct(token, registration.ctor, stack);
+  }
+  makeScopeView(stack) {
+    const owner = this;
+    const view = {
+      resolve: (depToken) => {
+        if (depToken === undefined) {
+          throw new TypeError("resolve<T>() requires the @fnioc/transformer plugin (no token at " + "runtime).");
+        }
+        return owner.resolveWith(depToken, stack);
+      },
+      resolveFactory: (depToken) => owner.makeFactory({ factory: depToken }),
+      createScope: (name) => owner.createScope(name)
+    };
+    return view;
+  }
+  invokeFactory(token, factory, stack) {
+    const scopeView = this.makeScopeView(stack);
+    const record = getDeps(factory);
+    if (record === undefined || record.signatures.length === 0) {
+      return factory(scopeView);
+    }
+    const signature2 = this.selectSignature(token, factory.name, record.signatures);
+    const args = signature2.map((slot) => {
+      if (isScopeRef2(slot))
+        return scopeView;
+      if (isFactoryRef2(slot))
+        return this.makeFactory(slot);
+      return this.resolveWith(slot, stack);
+    });
+    return factory(...args);
+  }
+  construct(token, ctor, stack) {
+    const record = getDeps(ctor);
+    if (record === undefined || record.signatures.length === 0) {
+      if (ctor.length > 0) {
+        throw new MissingMetadataError(token, ctor.name);
+      }
+      return new ctor;
+    }
+    const signature2 = this.selectSignature(token, ctor.name, record.signatures);
+    const args = signature2.map((slot) => {
+      if (isScopeRef2(slot)) {
+        return this.makeScopeView(stack);
+      }
+      if (isFactoryRef2(slot)) {
+        return this.makeFactory(slot);
+      }
+      return this.resolveWith(slot, stack);
+    });
+    return new ctor(...args);
+  }
+  makeFactory(ref) {
+    const owningScope = this;
+    const target = this.lookup(ref.factory);
+    if (target === undefined) {
+      throw new FactoryTargetError(ref.factory, "unregistered");
+    }
+    if (target.kind === "value") {
+      return () => owningScope.resolveWith(ref.factory, []);
+    }
+    const depTarget = target.kind === "class" ? target.ctor : target.factory;
+    const record = getDeps(depTarget);
+    const targetSignature = record === undefined || record.signatures.length === 0 ? undefined : owningScope.selectTargetSignature(record.signatures);
+    const parameterized = targetSignature !== undefined && targetSignature.some((slot) => !isFactoryRef2(slot) && !isScopeRef2(slot) && !owningScope.isResolvable(slot));
+    if (!parameterized) {
+      return () => owningScope.resolveWith(ref.factory, []);
+    }
+    return (...callArgs) => owningScope.buildPartitioned(target, targetSignature, callArgs);
+  }
+  buildPartitioned(target, signature2, callerArgs) {
+    const stack = [];
+    let nextCallerArg = 0;
+    const args = signature2.map((slot) => {
+      if (isScopeRef2(slot))
+        return this.makeScopeView(stack);
+      if (isFactoryRef2(slot))
+        return this.makeFactory(slot);
+      if (!this.isResolvable(slot)) {
+        return callerArgs[nextCallerArg++];
+      }
+      return this.resolveWith(slot, stack);
+    });
+    return target.kind === "class" ? new target.ctor(...args) : target.factory(...args);
+  }
+  selectSignature(token, targetName, signatures) {
+    const ordered = signatures.map((sig, index) => ({ sig, index })).sort((a, b) => b.sig.length !== a.sig.length ? b.sig.length - a.sig.length : a.index - b.index);
+    const unsatisfiable = new Set;
+    for (const { sig } of ordered) {
+      let satisfiable = true;
+      for (const slot of sig) {
+        if (isFactoryRef2(slot) || isScopeRef2(slot))
+          continue;
+        if (!this.isResolvable(slot)) {
+          satisfiable = false;
+          if (typeof slot === "string")
+            unsatisfiable.add(slot);
+        }
+      }
+      if (satisfiable)
+        return sig;
+    }
+    throw new NoSatisfiableSignatureError(token, targetName, [...unsatisfiable]);
+  }
+  selectTargetSignature(signatures) {
+    return signatures.map((sig, index) => ({ sig, index })).sort((a, b) => b.sig.length !== a.sig.length ? b.sig.length - a.sig.length : a.index - b.index)[0].sig;
+  }
+  isResolvable(slot) {
+    return typeof slot === "string" && this.lookup(slot) !== undefined;
+  }
+  dispose() {
+    if (this.disposed)
+      return;
+    for (const instance of this.ownedOrder) {
+      if (isThenable(instance)) {
+        throw new AsyncDisposalRequiredError;
+      }
+    }
+    this.disposed = true;
+    for (let i = this.ownedOrder.length - 1;i >= 0; i--) {
+      const instance = this.ownedOrder[i];
+      if (isDisposable(instance)) {
+        instance[Symbol.dispose]();
+      }
+    }
+    this.clear();
+  }
+  async disposeAsync() {
+    if (this.disposed)
+      return;
+    this.disposed = true;
+    const settled = [];
+    for (const instance of this.ownedOrder) {
+      settled.push(isThenable(instance) ? await instance : instance);
+    }
+    for (let i = settled.length - 1;i >= 0; i--) {
+      const instance = settled[i];
+      if (isAsyncDisposable(instance)) {
+        await instance[Symbol.asyncDispose]();
+      } else if (isDisposable(instance)) {
+        instance[Symbol.dispose]();
+      }
+    }
+    this.clear();
+  }
+  clear() {
+    this.instances.clear();
+    this.ownedOrder.length = 0;
+  }
+  [Symbol.dispose]() {
+    this.dispose();
+  }
+  [Symbol.asyncDispose]() {
+    return this.disposeAsync();
+  }
+}
+
+// src/builder.ts
+class DiBuilder {
+  registrations = new Map;
+  rootName;
+  constructor(rootName) {
+    this.rootName = rootName ?? "singleton";
+  }
+  append(token, registration) {
+    const existing = this.registrations.get(token);
+    if (existing === undefined) {
+      this.registrations.set(token, [registration]);
+    } else {
+      existing.push(registration);
+    }
+  }
+  appendScoped(token, base) {
+    this.append(token, base);
+    const append = (next) => this.append(token, next);
+    return {
+      as(scope) {
+        if (scope === undefined)
+          return;
+        append({ ...base, scope });
+      }
+    };
+  }
+  add(...args) {
+    if (args.length === 1 || typeof args[0] !== "string") {
+      throw new TypeError("add<I>(ctor) / add<I>(factory) require the @fnioc/transformer plugin. " + 'Without it, register with an explicit token: add("my:token", MyClass) ' + 'or addFactory("my:token", (scope) => ...).');
+    }
+    const [token, ctor] = args;
+    return this.appendScoped(token, {
+      kind: "class",
+      ctor,
+      scope: undefined
+    });
+  }
+  addFactory(token, factory) {
+    return this.appendScoped(token, {
+      kind: "factory",
+      factory,
+      scope: undefined
+    });
+  }
+  addValue(...args) {
+    if (args.length === 1 || typeof args[0] !== "string") {
+      throw new TypeError("addValue<I>(value) requires the @fnioc/transformer plugin. Without it, " + 'register with an explicit token: addValue("my:token", value).');
+    }
+    const [token, value] = args;
+    this.append(token, { kind: "value", useValue: value });
+  }
+  build() {
+    return new Scope(this.rootName, undefined, this.registrations);
+  }
+}
+export {
+  signature,
+  hole,
+  forCtor,
+  defineDeps,
+  UnregisteredTokenError,
+  Scope,
+  NoSatisfiableSignatureError,
+  MissingScopeError,
+  MissingMetadataError,
+  FactoryTargetError,
+  DiError,
+  DiBuilder,
+  CircularDependencyError,
+  AsyncDisposalRequiredError
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fnioc/di",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "The ioc runtime engine: DiBuilder, scopes, resolution, captive-dependency protection, factories, and native disposal.",
   "keywords": [
     "dependency-injection",
@@ -30,18 +30,15 @@
     "dist"
   ],
   "scripts": {
-    "build": "tsc -b",
+    "build": "tsc --noEmit -p tsconfig.json && bun build.ts",
     "test": "bun test",
-    "lint": "echo 'lint: typecheck runs in build (tsc -b)' && exit 0"
-  },
-  "peerDependencies": {
-    "@fnioc/core": "^1.0.0"
-  },
-  "devDependencies": {
-    "@fnioc/core": "^1.0.0"
+    "lint": "tsc --noEmit -p tsconfig.json"
   },
   "publishConfig": {
     "access": "public",
     "provenance": true
+  },
+  "devDependencies": {
+    "@rhombus-toolkit/func": "3.5.3"
   }
 }

package/dist/builder.d.ts

@@ -1,81 +0,0 @@
-import type { Token } from "@fnioc/core";
-import { Scope } from "./scope.js";
-import type { Ctor, OverrideSpec } from "./types.js";
-/**
- * The continuation returned by `DiBuilder.add`. Carries the just-added
- * registration so `.as()` can attach its lifetime tag in place. An `.add()`
- * with no trailing `.as()` leaves the registration untagged ⇒ transient.
- *
- * `Scopes` is threaded so `.as()` only accepts a declared scope name —
- * compile-time captive-misconfiguration guard at the registration site.
- */
-export interface AddBuilder<Scopes extends string> {
-    /**
-     * Attaches the lifetime tag. Must name a declared scope.
-     *
-     * Two call shapes, by design (PRD §7):
-     *   - AUTHORED   `.as<"singleton">()` — the scope name is a TYPE argument; the
-     *     `S extends Scopes` bound is the compile-time captive-misconfiguration
-     *     guard. No value argument is passed; this form is never executed (the
-     *     transformer rewrites it before it runs).
-     *   - LOWERED    `.as("singleton")` — the transformer rewrites the type
-     *     argument to a value argument. This is the form the engine executes; the
-     *     runtime reads the tag from the value arg.
-     *
-     * `scope` is therefore OPTIONAL at the type level: the authored form supplies
-     * it as a type arg only, the lowered form as a value. A bare `.as()` with no
-     * type arg leaves `S = Scopes` and is a degenerate (untagged) call — use the
-     * type arg.
-     */
-    as<S extends Scopes>(scope?: S): void;
-}
-/**
- * The registration builder.
- *
- * `Scopes` is the user-supplied scope-name union (e.g.
- * `"singleton" | "request"`). `"transient"` is NOT a member — transient is the
- * absence of a tag, not a scope.
- *
- * @example
- * ```ts
- * const services = new DiBuilder<"singleton" | "request">();
- * services.add("pkg:ILogger", ConsoleLogger).as("singleton"); // lowered form
- * const root = services.createScope("singleton");
- * const logger = root.resolve<ILogger>("pkg:ILogger");
- * ```
- */
-export declare class DiBuilder<Scopes extends string = string> {
-    private readonly registrations;
-    /**
-     * Type-only authoring overload — the form the transformer rewrites FROM. The
-     * concrete is typed `new (...args: any[]) => I` (plain `new`, so an abstract
-     * class is rejected). At runtime the engine only ever receives the
-     * string-token form below; this signature exists purely so type-driven
-     * authoring type-checks before the transformer lowers it.
-     */
-    add<I>(ctor: new (...args: any[]) => I): AddBuilder<Scopes>;
-    /**
-     * The runtime reality — a string token bound to a concrete constructor. This
-     * is what the transformer emits and what the engine actually executes.
-     */
-    add(token: Token, ctor: Ctor): AddBuilder<Scopes>;
-    /**
-     * The plugin-less override path. Registers a token against either a
-     * `useFactory` closure (which resolves its own deps from the scope passed to
-     * it) or a `useValue` instance. The recommended mechanism for test doubles,
-     * third-party instances, and plugin-less wiring.
-     *
-     * A `useFactory` may carry an optional `tag` so the factory's result is
-     * cached at a matching ancestor scope (singleton-style); without a tag it
-     * runs on every resolve. A `useValue` is the instance itself — always the
-     * same value, no lifetime.
-     */
-    register<T>(token: Token, spec: OverrideSpec<T>): this;
-    /**
-     * Mints the root scope. The root must be a real, app-lifetime object — its
-     * name is the lifetime tag that singletons (or whatever the app's longest
-     * lifetime is) bind to.
-     */
-    createScope(rootScopeName: Scopes): Scope<Scopes>;
-}
-//# sourceMappingURL=builder.d.ts.map

package/dist/builder.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../src/builder.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEzC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,KAAK,EAEV,IAAI,EACJ,YAAY,EAGb,MAAM,YAAY,CAAC;AAEpB;;;;;;;GAOG;AACH,MAAM,WAAW,UAAU,CAAC,MAAM,SAAS,MAAM;IAC/C;;;;;;;;;;;;;;;;OAgBG;IACH,EAAE,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC;CACvC;AAED;;;;;;;;;;;;;;GAcG;AACH,qBAAa,SAAS,CAAC,MAAM,SAAS,MAAM,GAAG,MAAM;IACnD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAkC;IAEhE;;;;;;OAMG;IACI,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,GAAG,UAAU,CAAC,MAAM,CAAC;IAClE;;;OAGG;IACI,GAAG,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,GAAG,UAAU,CAAC,MAAM,CAAC;IAsCxD;;;;;;;;;;OAUG;IACI,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI;IAa7D;;;;OAIG;IACI,WAAW,CAAC,aAAa,EAAE,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;CAGzD"}