@doweljs/core 0.0.0-stage → 0.1.0

package/LICENSE

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

@@ -1,3 +1,259 @@
-# Temporary Holding Version
+# @doweljs/core
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Type-complete dependency injection for TypeScript.
+
+- **The compiler checks completeness.** A container can't be built while a slot it needs is unbound, can't be opened without its scope's values, and can't resolve a node it can't see. These are type errors that name what is missing and who needs it.
+- **Async only at the edges.** `build()` and `open()` return promises; `get()` never does. Independent async services start concurrently, and a failed build disposes what it already created.
+- **Scope is inferred.** Depend on a request-scoped slot and your service lives per request too. Capturing a shorter-lived value in a longer-lived service is a compile error.
+- **Ownership is explicit.** A service disposes exactly the resources it adopts, and a resource can't have two owners.
+- **Child work is injectable.** An _execution_ hands a service a typed runner for jobs and message handlers, each run in its own short-lived container.
+- **No decorators, reflection or proxies.** Plain values, about 9 KB minified and gzipped, and a `get()` of about 40–50 ns.
+- **Hot replaceable.** With [`@doweljs/vite`](../vite), editing a service swaps it inside running containers.
+
+```ts
+import { container, service, slot } from '@doweljs/core'
+
+const Logger = slot('Logger')<{ info(message: string): void }>()
+
+const Config = service('Config', () => ({ dbUrl: process.env.DATABASE_URL! }))
+const Db = service('Db', { config: Config }, async ({ config }, ctx) =>
+	ctx.adopt(await connect(config.dbUrl), (client) => client.close()),
+)
+const Users = service('Users', { db: Db, log: Logger }, ({ db, log }) => ({
+	list: () => {
+		log.info('listing users')
+		return db.query('select * from users')
+	},
+}))
+
+const app = await container().provide(Users).bind(Logger, { info: console.log }).build()
+
+app.get(Users).list()
+await app.dispose()
+```
+
+Remove `.bind(Logger, …)` and `build()` stops being callable. Its type becomes `MissingBindings<{ Logger: "Users" }>`: the missing slot, and what needs it.
+
+## Concepts
+
+### Slots
+
+A slot is a named gap the container fills: a name and a type, with no implementation. Slots are the only open points in a graph; everything else is wired automatically.
+
+```ts
+// Bound once per container.
+const Logger = slot('Logger')<LoggerApi>()
+
+// Supplied each time a container for PerRequest opens.
+const PerRequest = scope('request')
+const Request = slot('Request', { scope: PerRequest })<IncomingRequest>()
+
+// Collects contributions into a readonly array.
+const Middleware = slot('Middleware', { many: true })<Middleware>()
+```
+
+Names must be unique within a container. The type system and hot replacement both identify nodes by name.
+
+### Services
+
+A service lists its dependencies as values. Its requirements, its scope and whether it is async are all inferred from them.
+
+```ts
+const Users = service(
+	'Users',
+	{ db: Db, log: Logger, metrics: optional(Metrics) },
+	({ db, log, metrics }, ctx) => {
+		ctx.defer(() => log.info('Users disposed'))
+		return {
+			list() {
+				metrics?.increment('users.list')
+				return db.query('select * from users')
+			},
+		}
+	},
+)
+```
+
+The service's type carries its whole subgraph. Hover `Users` to see the record the compiler reasons about:
+
+```ts
+Service<UsersApi, {
+	name: 'Users'; scope: 'root'; above: never
+	graph: {
+		Users:   { kind: 'service'; scope: 'root'; deps: 'Db' | 'Logger' | 'Metrics'; optional: 'Metrics'; … }
+		Db:      { kind: 'service'; scope: 'root'; deps: 'Config'; … }
+		Config:  { kind: 'service'; scope: 'root'; deps: never; … }
+		Logger:  { kind: 'slot';     scope: 'root'; … }
+		Metrics: { kind: 'slot';     scope: 'root'; … }
+	}
+}>
+```
+
+A service has one instance per container of its scope: one in the app's container for root-scope services, one in each opened container for scoped ones. There are no other lifetimes.
+
+The only option is `scope`. It places a service deeper than its dependencies imply, such as one unit of work per request although it only needs the database. Placing it shallower is a compile error.
+
+#### Resources and disposal
+
+The factory's context mirrors `AsyncDisposableStack`:
+
+- `ctx.use(resource)` adopts a `Disposable` or `AsyncDisposable` and returns it.
+- `ctx.adopt(value, dispose)` adopts anything else, with the function that disposes it.
+- `ctx.defer(fn)` runs a callback at disposal.
+- `ctx.signal` aborts when the instance's disposal starts, even if its factory is still running. Pass it to slow startup work: `connect(url, { signal: ctx.signal })`.
+
+Only what a factory adopts is disposed. Returning a disposable value doesn't hand it to the container, and adopting a value another service already owns is an error.
+
+Disposal runs last-in-first-out, inner scopes before outer ones, one scope at a time. It waits for factories still running, so their instances are disposed before what they depend on. A factory that ignores its signal and never settles keeps disposal waiting.
+
+### Containers
+
+```ts
+const app = await container()
+	.provide(Users, Mailer) // services; their dependencies are discovered
+	.bind(Logger, PinoLogger) // a slot to a service…
+	.bind(Config, { port: 3000 }) // …or to a value
+	.contribute(Middleware, Cors) // one item of a multi-binding
+	.with(infrastructure) // apply a composition function
+	.override(Db, fakeDb) // replace a node in the graph (tests)
+	.build()
+```
+
+What you `provide()` are the container's roots. Everything they reach is created at `build()`, and nothing else is. A binding alone activates nothing: `bind(Cache, RedisCache)` only takes effect once something reachable depends on `Cache`, or `Cache` itself is provided.
+
+If a factory fails, `build()` disposes what it already created, then rejects. Failures during that cleanup are attached to the original error as an `AggregateError`.
+
+Builders are persistent: every call returns a new builder, so a base composition can be shared between tests or environments. Write reusable composition functions generic in the state, so they apply anywhere in a chain:
+
+```ts
+const infrastructure = <S extends ContainerState>(b: ContainerBuilder<S>) =>
+	b.bind(Logger, ConsoleLogger).bind(Database, SqlDatabase)
+
+container().with(infrastructure).bind(Config, config).provide(Checkout).build()
+```
+
+`get()` is typed against what the container can reach:
+
+```ts
+app.get(Users) // UsersApi
+app.get(Mailer) // error: NotProvided<"Mailer">
+app.get(Current) // error: NotVisible<"Current", "request">
+```
+
+Overrides are exact. Override `Db` with a fake, and nothing that only `Db` needed is required any more; `get(Db)` returns the fake.
+
+### Scopes and containers
+
+A scope is a lifetime shorter than the app's, such as one request. `open()` creates a child container for a scope, and you pass the scope's slots their values as bindings. The graph decides which values are required, so a missing one is a compile error naming the slot and what needs it.
+
+```ts
+await using request = await app.open(PerRequest, bind(Request, req))
+request.get(CurrentUser) // created once per opened container
+request.get(Users) // root-scope services are shared
+```
+
+**Always dispose what `open()` returns**, with `await using` or in a `finally`. A container keeps every container opened from it until they are disposed, so that disposing the app can still close them. One dropped without being disposed stays in memory, with everything it created, until its parent is disposed.
+
+Everything in a scope is created when its container opens, not when first resolved; that is what keeps `get()` synchronous. Keep factories in short-lived scopes cheap, and free of side effects a request may not need.
+
+Scopes nest. Declare them as values, give slots a scope, and open containers one scope at a time:
+
+```ts
+export const Session = scope('session')
+export const Request = scope('request', Session)
+
+const Sess = slot('Sess', { scope: Session })<SessionData>()
+const Req = slot('Req', { scope: Request })<IncomingRequest>()
+
+const Cart = service('Cart', { sess: Sess }, …)                  // lives in 'session'
+const Handler = service('Handler', { req: Req, cart: Cart }, …)  // lives in 'request'
+
+await using session = await app.open(Session, bind(Sess, data))
+await using request = await session.open(Request, bind(Req, req))
+request.get(Handler)   // sees request, session and root
+session.get(Handler)   // error: NotVisible<"Handler", "request">
+app.open(Request, …)   // error: NotChildScope<"request", "root">
+```
+
+A service lives in the deepest scope among its dependencies. Dependencies on different branches, such as a request-scope slot and a job-scope slot, are rejected where the service is declared.
+
+Scopes are compared by lineage, their names from the root down, so a different scope that happens to share a name can't be opened in its place.
+
+### Executions
+
+Work a service starts and finishes on its own, such as a job, a message handler or a connection, is declared as an execution. It names a scope, an entry node in that scope or above, and the inputs each run supplies. Services depend on it like anything else and receive a runner.
+
+```ts
+const Job = scope('job')
+const JobInput = slot('JobInput', { scope: Job })<{ id: string }>()
+const JobRunner = service('JobRunner', { input: JobInput, db: Db }, ({ input, db }) => ({
+	run: () => db.process(input.id),
+}))
+
+const RunJob = execution('RunJob', { scope: Job, entry: JobRunner, inputs: { job: JobInput } })
+
+const Scheduler = service('Scheduler', { runJob: RunJob }, ({ runJob }) => ({
+	schedule: (id: string) => runJob({ job: { id } }, (runner) => runner.run()),
+}))
+```
+
+Each call to the runner:
+
+1. opens a container for the execution's scope, with the inputs it was given;
+2. resolves the entry and hands it to the body;
+3. disposes the container once the body settles, whether it returned or threw.
+
+The runner takes an object with a value for each input, typed from `inputs`. An execution without inputs takes only the body. `build()` isn't callable while the inputs don't cover what the entry needs: `IncompleteExecutions<{ RunJob: "Other" }>`.
+
+A run belongs to the container its runner was resolved from. Disposing that container aborts the `signal` the body receives as its second argument, as in `runJob({ job }, (runner, { signal }) => runner.run(signal))`. It then waits for the body to settle before disposing the run's container and its own instances, so a body never sees what it uses closed beneath it. A body that ignores the signal keeps disposal waiting.
+
+### Multi-bindings
+
+```ts
+const Middleware = slot('Middleware', { many: true })<Middleware>()
+const Server = service('Server', { middleware: Middleware }, ({ middleware }) =>
+	createServer(middleware),
+)
+
+container().provide(Server).contribute(Middleware, Auth).contribute(Middleware, Cors).build()
+```
+
+Contributions resolve to a readonly array, in the order they were contributed. A multi-binding never needs binding: with no contributions it resolves to `[]`. Contributing a service brings that service's own requirements into the container. `override()` on a multi-binding replaces the whole set.
+
+### Introspection
+
+`app.inspect()` and `request.inspect()` describe every node: its scope, dependencies, binding and instance status. [`@doweljs/devtools`](../devtools) shows the same, live, on the Vite dev server.
+
+## Errors
+
+Runtime errors are `DowelError`s with a stable `code`, such as `UNBOUND_SLOT`, `CAPTIVE_DEPENDENCY`, `CYCLE`, `INVALID_SCOPE` or `DISPOSED`. Messages include the dependency path:
+
+```text
+Slot 'Logger' is not bound. Needed by Api → Users → Logger.
+```
+
+Well-typed code rarely reaches them. They are a safety net for `any` and for dynamic composition.
+
+## Hot replacement
+
+`@doweljs/core/hot` lets a build tool re-register a module's declarations each time the module is re-evaluated; [`@doweljs/vite`](../vite) wires it up.
+
+Nodes are matched by name, and a name belongs to the module that first declared it; another module declaring it is rejected. Invalidation is per module and conservative: a factory may close over anything in its module, so every declaration in a re-evaluated module counts as changed.
+
+For each live container, an update:
+
+1. compiles the latest declarations and initializes them as a _proposal_, while the current generation keeps running. Root-scope instances from untouched modules, whose dependencies didn't change, are carried over;
+2. commits the proposal once it is up. Opened containers and running executions are disposed (running executions have their `signal` aborted and are waited for), and so are the instances it replaced;
+3. leaves stale references, held by modules that weren't re-evaluated, working.
+
+The next update doesn't wait for that teardown, so a run that ignores its signal can't hold up later reloads.
+
+A proposal that fails to compile or initialize is discarded. The container stays on its last good generation, and `snapshot()` reports it as failed until a later update succeeds.
+
+## Design notes
+
+- **Cycles can't be declared.** Dependencies are values, and a `const` can't reference a later one. A cycle can only come from binding a slot to a service that depends on it, from `override()`, or from an execution whose entry reaches the service that runs it. All three are detected at build; the first two are also type errors, which `build()` reports.
+- **Type-level cost.** The model is checked against a generated graph of 300 services in ten layers, 144 of them reachable from the roots (`test/types/scale.test-d.ts`). Checking the whole package takes about five seconds on TypeScript 5.9 and four to eight on TypeScript 7, mostly in that test. Builder types stay short because each step is an interface instantiation, not an expanded record.
+- **TypeScript 5.9 or later.** Earlier versions, checked down to 5.5, accept small graphs but stop with "type instantiation is excessively deep" on one that size.
+- **Declaration emit.** Builder steps over a generic state stay named (`Provide<Provide<S, A>, B>`) instead of expanding the merged graph, so libraries can export generic composition functions with declarations. The types an exported service, builder or container is inferred from are exported for the same reason.
+- **Literal types.** TypeScript keeps the literal return types of nested functions during generic inference: `service('S', () => ({ kind: () => 'a' }))` infers `() => "a"`. Annotate the return type when you want a wider one. This is how inference works, not something dowel does.

