digital-tools 2.1.1 → 2.3.0

package/dist/verb-registration.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Verb Auto-Registration (aip-47tm)
+ *
+ * Bridges `defineTool()` (synchronous, side-effect-free builder) to
+ * `digital-objects`' provider-mediated `defineVerb()` (async, I/O-bound).
+ *
+ * ## Design choice — Option B: explicit bootstrap
+ *
+ * `defineTool({ verb, frame })` records the metadata on the Tool but does
+ * NOT call `provider.defineVerb()` itself. Cross-package side effects
+ * from a pure builder are surprising; the provider is also caller-supplied,
+ * so eager registration would force `defineTool` to know about a provider
+ * it doesn't currently take.
+ *
+ * Instead, registration is an explicit, idempotent helper:
+ *
+ *   - `registerToolVerb(provider, tool)`     — single-tool, used from
+ *                                                custom dispatchers that
+ *                                                want lazy-on-first-call.
+ *   - `registerToolVerbs(provider, tools)`   — bootstrap list, used at
+ *                                                startup once per provider.
+ *
+ * Both are idempotent: re-registering a Verb with the same name and same
+ * frame is a no-op. Re-registering with a different frame throws —
+ * silent overwrite would mask an ontology drift bug.
+ *
+ * ## Why not Option A (lazy in `wrapTool`)
+ *
+ * `wrapTool()` takes auth + payment brokers, not a `DigitalObjectsProvider`.
+ * Wiring a provider into `wrapTool()` would couple HTTP wrapping to the
+ * digital-objects ontology — a layering inversion. Callers that want
+ * lazy-on-first-call can compose `registerToolVerb()` into their own
+ * dispatcher; the helper is fast enough to call per-request because the
+ * idempotency check short-circuits to a single `getVerb()` lookup.
+ *
+ * ## Why not Option C (eager-with-deferred-provider queue)
+ *
+ * A module-level queue is global state in `digital-tools` — exactly what
+ * the bead forbids. It also can't flush deterministically across
+ * concurrent test workers, and ordering becomes load-dependent.
+ *
+ * @packageDocumentation
+ */
+import type { Frame, Verb, VerbDefinition } from 'digital-objects';
+import type { AnyTool, Tool } from './types.js';
+/**
+ * Subset of `DigitalObjectsProvider` that this module requires.
+ *
+ * We deliberately accept only `getVerb` + `defineVerb` (rather than the
+ * full provider interface) so callers can pass any object with these
+ * two methods — including HTTP/RPC clients, test doubles, and the
+ * canonical `MemoryProvider`.
+ */
+export interface VerbRegistrationProvider {
+    defineVerb(def: VerbDefinition): Promise<Verb>;
+    getVerb(name: string): Promise<Verb | null>;
+}
+/**
+ * Mismatch error raised when a Tool tries to register a Verb whose name
+ * already exists with a different frame. We do not silently overwrite —
+ * conflicting ontology shapes are almost always a bug (two tools claiming
+ * the same verb with different role expectations).
+ */
+export declare class VerbRegistrationConflictError extends Error {
+    readonly verbName: string;
+    readonly existing: Frame | undefined;
+    readonly incoming: Frame | undefined;
+    constructor(verbName: string, existing: Frame | undefined, incoming: Frame | undefined);
+}
+/**
+ * Register the Verb declared by a single Tool against `provider`.
+ *
+ * - Tools without a `verb` field are skipped (they are not SVO-aware).
+ * - If the verb already exists with the same frame, the call is a no-op
+ *   and the existing Verb is returned (idempotent).
+ * - If the verb already exists with a different frame, throws
+ *   {@link VerbRegistrationConflictError}.
+ *
+ * Suitable for both eager bootstrap and lazy-per-request use:
+ * the idempotency check is a single `getVerb()` lookup, so it is safe
+ * to call from a hot dispatch path.
+ *
+ * @returns The registered Verb, or `null` if the tool has no `verb` field.
+ *
+ * @example Lazy registration in a custom dispatcher
+ * ```ts
+ * async function dispatch(provider: DigitalObjectsProvider, tool: Tool, args: unknown) {
+ *   await registerToolVerb(provider, tool)   // idempotent, cheap on subsequent calls
+ *   return tool.handler(args)
+ * }
+ * ```
+ */
+export declare function registerToolVerb(provider: VerbRegistrationProvider, tool: Tool<unknown, unknown> | AnyTool): Promise<Verb | null>;
+/**
+ * Bootstrap helper: register the Verbs for every SVO-aware tool in
+ * `tools` against `provider`.
+ *
+ * Tools without a `verb` field are skipped silently (legacy / non-SVO
+ * tools coexist with SVO-aware tools in the same registry).
+ *
+ * Conflicts (same verb name, different frame) throw on the first
+ * conflicting tool — the caller can decide whether to retry without
+ * the conflicting tool or surface the error.
+ *
+ * @returns The list of Verbs that were registered (or already existed,
+ *          for idempotent calls). Tools with no verb are not included.
+ *
+ * @example Startup
+ * ```ts
+ * import { MemoryProvider, registerToolVerbs, getBuiltinTools } from 'digital-tools'
+ *
+ * const provider = new MemoryProvider()
+ * await registerToolVerbs(provider, getBuiltinTools())
+ * ```
+ */
+export declare function registerToolVerbs(provider: VerbRegistrationProvider, tools: ReadonlyArray<Tool<unknown, unknown> | AnyTool>): Promise<Verb[]>;
+/**
+ * Alias for {@link registerToolVerbs}. The "bootstrap" name reads better
+ * at startup sites where a list of tools is wired against a provider once.
+ */
+export declare const bootstrapTools: typeof registerToolVerbs;
+//# sourceMappingURL=verb-registration.d.ts.map

