@brianmcd/di 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Brian McDaniel
+
+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.

package/README.md

@@ -0,0 +1,320 @@
+# @brianmcd/di
+
+A lightweight, type-safe dependency injection container for Node.
+
+[![npm version](https://badge.fury.io/js/%40brianmcd%2Fdi.svg)](https://www.npmjs.com/package/@brianmcd/di)
+[![CI](https://github.com/brianmcd/di/actions/workflows/ci.yml/badge.svg)](https://github.com/brianmcd/di/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Motivation
+
+Why yet another DI container for Node?
+
+I couldn't find one with the following feature set:
+
+- **No decorators**: I don't want to rely on experimental decorators, emitDecoratorMetadata, or reflect-metadata.
+- **Async factories**: When using a factory provider, the factory needs to be able to be async.
+- **Lifecycle hooks**: When providing a class, I want to be able to have async `onInit` and `onDestroy` methods so that I can do initialization and cleanup.
+- **Scoped containers**: By default, providers create singletons, but sometimes you need things to be scoped in some way (e.g. request-scoped).
+- **Type safety**: If I have a mismatch between what I've declared and what I'm using, I want a compiler error.
+
+These are the core design goals of `@brianmcd/di`. Beyond these, the goal is to keep the library small and simple.
+
+## Installation
+
+```bash
+npm install @brianmcd/di
+```
+
+## Example
+
+```typescript
+import { ContainerBuilder, OnInit, OnDestroy } from '@brianmcd/di';
+
+class UserRepository implements OnInit, OnDestroy {
+  public async onInit() {
+    // Do some async or sync initialization, if you want.
+  }
+
+  public async onDestroy() {
+    // Do some async or sync cleanup, if you want.
+  }
+
+  public async findById(id: string) {
+    return { id, name: 'Alice' };
+  }
+}
+
+class UserService {
+  static readonly deps = [UserRepository] as const;
+
+  constructor(private readonly userRepo: UserRepository) {}
+
+  public async getUser(id: string) {
+    return this.userRepo.findById(id);
+  }
+}
+
+// Build the container - dependencies are resolved automatically and registration order doesn't matter.
+const container = await new ContainerBuilder()
+  .registerClass(UserRepository)
+  .registerClass(UserService)
+  .build();
+
+// Use your services
+const userService = container.get(UserService);
+const user = await userService.getUser('123');
+console.log(user); // { id: '123', name: 'Alice' }
+
+// Cleanup - calls onDestroy in reverse order.
+await container.destroy();
+```
+
+## Overview
+
+To create a new `Container`, use the `ContainerBuilder`. The gist of it is that you register your providers with a `ContainerBuilder`, then call `.build()`. The `ContainerBuilder` takes care of instantiating your dependencies in the correct order, ensuring that dependencies are created before their dependents. If all goes well, you'll get a `Container` instance returned from `.build()`.
+
+To add a provider, call the appropriate method on the `ContainerBuilder`.
+
+There are 3 provider types you can use:
+
+1. Class providers: call `.registerClass(SomeClass)`. Class providers use constructor injection and need to have a static `deps` array that declares their dependencies. There's type safety to ensure that the `deps` array matches your constructor signature.
+
+2. Factory providers: call `.registerFactory(someFactory)`. Factories are useful for making third party libraries injectable, and they can be sync or async. Use the `defineFactory` helper function to define your factory so you get type safety around injected deps.
+
+3. Value providers: call `.registerValue(token, value)`. This is useful for making static data injectable. Use `createToken` to create the token.
+
+Note: Each token can only be registered once. Attempting to register the same token twice will throw an error. Use `override()` if you need to replace a registration (e.g., for testing).
+
+### Class Providers
+
+#### Deps Array
+
+Class providers work by declaring their dependencies in a static `deps` array.
+
+In the initial example, our `UserService` injects the `UserRepository`, so it must declare the `UserRepository` in its deps array. The deps array is how we tell the container what to inject without resorting to decorators.
+
+```typescript
+class UserService {
+  static readonly deps = [UserRepository] as const;
+
+  constructor(private readonly userRepo: UserRepository) {}
+
+  public async getUser(id: string) {
+    return this.userRepo.findById(id);
+  }
+}
+```
+
+#### Lifecycle Hooks
+
+When creating singleton services, it's common to need to do some async setup and teardown, such as connecting/disconnecting from a database or priming a cache.
+You can do this by declaring `onInit` and `onDestroy` methods in your service, both of which can be sync or async. You can optionally implement the `OnInit` and/or `OnDestroy` interfaces, but they aren't required.
+
+```typescript
+import { OnInit, OnDestroy } from '@brianmcd/di';
+
+class UserService implements OnInit {
+  static readonly deps = [UserRepository] as const;
+
+  constructor(private readonly userRepo: UserRepository) {}
+
+  public async onInit(): Promise<void> {
+    // Do some async stuff.
+  }
+
+  public async onDestroy(): Promise<void> {
+    // Do some async stuff.
+  }
+}
+```
+
+### Factory Providers
+
+Factory providers let you register a function that returns the provided instance. Factory functions are injectable, so you can use other dependencies in them. You can also register an `onDestroy` hook, which can be async or sync, to do cleanup when the Container is destroyed.
+
+Note: Unlike class providers, factories do **not** support `onInit`. If you need initialization logic, perform it in the factory function itself (which can be async).
+
+**defineFactory**
+
+Use the `defineFactory` helper function to define a factory. `defineFactory` gives you type safety between the factory's `deps` array and the factory function.
+
+```typescript
+import { Database } from 'some-third-party-lib';
+import { createToken, defineFactory } from '@brianmcd/di';
+
+export const DATABASE = createToken<Database>('DATABASE');
+
+export const dbFactory = defineFactory({
+  provide: DATABASE,
+  deps: [DB_OPTIONS] as const, // Assuming this was provided in your `ContainerBuilder`.
+  factory: (options) => new Database(options.connectionString),
+  // onDestroy.deps can reference the factory's own token (DATABASE) to receive
+  // the created instance for cleanup.
+  onDestroy: {
+    deps: [DATABASE] as const,
+    handler: async (db) => await db.destroy(),
+  },
+});
+```
+
+### Value Providers
+
+Value providers register static data. Note that values are considered "externally managed" - lifecycle hooks (`onInit`/`onDestroy`) are never called on values, even if the value object happens to have those methods.
+
+```typescript
+const CONFIG = createToken<{ value: string }>('CONFIG');
+
+const container = await new ContainerBuilder().registerValue(CONFIG, { value: 'test' }).build();
+
+expect(container.get(CONFIG)).toEqual({ value: 'test' });
+```
+
+## Scoped Containers
+
+The default behavior of the Container is to create singleton instances whose lifetime is the lifetime of the application. Sometimes, however, you have a set of providers that need to create new instances within some other scope, such as per-request. You can achieve that with Scoped Containers and defining the scope when you register your provider.
+
+### Provider Scope
+
+There are 2 scope options when registering a provider:
+
+1. Singleton (default): The provider is instantiated once when `.build()` is called on the `ContainerBuilder`.
+2. Scoped: The provider can only be created in a ScopedContainer. This is how you implement request-scoping.
+
+**Important:** Singleton providers cannot depend on Scoped providers. This constraint is validated at build time - you'll get an error if a singleton tries to inject a scoped dependency.
+
+### Using a Scoped Container
+
+It goes like this:
+
+1. Register your providers in a `ContainerBuilder`. Use `{ scope: Scope.Scoped }` for any providers that should be scoped to a ScopedContainer.
+2. Call `.build` to get your `Container`.
+3. In your application, call `container.createScope()` to get a new `ScopedContainer`. This is like a clean slate for any scoped dependencies. In express, you'd probably do this in a middleware and attach the `ScopedContainer` to the request. In GraphQL, you'd probably do this in the context creation function and attach the `ScopedContainer` to the context.
+
+`ScopedContainer`s provide a superset of the providers available in a `Container`: they can access all of the Singletons from their parent Container, plus they can instantiate Scoped providers.
+
+Within a `ScopedContainer`, Scoped dependencies are created **once** and then cached. Each `ScopedContainer` you create gets its own cache.
+
+When you're done with your `ScopedContainer`, be sure to call `.destroy()` on it to run any `onDestroy` hooks.
+
+## Creating Reusable Packages
+
+A common pattern is to break applications up into separate packages or libraries. `@brianmcd/di` supports this use case well via `ContainerBuilder`'s `merge` method.
+
+### Recipe
+
+In your library, register your providers with a `ContainerBuilder`, but don't call `.build()` on it. Export the `ContainerBuilder` instance.
+
+In your consuming application, simply call `.merge(yourLibraryContainerBuilder)`. This will merge all of the library's providers into the application's `ContainerBuilder`.
+
+Note: a `ContainerBuilder` forms a single namespace, so you can't provide the same token in your library and in your application.
+
+### Example
+
+```typescript
+// In your library package (e.g., @myorg/auth)
+import { ContainerBuilder } from '@brianmcd/di';
+
+class AuthService {
+  // ...
+}
+
+// Export the ContainerBuilder, not a built Container
+export const authModule = new ContainerBuilder().registerClass(AuthService);
+
+// In your application
+import { ContainerBuilder } from '@brianmcd/di';
+import { authModule } from '@myorg/auth';
+
+const container = await new ContainerBuilder()
+  .merge(authModule)
+  .registerClass(MyAppService)
+  .build();
+```
+
+## API Reference
+
+### ContainerBuilder
+
+Fluent builder for constructing Containers. Call `.build()` at the end to get your initialized `Container`.
+
+#### Methods
+
+- `registerValue<T>(token, value): this` - Register a plain value
+- `registerClass<T>(Class, options?): this` - Register a class with static `deps` property
+- `registerFactory<T>(provider, options?): this` - Register a factory provider
+- `merge(otherBuilder): this` - Merge registrations from another builder
+- `override<T>(token, value): this` - Override an existing registration (useful for testing)
+- `build(options?: { init?: boolean }): Promise<Container>` - Build the container. By default, also calls `init()` on the container. Set `{ init: false }` to skip automatic initialization if you need manual control over when `onInit` hooks run (useful for testing or staged startup).
+
+### Container
+
+The core DI container that holds service instances.
+
+#### Methods
+
+- `get<T>(token: Token<T>): T` - Retrieve a service by its token.
+- `init(): Promise<void>` - Initialize all services (calls `onInit` on all services, ensuring dependencies are initialized before dependents).
+- `destroy(): Promise<void>` - Destroy all services (calls `onDestroy` in reverse order, ensuring dependencies are destroyed after dependents).
+- `createScope(): ScopedContainer` - Create a new scoped container for scoped dependencies.
+
+### ScopedContainer
+
+Container for scoped instances, created via `container.createScope()`.
+
+#### Methods
+
+- `get<T>(token: Token<T>): Promise<T>` - Retrieve or create a scoped instance. Returns a Promise because scoped providers may have async factories that need to be resolved on-demand. The instance is cached for the lifetime of the `ScopedContainer`. For singleton tokens, falls back to the parent `Container`.
+- `destroy(): Promise<void>` - Run `onDestroy` on all `Scope.Scoped` instances that were created.
+
+### Helper Functions
+
+- `createToken<T>(name): TypedToken<T>` - Create a typed token for non-class dependencies.
+- `defineFactory(config): FactoryProvider` - Define a factory with type safety.
+
+### Interfaces
+
+- `OnInit` - Implement `onInit(): Promise<void> | void` for initialization logic in class providers.
+- `OnDestroy` - Implement `onDestroy(): Promise<void> | void` for cleanup logic in class providers.
+
+## Testing
+
+Use `merge()` and `override()` to easily mock dependencies:
+
+```typescript
+// Create a module with your production services
+const createAppModule = () =>
+  new ContainerBuilder()
+    .registerValue(CONFIG, productionConfig)
+    .registerFactory(databaseFactory)
+    .registerClass(UserService);
+
+// In tests, merge and override specific dependencies
+const testContainer = await new ContainerBuilder()
+  .merge(createAppModule())
+  .override(CONFIG, testConfig)
+  .override(DATABASE, mockDatabase)
+  .build();
+
+// UserService now uses mockDatabase
+const userService = testContainer.get(UserService);
+```
+
+## Type Safety
+
+The goal of this library is to provide type safety without limiting or complicating the library.
+
+To accomplish this, there are some tradeoffs to be aware of:
+
+1. The deps array is typechecked with the constructor parameters, but the compiler error will be thrown by the `ContainerBuilder` when you register the provider, not in the class. I explored ways to move the error to the class, but all of them required clumsy syntax.
+2. There is **no** _compile-time_ enforcement that the dependencies you declare in your deps array are actually provided in the `ContainerBuilder`, but you **will** get a _runtime_ error in this case as soon as you call `.build()`.
+
+So in general, there **is** compile-time type safety around dependency usage, but there **is not** compile-time type safety around dependency existence. Since you will get runtime errors as soon as you call `.build()`, this isn't a big limitation in practice, and it allows us to keep the library much simpler and more flexible.
+
+## Acknowledgements
+
+The API for this library is inspired by the dependency injection in [Nest.js](https://nestjs.com/), Angular/AngularJS, and [typed-inject](https://github.com/nicojs/typed-inject).
+
+## License
+
+MIT

package/dist/cjs/index.d.ts

@@ -0,0 +1,12 @@
+export { Container } from './lib/container.js';
+export { ContainerBuilder } from './lib/container-builder.js';
+export { ScopedContainer } from './lib/scoped-container.js';
+export type { OnDestroy, OnInit } from './lib/types/lifecycle.js';
+export type { FactoryProvider } from './lib/types/factory-provider.js';
+export type { RegistrationOptions } from './lib/types/options.js';
+export { Scope } from './lib/types/scope.js';
+export type { Scope as ScopeType } from './lib/types/scope.js';
+export type { Token, TypedToken } from './lib/types/tokens.js';
+export { createToken } from './lib/utils/create-token.js';
+export { defineFactory } from './lib/utils/define-factory.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAE5D,YAAY,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AAClE,YAAY,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AACvE,YAAY,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAClE,OAAO,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAC7C,YAAY,EAAE,KAAK,IAAI,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAC/D,YAAY,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAE/D,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC"}

package/dist/cjs/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineFactory = exports.createToken = exports.Scope = exports.ScopedContainer = exports.ContainerBuilder = exports.Container = void 0;
+var container_js_1 = require("./lib/container.js");
+Object.defineProperty(exports, "Container", { enumerable: true, get: function () { return container_js_1.Container; } });
+var container_builder_js_1 = require("./lib/container-builder.js");
+Object.defineProperty(exports, "ContainerBuilder", { enumerable: true, get: function () { return container_builder_js_1.ContainerBuilder; } });
+var scoped_container_js_1 = require("./lib/scoped-container.js");
+Object.defineProperty(exports, "ScopedContainer", { enumerable: true, get: function () { return scoped_container_js_1.ScopedContainer; } });
+var scope_js_1 = require("./lib/types/scope.js");
+Object.defineProperty(exports, "Scope", { enumerable: true, get: function () { return scope_js_1.Scope; } });
+var create_token_js_1 = require("./lib/utils/create-token.js");
+Object.defineProperty(exports, "createToken", { enumerable: true, get: function () { return create_token_js_1.createToken; } });
+var define_factory_js_1 = require("./lib/utils/define-factory.js");
+Object.defineProperty(exports, "defineFactory", { enumerable: true, get: function () { return define_factory_js_1.defineFactory; } });
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;AAAA,mDAA+C;AAAtC,yGAAA,SAAS,OAAA;AAClB,mEAA8D;AAArD,wHAAA,gBAAgB,OAAA;AACzB,iEAA4D;AAAnD,sHAAA,eAAe,OAAA;AAKxB,iDAA6C;AAApC,iGAAA,KAAK,OAAA;AAId,+DAA0D;AAAjD,8GAAA,WAAW,OAAA;AACpB,mEAA8D;AAArD,kHAAA,aAAa,OAAA"}

package/dist/cjs/lib/container-builder.d.ts

@@ -0,0 +1,76 @@
+import { Container } from './container.js';
+import type { FactoryProvider } from './types/factory-provider.js';
+import type { InjectableClass } from './types/injectable-class.js';
+import type { RegistrationOptions } from './types/options.js';
+import type { Token } from './types/tokens.js';
+/**
+ * ContainerBuilder is the class you use to configure a Container.
+ *
+ * The ContainerBuilder has 2 main responsibilities:
+ *   1. Collect all provider registrations, which can be defined in any order.
+ *     - Handled by register* methods.
+ *   2. Instantiate instances and register them in a new Container.
+ *     - Handled by `.build()`.
+ *
+ * The ContainerBuilder does a topological sort to ensure that instances are created and destroyed
+ * in the correct order (e.g. all of a providers dependencies must be created before that
+ * provider's instance can be created, and destruction needs to happen in the opposite order).
+ */
+export declare class ContainerBuilder {
+    private readonly registrations;
+    /**
+     * Register a static value.
+     */
+    registerValue<T>(token: Token<T>, value: T): this;
+    /**
+     * Register a class with static deps property.
+     * Dependencies are resolved automatically during build().
+     * Type safety between the deps array and constructor params is enforced at this method.
+     */
+    registerClass<T, Deps extends readonly Token<any>[]>(Class: InjectableClass<T, Deps>, options?: RegistrationOptions): this;
+    /**
+     * Register a factory provider, which can be async or sync and can inject other dependencies.
+     */
+    registerFactory<T, Deps extends readonly Token<any>[], DestroyDeps extends readonly Token<any>[]>(provider: FactoryProvider<T, Deps, DestroyDeps>, options?: RegistrationOptions): this;
+    /**
+     * Merge providers from another container.
+     *
+     * This is useful for creating standalone packages/libraries that export a ContainerBuilder.
+     * You can use `merge` to bring these standalone packages together into a single Container.
+     */
+    merge(other: ContainerBuilder): this;
+    /**
+     * Override an existing provider with a value; intended for mocking during tests.
+     */
+    override<T>(token: Token<T>, value: T): this;
+    /**
+     * Build the container - topologically sorts providers and instantiates singletons.
+     * Scoped providers are validated but not instantiated - they're stored for later use in Scopes.
+     * By default, also initializes the container (calls onInit on all services).
+     */
+    build(options?: {
+        init?: boolean;
+    }): Promise<Container>;
+    /**
+     * Topologically sort providers by their dependencies using Kahn's algorithm.
+     *
+     * This ensures that dependent providers are created and initialized BEFORE the providers that
+     * depend on them, and that dependent providers are destroyed AFTER providers that depend on them.
+     *
+     * Also validates that singleton providers do not depend on scoped providers.
+     */
+    private topologicalSort;
+    /**
+     * Find a cycle path using DFS with coloring.
+     * Returns the cycle as an array of tokens ending with the repeated token.
+     */
+    private findCyclePath;
+    private addRegistration;
+    private isScoped;
+    private isSingleton;
+    /**
+     * Resolve dependencies from the instances map.
+     */
+    private resolveDeps;
+}
+//# sourceMappingURL=container-builder.d.ts.map

package/dist/cjs/lib/container-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"container-builder.d.ts","sourceRoot":"","sources":["../../../src/lib/container-builder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAkB,MAAM,gBAAgB,CAAC;AAC3D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAE9D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAG/C;;;;;;;;;;;;GAYG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAgD;IAE9E;;OAEG;IACI,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAKxD;;;;OAIG;IACI,aAAa,CAAC,CAAC,EAAE,IAAI,SAAS,SAAS,KAAK,CAAC,GAAG,CAAC,EAAE,EACxD,KAAK,EAAE,eAAe,CAAC,CAAC,EAAE,IAAI,CAAC,EAC/B,OAAO,CAAC,EAAE,mBAAmB,GAC5B,IAAI;IAYP;;OAEG;IACI,eAAe,CACpB,CAAC,EACD,IAAI,SAAS,SAAS,KAAK,CAAC,GAAG,CAAC,EAAE,EAClC,WAAW,SAAS,SAAS,KAAK,CAAC,GAAG,CAAC,EAAE,EACzC,QAAQ,EAAE,eAAe,CAAC,CAAC,EAAE,IAAI,EAAE,WAAW,CAAC,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,IAAI;IAYvF;;;;;OAKG;IACI,KAAK,CAAC,KAAK,EAAE,gBAAgB,GAAG,IAAI;IAO3C;;OAEG;IACI,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAQnD;;;;OAIG;IACU,KAAK,CAAC,OAAO,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,SAAS,CAAC;IA+DpE;;;;;;;OAOG;IACH,OAAO,CAAC,eAAe;IA+EvB;;;OAGG;IACH,OAAO,CAAC,aAAa;IAmDrB,OAAO,CAAC,eAAe;IAOvB,OAAO,CAAC,QAAQ;IAIhB,OAAO,CAAC,WAAW;IAInB;;OAEG;IACH,OAAO,CAAC,WAAW;CAYpB"}