@typed/app 1.0.0-beta.1

package/README.md

@@ -0,0 +1,166 @@
+# @typed/app
+
+> **Beta:** This package is in beta; APIs may change.
+
+`@typed/app` provides **virtual module plugins** for the router and HttpApi stacks: `router:./path` and `api:./path` imports that generate typed route matchers and API clients from source. It also exports `createTypeInfoApiSessionForApp` for TypeInfo-backed type-checking and `defineApiHandler` for typed HttpApi endpoint contracts.
+
+## Purpose
+
+Typed-smol apps get typed routes and APIs from convention-based source without manual wiring. You place route and endpoint files in directories, follow the file conventions, and import `router:./routes` or `api:./endpoints` to receive generated Matcher and Client modules. The plugins are configured in `vmc.config.ts` and consumed by `typedVitePlugin`, vmc (virtual-modules-compiler), or the TS plugin.
+
+## How to use
+
+1. Add the plugins to `vmc.config.ts` (see Configuration below).
+2. Import `router:./routes` and `api:./endpoints` in your app code to use the generated Matcher and Client.
+3. (Optional) Provide `createTypeInfoApiSessionForApp` to `typedVitePlugin` for structural type-checking of route and endpoint contracts.
+
+## Architecture
+
+```mermaid
+flowchart LR
+  subgraph config [vmc.config.ts]
+    VMC[plugins array]
+  end
+
+  subgraph consumers [Consumers]
+    Vite[typedVitePlugin]
+    VMC2[vmc]
+    TS[TS plugin]
+  end
+
+  subgraph plugins [@typed/app plugins]
+    Router[Router VM plugin]
+    HttpApi[HttpApi VM plugin]
+  end
+
+  subgraph imports [App imports]
+    RImport["router:./routes"]
+    ApiImport["api:./endpoints"]
+  end
+
+  subgraph output [Generated output]
+    Matcher[Matcher source]
+    Client[Client + OpenAPI]
+  end
+
+  VMC --> Router
+  VMC --> HttpApi
+  Router --> Vite
+  HttpApi --> Vite
+  Vite --> RImport
+  Vite --> ApiImport
+  RImport --> Matcher
+  ApiImport --> Client
+```
+
+## Companion file conventions
+
+### Router plugin
+
+| Pattern | Role | Behavior |
+| ------- | ---- | -------- |
+| `*.guard.ts` | Sibling | Guard for this route |
+| `*.dependencies.ts` | Sibling | Dependencies for this route |
+| `*.layout.ts` | Sibling | Layout wrapper |
+| `*.catch.ts` | Sibling | Error catch handler |
+| `_guard.ts` | Directory | Guard inherited by children |
+| `_dependencies.ts` | Directory | Dependencies inherited by children |
+| `_layout.ts` | Directory | Layout inherited by children |
+| `_catch.ts` | Directory | Catch inherited by children |
+
+Each route file must export `route` and exactly one of `handler`, `template`, or `default`.
+
+### HttpApi plugin
+
+| Pattern | Role | Behavior |
+| ------- | ---- | -------- |
+| `_api.ts` | API root | Top-level API defaults (name, prefix, openapi) |
+| `_group.ts` | Group override | Group name, prefix, dependencies, middlewares |
+| `(pathless)/` | Pathless dir | Organizational only, no path segment |
+| `*.name.ts` | Endpoint companion | Override endpoint name |
+| `*.dependencies.ts` | Endpoint companion | Endpoint dependencies |
+| `*.middlewares.ts` | Endpoint companion | Endpoint middlewares |
+| `_dependencies.ts` | Directory | Inherited dependencies |
+| `_middlewares.ts` | Directory | Inherited middlewares |
+
+Each endpoint file must export `route`, `method`, and `handler`. See [router-virtual-module-plugin spec](../../.docs/specs/router-virtual-module-plugin/spec.md) and [httpapi-virtual-module-plugin spec](../../.docs/specs/httpapi-virtual-module-plugin/spec.md) for full details.
+
+## Dependencies
+
+- `effect`
+- `@typed/router`
+- `@typed/virtual-modules`
+
+Peer: `typescript`.
+
+## Installation
+
+```bash
+pnpm add @typed/app @typed/router @typed/virtual-modules
+```
+
+## Configuration
+
+Configure plugins in `vmc.config.ts` (used by vmc, the TS plugin, and typedVitePlugin):
+
+```ts
+// vmc.config.ts
+import { createRouterVirtualModulePlugin, createHttpApiVirtualModulePlugin } from "@typed/app";
+
+export default {
+  plugins: [
+    createRouterVirtualModulePlugin(),
+    createHttpApiVirtualModulePlugin(),
+  ],
+};
+```
+
+## Example
+
+```ts
+// Import generated router matcher
+import { Matcher } from "router:./routes";
+
+// Import generated API client
+import { Client } from "api:./endpoints";
+
+// Define typed handler
+import { defineApiHandler } from "@typed/app";
+import { Route } from "@typed/router";
+import * as Schema from "effect/Schema";
+
+const handler = defineApiHandler(
+  Route.Parse("/todos/:id"),
+  "GET",
+  { success: Schema.Struct({ id: Schema.String }) }
+)(({ path }) => Effect.succeed({ id: path.id }));
+```
+
+## API overview
+
+- **Router VM plugin** — `createRouterVirtualModulePlugin(options)` — virtual `router:./routes` imports; scans route files, emits typed Matcher source.
+- **HttpApi VM plugin** — `createHttpApiVirtualModulePlugin(options)` — virtual `api:./endpoints` imports; scans API files, emits typed Api + Client + OpenAPI.
+- **TypeInfo session** — `createTypeInfoApiSessionForApp({ ts, program })` — session with router + HttpApi type targets; use with `typedVitePlugin` or vmc.
+- **API handler helper** — `defineApiHandler(route, method, schemas?)(handler)` — typed handler with path/query/headers/body; success/error schemas for responses.
+- **Parsing helpers** — `parseRouterVirtualModuleId`, `parseHttpApiVirtualModuleId`; `resolveRouterTargetDirectory`, `resolveHttpApiTargetDirectory`.
+- **Type target specs** — `ROUTER_TYPE_TARGET_SPECS`, `HTTPAPI_TYPE_TARGET_SPECS`; `APP_TYPE_TARGET_BOOTSTRAP_CONTENT`.
+
+## API reference
+
+### RouterVirtualModulePluginOptions
+
+| Property | Type | Default | Description |
+| -------- | ---- | ------- | ----------- |
+| `prefix` | `string` | `"router:"` | Virtual module ID prefix. |
+| `name` | `string` | `"router-virtual-module"` | Plugin name for diagnostics. |
+
+### HttpApiVirtualModulePluginOptions
+
+| Property | Type | Default | Description |
+| -------- | ---- | ------- | ----------- |
+| `prefix` | `string` | `"api:"` | Virtual module ID prefix. |
+| `name` | `string` | `"httpapi-virtual-module"` | Plugin name for diagnostics. |
+
+### createTypeInfoApiSessionForApp
+
+Requires a TypeScript `program` that includes imports from canonical type target modules. If the program has no such imports, write `APP_TYPE_TARGET_BOOTSTRAP_CONTENT` to a file and include it in `rootNames`.