package/dist/verb-registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verb-registration.d.ts","sourceRoot":"","sources":["../src/verb-registration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAClE,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAE/C;;;;;;;GAOG;AACH,MAAM,WAAW,wBAAwB;IACvC,UAAU,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAC9C,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC,CAAA;CAC5C;AAkCD;;;;;GAKG;AACH,qBAAa,6BAA8B,SAAQ,KAAK;aAEpC,QAAQ,EAAE,MAAM;aAChB,QAAQ,EAAE,KAAK,GAAG,SAAS;aAC3B,QAAQ,EAAE,KAAK,GAAG,SAAS;gBAF3B,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,KAAK,GAAG,SAAS,EAC3B,QAAQ,EAAE,KAAK,GAAG,SAAS;CAU9C;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAsB,gBAAgB,CACpC,QAAQ,EAAE,wBAAwB,EAClC,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,OAAO,GACrC,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC,CAgBtB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,iBAAiB,CACrC,QAAQ,EAAE,wBAAwB,EAClC,KAAK,EAAE,aAAa,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,GACrD,OAAO,CAAC,IAAI,EAAE,CAAC,CAOjB;AAED;;;GAGG;AACH,eAAO,MAAM,cAAc,0BAAoB,CAAA"}

package/dist/verb-registration.js