package/dist/api.d.ts

@@ -0,0 +1,145 @@
+/** The public interfaces the runtime implements. */
+import type { DeclaredScope } from './model/checks.ts';
+import type { AnyBinding, AnyExecution, AnyScope, AnyService, AnySlot, Binding, RootMeta, ScopeMeta, ServiceMeta, Slot, SlotMeta } from './model/declarations.ts';
+import type { CompositionIssues, IncompleteExecutions, InputsBoundAtBuild, MissingBindings } from './model/diagnostics.ts';
+import type { NeededBy } from './model/graph.ts';
+import type { BindingMetaOf, Impl, ImplAt, MetaOf } from './model/infer.ts';
+import type { BoundExecutionInputs, BoundNames, ChildCheck, ContainerState, GetResult, Issues, KnownLength, Missing, MissingExecutionInputs, OpenCheck, Overridable, Override, Providable, Provide, ProvideAll, Resolvable, TargetOf } from './model/state.ts';
+import type { Simplify } from './model/util.ts';
+/**
+ * The context handed to every factory. It mirrors `AsyncDisposableStack`:
+ * a factory owns what it adopts, and nothing else.
+ */
+export interface ServiceContext {
+    /**
+     * Adopt a resource that implements `Symbol.dispose` or `Symbol.asyncDispose`
+     * and return it. It is disposed with the instance.
+     *
+     * ```ts
+     * const client = ctx.use(await connect(url))
+     * ```
+     */
+    use<T extends Disposable | AsyncDisposable>(resource: T): T;
+    /** Adopt any value with an explicit disposer and return it. */
+    adopt<T>(resource: T, dispose: (resource: T) => void | PromiseLike<void>): T;
+    /** Run a callback when the instance is disposed. */
+    defer(dispose: () => void | PromiseLike<void>): void;
+    /**
+     * Aborted when disposal of the instance starts, or of its owner while the
+     * factory is still running. Disposal waits for a running factory, so pass
+     * this to slow startup work (connects, fetches) to let it stop promptly.
+     *
+     * ```ts
+     * const client = ctx.use(await connect(url, { signal: ctx.signal }))
+     * ```
+     */
+    readonly signal: AbortSignal;
+}
+/** What a run's body receives besides the entry. */
+export interface RunContext {
+    /**
+     * Aborted when the container the runner was resolved from is disposed while
+     * the body runs. Disposal waits for the body to settle, so a long-running
+     * body should stop when this aborts.
+     */
+    readonly signal: AbortSignal;
+}
+/** How a node's value arrives, as reported by `inspect()`. */
+export type NodeBinding = {
+    readonly kind: 'service';
+    readonly name: string;
+} | {
+    readonly kind: 'value';
+} | {
+    readonly kind: 'scope';
+} | {
+    readonly kind: 'absent';
+} | {
+    readonly kind: 'many';
+    readonly items: readonly ({
+        readonly kind: 'service';
+        readonly name: string;
+    } | {
+        readonly kind: 'value';
+    })[];
+};
+/** A node of a built container, as reported by `inspect()`. */
+export interface NodeInfo {
+    readonly name: string;
+    readonly kind: 'service' | 'slot' | 'execution';
+    readonly scope: string;
+    readonly many: boolean;
+    readonly deps: readonly {
+        readonly key: string;
+        readonly name: string;
+    }[];
+    readonly binding: NodeBinding | null;
+    /** Instance state for cached nodes visible from here; `null` otherwise. */
+    readonly status: 'idle' | 'pending' | 'ready' | null;
+}
+/**
+ * An immutable description of a container. Every method returns a new
+ * builder, so partial compositions can be shared and extended freely.
+ */
+export interface ContainerBuilder<S extends ContainerState> {
+    /**
+     * Add roots and bindings. Services, executions and slots given here are
+     * activated at `build()` together with everything they reach; bindings
+     * only make implementations available and are activated when reached.
+     */
+    provide<const I extends readonly Providable[]>(...items: I & KnownLength<I>): ContainerBuilder<ProvideAll<S, I>>;
+    /** Shorthand for `provide(bind(slot, impl))`. */
+    bind<T, TM extends SlotMeta, const I extends Impl<T, TM>>(slot: Slot<T, TM>, impl: I): ContainerBuilder<Provide<S, Binding<T, BindingMetaOf<TM, I>>>>;
+    /** Contribute one item to a multi-binding slot. The same as `bind()` for such slots, named for clarity. */
+    contribute<T, TM extends SlotMeta & {
+        readonly many: true;
+    }, const I extends Impl<T, TM>>(slot: Slot<T, TM>, impl: I): ContainerBuilder<Provide<S, Binding<T, BindingMetaOf<TM, I>>>>;
+    /**
+     * Replace a node in the graph. Dependents receive the replacement; the
+     * original is never instantiated, and nothing that only it needed is
+     * required any more. Intended for tests and environment specific swaps.
+     * A service must be reachable from what is provided and a slot must be
+     * bound by the time `build()` is called, in any order.
+     */
+    override<T, M extends ServiceMeta | SlotMeta, const I extends NoInfer<T> | ImplAt<T, M>>(target: Overridable<T, M>, impl: I): ContainerBuilder<Override<S, TargetOf<M>, I>>;
+    /**
+     * Apply a reusable composition function. Write it generic in the state so
+     * it applies at any point of a chain:
+     *
+     * ```ts
+     * const infra = <S extends ContainerState>(b: ContainerBuilder<S>) => b.bind(Logger, Pino).provide(Db)
+     * container().with(infra).provide(Users).build()
+     * ```
+     */
+    with<R>(compose: (builder: this) => R): R;
+    /**
+     * Build the container: activate every root and what it reaches, awaiting
+     * async factories. Only callable once the composition has no issues,
+     * every reachable root-scope slot is bound and every execution's inputs
+     * are complete. If construction fails, everything created is disposed
+     * before the returned promise rejects.
+     */
+    readonly build: [Issues<S>] extends [never] ? [Missing<S>] extends [never] ? [keyof MissingExecutionInputs<S>] extends [never] ? [keyof BoundExecutionInputs<S>] extends [never] ? () => Promise<Container<S>> : InputsBoundAtBuild<Simplify<BoundExecutionInputs<S>>> : IncompleteExecutions<Simplify<MissingExecutionInputs<S>>> : MissingBindings<Simplify<NeededBy<S['graph'], Missing<S>>>> : CompositionIssues<Issues<S>>;
+}
+/**
+ * A container: the one `build()` returns, for the `root` scope, or one opened
+ * from it for a child scope with `open()`. Each sees its own scope and every
+ * scope above it.
+ */
+export interface Container<S extends ContainerState = ContainerState, Current extends ScopeMeta = RootMeta, 
+/** Slots supplied to `open()` for this container and those it was opened from. */
+Supplied extends string = never> extends AsyncDisposable {
+    /** Resolve a node visible from this scope. Always synchronous. */
+    get<N extends AnyService | AnySlot | AnyExecution>(node: Resolvable<N, S, Current>): GetResult<N, S, Supplied>;
+    /**
+     * Open a container for a child scope. Required slots of that scope must be
+     * supplied as value bindings. Everything in that scope is
+     * initialized before the promise resolves; on failure it is disposed first.
+     */
+    open<Sc extends AnyScope, const B extends readonly AnyBinding[]>(scope: Sc & DeclaredScope<Sc> & ChildCheck<Current, Sc> & OpenCheck<S, MetaOf<Sc>['name'], B>, ...bindings: B): Promise<Container<S, MetaOf<Sc>, Supplied | BoundNames<B>>>;
+    /** Describe every node in the graph and the state of instances visible from here. */
+    inspect(): readonly NodeInfo[];
+    /** Dispose every container and execution opened from here, then every instance, in reverse creation order. */
+    dispose(): Promise<void>;
+}
+//# sourceMappingURL=api.d.ts.map