package/dist/HttpApiVirtualModulePlugin.d.ts

@@ -0,0 +1,26 @@
+import type { VirtualModulePlugin } from "@typed/virtual-modules";
+export interface HttpApiVirtualModulePluginOptions {
+    readonly prefix?: string;
+    readonly name?: string;
+}
+export type ParseHttpApiVirtualModuleIdResult = {
+    readonly ok: true;
+    readonly relativeDirectory: string;
+} | {
+    readonly ok: false;
+    readonly reason: string;
+};
+export declare function parseHttpApiVirtualModuleId(id: string, prefix?: string): ParseHttpApiVirtualModuleIdResult;
+export type ResolveHttpApiTargetDirectoryResult = {
+    readonly ok: true;
+    readonly targetDirectory: string;
+} | {
+    readonly ok: false;
+    readonly reason: string;
+};
+export declare function resolveHttpApiTargetDirectory(id: string, importer: string, prefix?: string): ResolveHttpApiTargetDirectoryResult;
+/**
+ * Creates the HttpApi virtual module plugin with sync shouldResolve and build behavior.
+ */
+export declare const createHttpApiVirtualModulePlugin: (options?: HttpApiVirtualModulePluginOptions) => VirtualModulePlugin;
+//# sourceMappingURL=HttpApiVirtualModulePlugin.d.ts.map

package/dist/HttpApiVirtualModulePlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HttpApiVirtualModulePlugin.d.ts","sourceRoot":"","sources":["../src/HttpApiVirtualModulePlugin.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAIV,mBAAmB,EACpB,MAAM,wBAAwB,CAAC;AAgChC,MAAM,WAAW,iCAAiC;IAChD,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,MAAM,iCAAiC,GACzC;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAA;CAAE,GACzD;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpD,wBAAgB,2BAA2B,CACzC,EAAE,EAAE,MAAM,EACV,MAAM,GAAE,MAAuB,GAC9B,iCAAiC,CAwBnC;AAED,MAAM,MAAM,mCAAmC,GAC3C;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAA;CAAE,GACvD;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpD,wBAAgB,6BAA6B,CAC3C,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,MAAM,EAChB,MAAM,GAAE,MAAuB,GAC9B,mCAAmC,CAiBrC;AAoHD;;GAEG;AACH,eAAO,MAAM,gCAAgC,GAC3C,UAAS,iCAAsC,KAC9C,mBAoIF,CAAC"}

package/dist/HttpApiVirtualModulePlugin.js

@@ -0,0 +1,301 @@
+import { readdirSync, statSync } from "node:fs";
+import { dirname, extname, join, relative } from "node:path";
+import { pathIsUnderBase, resolvePathUnderBase, resolveRelativePath, toPosixPath, } from "./internal/path.js";
+import { buildHttpApiDescriptorTree, } from "./internal/httpapiDescriptorTree.js";
+import { classifyHttpApiFileRole } from "./internal/httpapiFileRoles.js";
+import { emitHttpApiSource } from "./internal/emitHttpApiSource.js";
+import { extractEndpointLiterals } from "./internal/extractHttpApiLiterals.js";
+import { getCallableReturnType, isCallableNode, typeNodeIsRouteCompatible, } from "./internal/routeTypeNode.js";
+import { validateNonEmptyString, validatePathSegment } from "./internal/validation.js";
+import { HTTPAPI_TYPE_TARGET_SPECS } from "./internal/typeTargetSpecs.js";
+const DEFAULT_PREFIX = "api:";
+const DEFAULT_PLUGIN_NAME = "httpapi-virtual-module";
+/** Extensions that count as script files when checking if a directory should resolve. */
+const SCRIPT_EXTENSION_SET = new Set([
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".mts",
+    ".cts",
+    ".mjs",
+    ".cjs",
+]);
+/** Glob patterns for discovering API source files. */
+const API_FILE_GLOBS = [
+    "**/*.ts",
+    "**/*.tsx",
+    "**/*.js",
+    "**/*.jsx",
+    "**/*.mts",
+    "**/*.cts",
+    "**/*.mjs",
+    "**/*.cjs",
+];
+const REQUIRED_ENDPOINT_EXPORTS = ["route", "method", "handler"];
+export function parseHttpApiVirtualModuleId(id, prefix = DEFAULT_PREFIX) {
+    const idResult = validateNonEmptyString(id, "id");
+    if (!idResult.ok)
+        return { ok: false, reason: idResult.reason };
+    const prefixResult = validateNonEmptyString(prefix, "prefix");
+    if (!prefixResult.ok)
+        return { ok: false, reason: prefixResult.reason };
+    if (!id.startsWith(prefix)) {
+        return { ok: false, reason: `id must start with "${prefix}"` };
+    }
+    let relativeDirectory = id.slice(prefix.length);
+    if (relativeDirectory.length > 0 &&
+        relativeDirectory !== "." &&
+        relativeDirectory !== ".." &&
+        !relativeDirectory.startsWith("./") &&
+        !relativeDirectory.startsWith("../") &&
+        !relativeDirectory.startsWith("/")) {
+        relativeDirectory = `./${relativeDirectory}`;
+    }
+    const relativeResult = validatePathSegment(relativeDirectory, "relativeDirectory");
+    if (!relativeResult.ok)
+        return { ok: false, reason: relativeResult.reason };
+    return { ok: true, relativeDirectory: relativeResult.value };
+}
+export function resolveHttpApiTargetDirectory(id, importer, prefix = DEFAULT_PREFIX) {
+    const parsed = parseHttpApiVirtualModuleId(id, prefix);
+    if (!parsed.ok)
+        return parsed;
+    const importerResult = validatePathSegment(importer, "importer");
+    if (!importerResult.ok)
+        return { ok: false, reason: importerResult.reason };
+    const importerDir = dirname(toPosixPath(importerResult.value));
+    const resolved = resolvePathUnderBase(importerDir, parsed.relativeDirectory);
+    if (!resolved.ok) {
+        return { ok: false, reason: "resolved target directory escapes importer base directory" };
+    }
+    if (!pathIsUnderBase(importerDir, resolved.path)) {
+        return { ok: false, reason: "resolved target directory is outside importer base directory" };
+    }
+    return { ok: true, targetDirectory: toPosixPath(resolved.path) };
+}
+function isExistingDirectory(absolutePath) {
+    try {
+        return statSync(absolutePath).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function directoryHasScriptFiles(dir) {
+    try {
+        const items = readdirSync(dir, { withFileTypes: true });
+        for (const e of items) {
+            if (e.isFile() &&
+                SCRIPT_EXTENSION_SET.has(extname(e.name).toLowerCase()) &&
+                !e.name.toLowerCase().endsWith(".d.ts"))
+                return true;
+            if (e.isDirectory() && directoryHasScriptFiles(join(dir, e.name)))
+                return true;
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+function collectEndpointNodes(nodes) {
+    const collected = [];
+    for (const node of nodes) {
+        if (node.type === "endpoint") {
+            collected.push(node);
+            continue;
+        }
+        collected.push(...collectEndpointNodes(node.children));
+    }
+    return collected;
+}
+function mapSnapshotsByRelativePath(snapshots, targetDirectory) {
+    const byPath = new Map();
+    for (const snapshot of snapshots) {
+        const relativePath = toPosixPath(relative(targetDirectory, snapshot.filePath));
+        byPath.set(relativePath, snapshot);
+    }
+    return byPath;
+}
+function validateEndpointContracts(endpoints, snapshotsByPath, api) {
+    const violations = [];
+    for (const endpoint of endpoints) {
+        const snapshot = snapshotsByPath.get(endpoint.path);
+        if (!snapshot) {
+            violations.push({
+                code: "AVM-CONTRACT-001",
+                message: `endpoint module not found in TypeInfo snapshot set: ${endpoint.path}`,
+            });
+            continue;
+        }
+        const exportedNames = new Set(snapshot.exports.map((exported) => exported.name));
+        const missing = REQUIRED_ENDPOINT_EXPORTS.filter((name) => !exportedNames.has(name));
+        if (missing.length > 0) {
+            violations.push({
+                code: "AVM-CONTRACT-002",
+                message: `endpoint "${endpoint.path}" missing required export(s): ${missing.join(", ")}`,
+            });
+            continue;
+        }
+        const routeExport = snapshot.exports.find((e) => e.name === "route");
+        if (!routeExport)
+            continue;
+        if (!typeNodeIsRouteCompatible(routeExport.type, api)) {
+            const hint = "; route must be assignable to Route from @typed/router";
+            violations.push({
+                code: "AVM-CONTRACT-003",
+                message: `endpoint "${endpoint.path}" route: export must be Route (Parse, Param, Join, etc.) from @typed/router${hint}`,
+            });
+        }
+        const handlerExport = snapshot.exports.find((e) => e.name === "handler");
+        if (handlerExport) {
+            const handlerNode = isCallableNode(handlerExport.type)
+                ? (getCallableReturnType(handlerExport.type) ?? handlerExport.type)
+                : handlerExport.type;
+            const handlerReturnsEffect = api.isAssignableTo(handlerNode, "Effect");
+            if (!handlerReturnsEffect) {
+                violations.push({
+                    code: "AVM-CONTRACT-004",
+                    message: `endpoint "${endpoint.path}" handler: return type must be Effect`,
+                });
+            }
+        }
+        const successExport = snapshot.exports.find((e) => e.name === "success");
+        if (successExport && !api.isAssignableTo(successExport.type, "Schema")) {
+            violations.push({
+                code: "AVM-CONTRACT-005",
+                message: `endpoint "${endpoint.path}" success: export must be Schema when present`,
+            });
+        }
+        const errorExport = snapshot.exports.find((e) => e.name === "error");
+        if (errorExport && !api.isAssignableTo(errorExport.type, "Schema")) {
+            violations.push({
+                code: "AVM-CONTRACT-006",
+                message: `endpoint "${endpoint.path}" error: export must be Schema when present`,
+            });
+        }
+    }
+    return violations.sort((a, b) => a.message.localeCompare(b.message, "en"));
+}
+/**
+ * Creates the HttpApi virtual module plugin with sync shouldResolve and build behavior.
+ */
+export const createHttpApiVirtualModulePlugin = (options = {}) => {
+    const prefix = options.prefix ?? DEFAULT_PREFIX;
+    const name = options.name ?? DEFAULT_PLUGIN_NAME;
+    return {
+        name,
+        typeTargetSpecs: HTTPAPI_TYPE_TARGET_SPECS,
+        shouldResolve(id, importer) {
+            const resolved = resolveHttpApiTargetDirectory(id, importer, prefix);
+            if (!resolved.ok)
+                return false;
+            if (!isExistingDirectory(resolved.targetDirectory))
+                return false;
+            return directoryHasScriptFiles(resolved.targetDirectory);
+        },
+        build(id, importer, api) {
+            const resolved = resolveHttpApiTargetDirectory(id, importer, prefix);
+            if (!resolved.ok) {
+                return {
+                    errors: [{ code: "AVM-ID-001", message: resolved.reason, pluginName: name }],
+                };
+            }
+            if (!isExistingDirectory(resolved.targetDirectory)) {
+                return {
+                    errors: [
+                        {
+                            code: "AVM-DISC-001",
+                            message: `target directory does not exist: ${resolveRelativePath(dirname(importer), resolved.targetDirectory)}`,
+                            pluginName: name,
+                        },
+                    ],
+                };
+            }
+            const snapshots = api.directory(API_FILE_GLOBS, {
+                baseDir: resolved.targetDirectory,
+                recursive: true,
+                watch: true,
+            });
+            if (snapshots.length === 0) {
+                return {
+                    errors: [
+                        {
+                            code: "AVM-LEAF-001",
+                            message: `no API source files discovered in ${resolved.targetDirectory}`,
+                            pluginName: name,
+                        },
+                    ],
+                };
+            }
+            const snapshotsByRelativePath = mapSnapshotsByRelativePath(snapshots, resolved.targetDirectory);
+            const relativePaths = [...snapshotsByRelativePath.keys()].sort((a, b) => a.localeCompare(b, "en"));
+            const roles = relativePaths.map((path) => classifyHttpApiFileRole(path));
+            const tree = buildHttpApiDescriptorTree({ roles });
+            const endpoints = collectEndpointNodes(tree.children);
+            if (endpoints.length === 0) {
+                return {
+                    errors: [
+                        {
+                            code: "AVM-LEAF-001",
+                            message: `no valid API endpoint leaves discovered in ${resolved.targetDirectory}`,
+                            pluginName: name,
+                        },
+                    ],
+                };
+            }
+            const contractViolations = validateEndpointContracts(endpoints, snapshotsByRelativePath, api);
+            if (contractViolations.length > 0) {
+                return {
+                    errors: contractViolations.map((violation) => ({
+                        code: violation.code,
+                        message: violation.message,
+                        pluginName: name,
+                    })),
+                };
+            }
+            const extractedLiteralsByPath = new Map();
+            const optionalExportsByPath = new Map();
+            const handlerIsRawByPath = new Map();
+            const OPTIONAL_NAMES = ["headers", "body", "success", "error"];
+            for (const endpoint of endpoints) {
+                const snapshot = snapshotsByRelativePath.get(endpoint.path);
+                if (snapshot) {
+                    const literals = extractEndpointLiterals(snapshot, endpoint.stem);
+                    extractedLiteralsByPath.set(endpoint.path, literals);
+                    const exportedNames = new Set(snapshot.exports.map((e) => e.name));
+                    const present = new Set(OPTIONAL_NAMES.filter((n) => exportedNames.has(n)));
+                    optionalExportsByPath.set(endpoint.path, present);
+                    const handlerExport = snapshot.exports.find((e) => e.name === "handler");
+                    if (handlerExport != null &&
+                        api.isAssignableTo(handlerExport.type, "HttpServerResponse", [
+                            { kind: "returnType" },
+                            { kind: "typeArg", index: 0 },
+                        ])) {
+                        handlerIsRawByPath.set(endpoint.path, true);
+                    }
+                }
+            }
+            const sourceText = emitHttpApiSource({
+                tree,
+                targetDirectory: resolved.targetDirectory,
+                importer,
+                extractedLiteralsByPath,
+                optionalExportsByPath,
+                handlerIsRawByPath,
+            });
+            if (tree.diagnostics.length > 0) {
+                return {
+                    sourceText,
+                    warnings: tree.diagnostics.map((diagnostic) => ({
+                        code: diagnostic.code,
+                        message: diagnostic.message,
+                        pluginName: name,
+                    })),
+                };
+            }
+            return sourceText;
+        },
+    };
+};

package/dist/RouterVirtualModulePlugin.d.ts

@@ -0,0 +1,23 @@
+import type { VirtualModulePlugin } from "@typed/virtual-modules";
+export interface RouterVirtualModulePluginOptions {
+    readonly prefix?: string;
+    readonly name?: string;
+}
+export type ParseRouterVirtualModuleIdResult = {
+    readonly ok: true;
+    readonly relativeDirectory: string;
+} | {
+    readonly ok: false;
+    readonly reason: string;
+};
+export declare function parseRouterVirtualModuleId(id: string, prefix?: string): ParseRouterVirtualModuleIdResult;
+export type ResolveRouterTargetDirectoryResult = {
+    readonly ok: true;
+    readonly targetDirectory: string;
+} | {
+    readonly ok: false;
+    readonly reason: string;
+};
+export declare function resolveRouterTargetDirectory(id: string, importer: string, prefix?: string): ResolveRouterTargetDirectoryResult;
+export declare const createRouterVirtualModulePlugin: (options?: RouterVirtualModulePluginOptions) => VirtualModulePlugin;
+//# sourceMappingURL=RouterVirtualModulePlugin.d.ts.map

package/dist/RouterVirtualModulePlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RouterVirtualModulePlugin.d.ts","sourceRoot":"","sources":["../src/RouterVirtualModulePlugin.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAA2B,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AA8B3F,MAAM,WAAW,gCAAgC;IAC/C,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,MAAM,gCAAgC,GACxC;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAA;CAAE,GACzD;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpD,wBAAgB,0BAA0B,CACxC,EAAE,EAAE,MAAM,EACV,MAAM,GAAE,MAAuB,GAC9B,gCAAgC,CAwBlC;AAED,MAAM,MAAM,kCAAkC,GAC1C;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAA;CAAE,GACvD;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpD,wBAAgB,4BAA4B,CAC1C,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,MAAM,EAChB,MAAM,GAAE,MAAuB,GAC9B,kCAAkC,CAiBpC;AAmDD,eAAO,MAAM,+BAA+B,GAC1C,UAAS,gCAAqC,KAC7C,mBAiFF,CAAC"}