@@ -0,0 +1,176 @@
+/**
+ * Verb Auto-Registration (aip-47tm)
+ *
+ * Bridges `defineTool()` (synchronous, side-effect-free builder) to
+ * `digital-objects`' provider-mediated `defineVerb()` (async, I/O-bound).
+ *
+ * ## Design choice — Option B: explicit bootstrap
+ *
+ * `defineTool({ verb, frame })` records the metadata on the Tool but does
+ * NOT call `provider.defineVerb()` itself. Cross-package side effects
+ * from a pure builder are surprising; the provider is also caller-supplied,
+ * so eager registration would force `defineTool` to know about a provider
+ * it doesn't currently take.
+ *
+ * Instead, registration is an explicit, idempotent helper:
+ *
+ *   - `registerToolVerb(provider, tool)`     — single-tool, used from
+ *                                                custom dispatchers that
+ *                                                want lazy-on-first-call.
+ *   - `registerToolVerbs(provider, tools)`   — bootstrap list, used at
+ *                                                startup once per provider.
+ *
+ * Both are idempotent: re-registering a Verb with the same name and same
+ * frame is a no-op. Re-registering with a different frame throws —
+ * silent overwrite would mask an ontology drift bug.
+ *
+ * ## Why not Option A (lazy in `wrapTool`)
+ *
+ * `wrapTool()` takes auth + payment brokers, not a `DigitalObjectsProvider`.
+ * Wiring a provider into `wrapTool()` would couple HTTP wrapping to the
+ * digital-objects ontology — a layering inversion. Callers that want
+ * lazy-on-first-call can compose `registerToolVerb()` into their own
+ * dispatcher; the helper is fast enough to call per-request because the
+ * idempotency check short-circuits to a single `getVerb()` lookup.
+ *
+ * ## Why not Option C (eager-with-deferred-provider queue)
+ *
+ * A module-level queue is global state in `digital-tools` — exactly what
+ * the bead forbids. It also can't flush deterministically across
+ * concurrent test workers, and ordering becomes load-dependent.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Compare two optional Frames structurally. Returns true when both are
+ * undefined, or both define the same set of role -> NounRef mappings.
+ *
+ * `manner` (string[]) is compared as an unordered set since the role
+ * order is not semantically meaningful.
+ */
+function framesEqual(a, b) {
+    if (a === b)
+        return true;
+    if (!a || !b)
+        return false;
+    const keys = new Set([
+        ...Object.keys(a),
+        ...Object.keys(b),
+    ]);
+    for (const k of keys) {
+        const av = a[k];
+        const bv = b[k];
+        if (k === 'manner') {
+            const aArr = av ?? [];
+            const bArr = bv ?? [];
+            if (aArr.length !== bArr.length)
+                return false;
+            const aSet = new Set(aArr);
+            for (const v of bArr)
+                if (!aSet.has(v))
+                    return false;
+        }
+        else {
+            if (av !== bv)
+                return false;
+        }
+    }
+    return true;
+}
+/**
+ * Mismatch error raised when a Tool tries to register a Verb whose name
+ * already exists with a different frame. We do not silently overwrite —
+ * conflicting ontology shapes are almost always a bug (two tools claiming
+ * the same verb with different role expectations).
+ */
+export class VerbRegistrationConflictError extends Error {
+    verbName;
+    existing;
+    incoming;
+    constructor(verbName, existing, incoming) {
+        super(`Verb "${verbName}" is already registered with a different frame. ` +
+            `Tools that share a verb name must declare the same frame. ` +
+            `Re-registering a verb with the same frame is a no-op (idempotent), ` +
+            `but the incoming frame does not match the existing one.`);
+        this.verbName = verbName;
+        this.existing = existing;
+        this.incoming = incoming;
+        this.name = 'VerbRegistrationConflictError';
+    }
+}
+/**
+ * Register the Verb declared by a single Tool against `provider`.
+ *
+ * - Tools without a `verb` field are skipped (they are not SVO-aware).
+ * - If the verb already exists with the same frame, the call is a no-op
+ *   and the existing Verb is returned (idempotent).
+ * - If the verb already exists with a different frame, throws
+ *   {@link VerbRegistrationConflictError}.
+ *
+ * Suitable for both eager bootstrap and lazy-per-request use:
+ * the idempotency check is a single `getVerb()` lookup, so it is safe
+ * to call from a hot dispatch path.
+ *
+ * @returns The registered Verb, or `null` if the tool has no `verb` field.
+ *
+ * @example Lazy registration in a custom dispatcher
+ * ```ts
+ * async function dispatch(provider: DigitalObjectsProvider, tool: Tool, args: unknown) {
+ *   await registerToolVerb(provider, tool)   // idempotent, cheap on subsequent calls
+ *   return tool.handler(args)
+ * }
+ * ```
+ */
+export async function registerToolVerb(provider, tool) {
+    if (!tool.verb)
+        return null;
+    const existing = await provider.getVerb(tool.verb);
+    if (existing) {
+        if (framesEqual(existing.frame, tool.frame)) {
+            return existing;
+        }
+        throw new VerbRegistrationConflictError(tool.verb, existing.frame, tool.frame);
+    }
+    return provider.defineVerb({
+        name: tool.verb,
+        ...(tool.frame !== undefined && { frame: tool.frame }),
+        ...(tool.description !== undefined && { description: tool.description }),
+    });
+}
+/**
+ * Bootstrap helper: register the Verbs for every SVO-aware tool in
+ * `tools` against `provider`.
+ *
+ * Tools without a `verb` field are skipped silently (legacy / non-SVO
+ * tools coexist with SVO-aware tools in the same registry).
+ *
+ * Conflicts (same verb name, different frame) throw on the first
+ * conflicting tool — the caller can decide whether to retry without
+ * the conflicting tool or surface the error.
+ *
+ * @returns The list of Verbs that were registered (or already existed,
+ *          for idempotent calls). Tools with no verb are not included.
+ *
+ * @example Startup
+ * ```ts
+ * import { MemoryProvider, registerToolVerbs, getBuiltinTools } from 'digital-tools'
+ *
+ * const provider = new MemoryProvider()
+ * await registerToolVerbs(provider, getBuiltinTools())
+ * ```
+ */
+export async function registerToolVerbs(provider, tools) {
+    const registered = [];
+    for (const tool of tools) {
+        const verb = await registerToolVerb(provider, tool);
+        if (verb)
+            registered.push(verb);
+    }
+    return registered;
+}
+/**
+ * Alias for {@link registerToolVerbs}. The "bootstrap" name reads better
+ * at startup sites where a list of tools is wired against a provider once.
+ */
+export const bootstrapTools = registerToolVerbs;
+//# sourceMappingURL=verb-registration.js.map