package/dist/api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../src/api.ts"],"names":[],"mappings":"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"}

package/dist/api.js

@@ -0,0 +1,3 @@
+/** The public interfaces the runtime implements. */
+export {};
+//# sourceMappingURL=api.js.map

package/dist/api.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.js","sourceRoot":"","sources":["../src/api.ts"],"names":[],"mappings":"AAAA,oDAAoD"}

package/dist/compile/compile.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Turns a composition (roots, bindings, contributions and overrides) into
+ * plans.
+ *
+ * Compilation walks the graph from the roots, validates it (unbound slots,
+ * captive dependencies, cycles, duplicate names, scope mismatches, execution
+ * inputs) and produces one `Plan` per reached node, allocating each cached
+ * plan a cell in the stores of its scope. Bindings that nothing reaches are
+ * never compiled, so they never activate.
+ */
+import { type DeclaredNode, type ImplNode, type ScopeNode, type ServiceNode, type SlotNode } from '../nodes/node.ts';
+import type { Compiled } from './plan.ts';
+/** Everything a builder accumulates. Immutable once a container is built from it. */
+export interface Composition {
+    /** Services, executions and slots activation starts from. */
+    readonly roots: readonly DeclaredNode[];
+    readonly bindings: ReadonlyMap<SlotNode, ImplNode>;
+    readonly contributions: ReadonlyMap<SlotNode, readonly ImplNode[]>;
+    readonly overrides: ReadonlyMap<SlotNode | ServiceNode, ImplNode>;
+}
+/** Maps a node to the one that should stand in for it (used by hot replacement). */
+export type Canonicalize = <N extends DeclaredNode | ScopeNode>(node: N) => N;
+export interface CompileOptions {
+    readonly canonical?: Canonicalize;
+}
+export declare function compile(composition: Composition, options?: CompileOptions): Compiled;
+//# sourceMappingURL=compile.d.ts.map