package/dist/verb-registration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"verb-registration.js","sourceRoot":"","sources":["../src/verb-registration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAkBH;;;;;;GAMG;AACH,SAAS,WAAW,CAAC,CAAoB,EAAE,CAAoB;IAC7D,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,IAAI,CAAA;IACxB,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC;QAAE,OAAO,KAAK,CAAA;IAE1B,MAAM,IAAI,GAAG,IAAI,GAAG,CAAc;QAChC,GAAI,MAAM,CAAC,IAAI,CAAC,CAAC,CAAqB;QACtC,GAAI,MAAM,CAAC,IAAI,CAAC,CAAC,CAAqB;KACvC,CAAC,CAAA;IAEF,KAAK,MAAM,CAAC,IAAI,IAAI,EAAE,CAAC;QACrB,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAA;QACf,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAA;QACf,IAAI,CAAC,KAAK,QAAQ,EAAE,CAAC;YACnB,MAAM,IAAI,GAAI,EAA2B,IAAI,EAAE,CAAA;YAC/C,MAAM,IAAI,GAAI,EAA2B,IAAI,EAAE,CAAA;YAC/C,IAAI,IAAI,CAAC,MAAM,KAAK,IAAI,CAAC,MAAM;gBAAE,OAAO,KAAK,CAAA;YAC7C,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,CAAA;YAC1B,KAAK,MAAM,CAAC,IAAI,IAAI;gBAAE,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;oBAAE,OAAO,KAAK,CAAA;QACtD,CAAC;aAAM,CAAC;YACN,IAAI,EAAE,KAAK,EAAE;gBAAE,OAAO,KAAK,CAAA;QAC7B,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAA;AACb,CAAC;AAED;;;;;GAKG;AACH,MAAM,OAAO,6BAA8B,SAAQ,KAAK;IAEpC;IACA;IACA;IAHlB,YACkB,QAAgB,EAChB,QAA2B,EAC3B,QAA2B;QAE3C,KAAK,CACH,SAAS,QAAQ,kDAAkD;YACjE,4DAA4D;YAC5D,qEAAqE;YACrE,yDAAyD,CAC5D,CAAA;QATe,aAAQ,GAAR,QAAQ,CAAQ;QAChB,aAAQ,GAAR,QAAQ,CAAmB;QAC3B,aAAQ,GAAR,QAAQ,CAAmB;QAQ3C,IAAI,CAAC,IAAI,GAAG,+BAA+B,CAAA;IAC7C,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CACpC,QAAkC,EAClC,IAAsC;IAEtC,IAAI,CAAC,IAAI,CAAC,IAAI;QAAE,OAAO,IAAI,CAAA;IAE3B,MAAM,QAAQ,GAAG,MAAM,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IAClD,IAAI,QAAQ,EAAE,CAAC;QACb,IAAI,WAAW,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;YAC5C,OAAO,QAAQ,CAAA;QACjB,CAAC;QACD,MAAM,IAAI,6BAA6B,CAAC,IAAI,CAAC,IAAI,EAAE,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,CAAA;IAChF,CAAC;IAED,OAAO,QAAQ,CAAC,UAAU,CAAC;QACzB,IAAI,EAAE,IAAI,CAAC,IAAI;QACf,GAAG,CAAC,IAAI,CAAC,KAAK,KAAK,SAAS,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC;QACtD,GAAG,CAAC,IAAI,CAAC,WAAW,KAAK,SAAS,IAAI,EAAE,WAAW,EAAE,IAAI,CAAC,WAAW,EAAE,CAAC;KACzE,CAAC,CAAA;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,QAAkC,EAClC,KAAsD;IAEtD,MAAM,UAAU,GAAW,EAAE,CAAA;IAC7B,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,IAAI,GAAG,MAAM,gBAAgB,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAA;QACnD,IAAI,IAAI;YAAE,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IACjC,CAAC;IACD,OAAO,UAAU,CAAA;AACnB,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,iBAAiB,CAAA"}

package/dist/worker.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Tool Worker - provides tool service via RPC
+ *
+ * This worker can be deployed to Cloudflare Workers or run locally via Miniflare.
+ * It exposes tool registration, discovery, execution, and MCP conversion via Workers RPC.
+ *
+ * Uses Cloudflare Workers RPC (WorkerEntrypoint, RpcTarget) for communication.
+ */
+import { WorkerEntrypoint, RpcTarget } from 'cloudflare:workers';
+import type { AnyTool, ToolCategory, ToolQuery, MCPTool, ToolSubcategory } from './types.js';
+/**
+ * Core tool service - extends RpcTarget so it can be passed over RPC
+ *
+ * Contains all tool functionality: registration, discovery, execution, and MCP conversion
+ */
+export declare class ToolServiceCore extends RpcTarget {
+    private tools;
+    constructor();
+    /**
+     * Register built-in tools
+     */
+    private registerBuiltins;
+    /**
+     * Register a tool in the service registry
+     */
+    register(tool: AnyTool): void;
+    /**
+     * Unregister a tool
+     */
+    unregister(id: string): boolean;
+    /**
+     * Get a tool by ID
+     */
+    get(id: string): AnyTool | undefined;
+    /**
+     * Check if a tool exists
+     */
+    has(id: string): boolean;
+    /**
+     * List all tool IDs
+     */
+    list(): string[];
+    /**
+     * Query tools with filtering
+     */
+    query(options: ToolQuery): AnyTool[];
+    /**
+     * Get tools by category
+     */
+    byCategory(category: ToolCategory): AnyTool[];
+    /**
+     * Execute a tool by ID
+     */
+    executeTool<TInput = unknown, TOutput = unknown>(id: string, input: TInput): Promise<TOutput>;
+    /**
+     * Convert a Tool to MCP format
+     */
+    toMCP(tool: AnyTool): MCPTool;
+    /**
+     * Convert all registered tools to MCP format
+     */
+    listMCPTools(): MCPTool[];
+    /**
+     * Import a tool from MCP format
+     */
+    fromMCP(mcpTool: MCPTool, handler: (input: unknown) => unknown | Promise<unknown>, options?: {
+        category?: ToolCategory;
+        subcategory?: ToolSubcategory;
+        tags?: string[];
+    }): AnyTool;
+    /**
+     * Clear all tools (except built-ins if keepBuiltins is true)
+     */
+    clear(keepBuiltins?: boolean): void;
+}
+/**
+ * Main tool service exposed via RPC as WorkerEntrypoint
+ *
+ * Usage:
+ *   const tools = await env.TOOLS.connect()
+ *   tools.register({ id: 'my.tool', ... })
+ *   tools.list()
+ *   const result = await tools.executeTool('data.json.parse', { text: '{}' })
+ */
+export declare class ToolService extends WorkerEntrypoint {
+    /**
+     * Get a tool service instance - returns an RpcTarget that can be used directly
+     */
+    connect(): ToolServiceCore;
+}
+export default ToolService;
+export { ToolService as ToolWorker };
+//# sourceMappingURL=worker.d.ts.map

package/dist/worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../src/worker.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAChE,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAE5F;;;;GAIG;AACH,qBAAa,eAAgB,SAAQ,SAAS;IAC5C,OAAO,CAAC,KAAK,CAAkC;;IAQ/C;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAsIxB;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI;IAI7B;;OAEG;IACH,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAI/B;;OAEG;IACH,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS;IAIpC;;OAEG;IACH,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAIxB;;OAEG;IACH,IAAI,IAAI,MAAM,EAAE;IAIhB;;OAEG;IACH,KAAK,CAAC,OAAO,EAAE,SAAS,GAAG,OAAO,EAAE;IA4CpC;;OAEG;IACH,UAAU,CAAC,QAAQ,EAAE,YAAY,GAAG,OAAO,EAAE;IAI7C;;OAEG;IACG,WAAW,CAAC,MAAM,GAAG,OAAO,EAAE,OAAO,GAAG,OAAO,EACnD,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,OAAO,CAAC;IAQnB;;OAEG;IACH,KAAK,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO;IAmB7B;;OAEG;IACH,YAAY,IAAI,OAAO,EAAE;IAIzB;;OAEG;IACH,OAAO,CACL,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,EACvD,OAAO,CAAC,EAAE;QACR,QAAQ,CAAC,EAAE,YAAY,CAAA;QACvB,WAAW,CAAC,EAAE,eAAe,CAAA;QAC7B,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;KAChB,GACA,OAAO;IA0BV;;OAEG;IACH,KAAK,CAAC,YAAY,GAAE,OAAe,GAAG,IAAI;CAU3C;AAED;;;;;;;;GAQG;AACH,qBAAa,WAAY,SAAQ,gBAAgB;IAC/C;;OAEG;IACH,OAAO,IAAI,eAAe;CAG3B;AAGD,eAAe,WAAW,CAAA;AAG1B,OAAO,EAAE,WAAW,IAAI,UAAU,EAAE,CAAA"}