package/dist/compile/compile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../src/compile/compile.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAKH,OAAO,EACN,KAAK,YAAY,EAEjB,KAAK,QAAQ,EAEb,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,QAAQ,EACb,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EAGX,QAAQ,EAYR,MAAM,WAAW,CAAA;AAElB,qFAAqF;AACrF,MAAM,WAAW,WAAW;IAC3B,6DAA6D;IAC7D,QAAQ,CAAC,KAAK,EAAE,SAAS,YAAY,EAAE,CAAA;IACvC,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAA;IAClD,QAAQ,CAAC,aAAa,EAAE,WAAW,CAAC,QAAQ,EAAE,SAAS,QAAQ,EAAE,CAAC,CAAA;IAClE,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC,QAAQ,GAAG,WAAW,EAAE,QAAQ,CAAC,CAAA;CACjE;AAED,oFAAoF;AACpF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,SAAS,YAAY,GAAG,SAAS,EAAE,IAAI,EAAE,CAAC,KAAK,CAAC,CAAA;AAE7E,MAAM,WAAW,cAAc;IAC9B,QAAQ,CAAC,SAAS,CAAC,EAAE,YAAY,CAAA;CACjC;AAYD,wBAAgB,OAAO,CAAC,WAAW,EAAE,WAAW,EAAE,OAAO,GAAE,cAAmB,GAAG,QAAQ,CAExF"}