@webiny/api-core 0.0.0-unstable.0d717d18dd

package/features/ai/events.js

@@ -0,0 +1,41 @@
+import { createAbstraction } from "@webiny/feature/api";
+import { DomainEvent } from "../eventPublisher/index.js";
+class AiBeforeGenerateTextEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return AiBeforeGenerateTextEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "ai.beforeGenerateText";
+    }
+}
+const AiBeforeGenerateTextEventHandler = createAbstraction("AiBeforeGenerateTextEventHandler");
+class AiAfterGenerateTextEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return AiAfterGenerateTextEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "ai.afterGenerateText";
+    }
+}
+const AiAfterGenerateTextEventHandler = createAbstraction("AiAfterGenerateTextEventHandler");
+class AiGenerateTextErrorEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return AiGenerateTextErrorEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "ai.generateTextError";
+    }
+}
+const AiGenerateTextErrorEventHandler = createAbstraction("AiGenerateTextErrorEventHandler");
+class AiBeforeStreamTextEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return AiBeforeStreamTextEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "ai.beforeStreamText";
+    }
+}
+const AiBeforeStreamTextEventHandler = createAbstraction("AiBeforeStreamTextEventHandler");
+export { AiAfterGenerateTextEvent, AiAfterGenerateTextEventHandler, AiBeforeGenerateTextEvent, AiBeforeGenerateTextEventHandler, AiBeforeStreamTextEvent, AiBeforeStreamTextEventHandler, AiGenerateTextErrorEvent, AiGenerateTextErrorEventHandler };
+
+//# sourceMappingURL=events.js.map

package/features/ai/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/ai/events.js","sources":["../../../src/features/ai/events.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { DomainEvent } from \"~/features/eventPublisher/index.js\";\nimport type { IEventHandler } from \"~/features/eventPublisher/index.js\";\nimport type { AiGenerateTextParams, AiStreamTextParams } from \"./abstractions.js\";\nimport type { generateText } from \"ai\";\n\n// ============================================================================\n// BeforeGenerateText\n// ============================================================================\n\nexport interface AiBeforeGenerateTextPayload {\n    requestId: string;\n    params: AiGenerateTextParams;\n}\n\nexport class AiBeforeGenerateTextEvent extends DomainEvent<AiBeforeGenerateTextPayload> {\n    eventType = \"ai.beforeGenerateText\" as const;\n\n    getHandlerAbstraction() {\n        return AiBeforeGenerateTextEventHandler;\n    }\n}\n\nexport const AiBeforeGenerateTextEventHandler = createAbstraction<\n    IEventHandler<AiBeforeGenerateTextEvent>\n>(\"AiBeforeGenerateTextEventHandler\");\n\nexport namespace AiBeforeGenerateTextEventHandler {\n    export type Interface = IEventHandler<AiBeforeGenerateTextEvent>;\n    export type Event = AiBeforeGenerateTextEvent;\n}\n\n// ============================================================================\n// AfterGenerateText\n// ============================================================================\n\nexport interface AiAfterGenerateTextPayload {\n    requestId: string;\n    params: AiGenerateTextParams;\n    result: Awaited<ReturnType<typeof generateText>>;\n    duration: number;\n}\n\nexport class AiAfterGenerateTextEvent extends DomainEvent<AiAfterGenerateTextPayload> {\n    eventType = \"ai.afterGenerateText\" as const;\n\n    getHandlerAbstraction() {\n        return AiAfterGenerateTextEventHandler;\n    }\n}\n\nexport const AiAfterGenerateTextEventHandler = createAbstraction<\n    IEventHandler<AiAfterGenerateTextEvent>\n>(\"AiAfterGenerateTextEventHandler\");\n\nexport namespace AiAfterGenerateTextEventHandler {\n    export type Interface = IEventHandler<AiAfterGenerateTextEvent>;\n    export type Event = AiAfterGenerateTextEvent;\n}\n\n// ============================================================================\n// GenerateTextError\n// ============================================================================\n\nexport interface AiGenerateTextErrorPayload {\n    requestId: string;\n    params: AiGenerateTextParams;\n    error: Error;\n    duration: number;\n}\n\nexport class AiGenerateTextErrorEvent extends DomainEvent<AiGenerateTextErrorPayload> {\n    eventType = \"ai.generateTextError\" as const;\n\n    getHandlerAbstraction() {\n        return AiGenerateTextErrorEventHandler;\n    }\n}\n\nexport const AiGenerateTextErrorEventHandler = createAbstraction<\n    IEventHandler<AiGenerateTextErrorEvent>\n>(\"AiGenerateTextErrorEventHandler\");\n\nexport namespace AiGenerateTextErrorEventHandler {\n    export type Interface = IEventHandler<AiGenerateTextErrorEvent>;\n    export type Event = AiGenerateTextErrorEvent;\n}\n\n// ============================================================================\n// BeforeStreamText\n// ============================================================================\n\nexport interface AiBeforeStreamTextPayload {\n    params: AiStreamTextParams;\n}\n\nexport class AiBeforeStreamTextEvent extends DomainEvent<AiBeforeStreamTextPayload> {\n    eventType = \"ai.beforeStreamText\" as const;\n\n    getHandlerAbstraction() {\n        return AiBeforeStreamTextEventHandler;\n    }\n}\n\nexport const AiBeforeStreamTextEventHandler = createAbstraction<\n    IEventHandler<AiBeforeStreamTextEvent>\n>(\"AiBeforeStreamTextEventHandler\");\n\nexport namespace AiBeforeStreamTextEventHandler {\n    export type Interface = IEventHandler<AiBeforeStreamTextEvent>;\n    export type Event = AiBeforeStreamTextEvent;\n}\n"],"names":["AiBeforeGenerateTextEvent","DomainEvent","AiBeforeGenerateTextEventHandler","createAbstraction","AiAfterGenerateTextEvent","AiAfterGenerateTextEventHandler","AiGenerateTextErrorEvent","AiGenerateTextErrorEventHandler","AiBeforeStreamTextEvent","AiBeforeStreamTextEventHandler"],"mappings":";;AAeO,MAAMA,kCAAkCC;IAG3C,wBAAwB;QACpB,OAAOC;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAEO,MAAMA,mCAAmCC,kBAE9C;AAkBK,MAAMC,iCAAiCH;IAG1C,wBAAwB;QACpB,OAAOI;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAEO,MAAMA,kCAAkCF,kBAE7C;AAkBK,MAAMG,iCAAiCL;IAG1C,wBAAwB;QACpB,OAAOM;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAEO,MAAMA,kCAAkCJ,kBAE7C;AAeK,MAAMK,gCAAgCP;IAGzC,wBAAwB;QACpB,OAAOQ;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAEO,MAAMA,iCAAiCN,kBAE5C"}

package/features/ai/feature.d.ts

@@ -0,0 +1,4 @@
+export declare const AiFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/ai/feature.js

@@ -0,0 +1,23 @@
+import { createFeature } from "@webiny/feature/api";
+import { OpenAiSdkFactory } from "./OpenAiSdkFactory.js";
+import { AnthropicSdkFactory } from "./AnthropicSdkFactory.js";
+import { Ai } from "./Ai.js";
+import { AiSdkTools } from "./AiSdkTools.js";
+import { AiOutputToolRegistry } from "./toolPipeline/AiOutputToolRegistry.js";
+import { AiToolPipelineRunner } from "./toolPipeline/AiToolPipelineRunner.js";
+import { DefaultTextExtractor } from "./TextExtractor/DefaultTextExtractor.js";
+const AiFeature = createFeature({
+    name: "AiFeature",
+    register (container) {
+        container.register(OpenAiSdkFactory);
+        container.register(AnthropicSdkFactory);
+        container.register(Ai);
+        container.register(AiSdkTools);
+        container.register(AiOutputToolRegistry);
+        container.register(AiToolPipelineRunner);
+        container.register(DefaultTextExtractor);
+    }
+});
+export { AiFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/ai/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/ai/feature.js","sources":["../../../src/features/ai/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { OpenAiSdkFactory } from \"./OpenAiSdkFactory.js\";\nimport { AnthropicSdkFactory } from \"./AnthropicSdkFactory.js\";\nimport { Ai } from \"./Ai.js\";\nimport { AiSdkTools } from \"./AiSdkTools.js\";\nimport { AiOutputToolRegistry } from \"./toolPipeline/AiOutputToolRegistry.js\";\nimport { AiToolPipelineRunner } from \"./toolPipeline/AiToolPipelineRunner.js\";\nimport { DefaultTextExtractor } from \"./TextExtractor/DefaultTextExtractor.js\";\n\nexport const AiFeature = createFeature({\n    name: \"AiFeature\",\n    register(container) {\n        container.register(OpenAiSdkFactory);\n        container.register(AnthropicSdkFactory);\n        container.register(Ai);\n        container.register(AiSdkTools);\n        container.register(AiOutputToolRegistry);\n        container.register(AiToolPipelineRunner);\n        container.register(DefaultTextExtractor);\n    }\n});\n"],"names":["AiFeature","createFeature","container","OpenAiSdkFactory","AnthropicSdkFactory","Ai","AiSdkTools","AiOutputToolRegistry","AiToolPipelineRunner","DefaultTextExtractor"],"mappings":";;;;;;;;AASO,MAAMA,YAAYC,cAAc;IACnC,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE;QACnBF,UAAU,QAAQ,CAACG;QACnBH,UAAU,QAAQ,CAACI;QACnBJ,UAAU,QAAQ,CAACK;QACnBL,UAAU,QAAQ,CAACM;QACnBN,UAAU,QAAQ,CAACO;IACvB;AACJ"}

package/features/ai/index.d.ts

@@ -0,0 +1,9 @@
+export { AiSdk, AiSdkFactory, AiConnectionFactory, Ai, AiSdkTool, AiSdkTools } from "./abstractions.js";
+export type { IAiConnection, IAiConnectionInline, AiModel, IAiSdkModel, IAiSdkTool, IAiSdkTools } from "./abstractions.js";
+export { AiOutputTool, AiOutputToolRegistry, AiToolPipelineRunner } from "./toolPipeline/index.js";
+export type { IAiOutputTool, IAiOutputToolRegistry, IAiToolPipelineRunner } from "./toolPipeline/index.js";
+export { TextExtractor, DefaultTextExtractor } from "./TextExtractor/index.js";
+export type { ITextExtractor, TextExtractorResult } from "./TextExtractor/index.js";
+export { AiBeforeGenerateTextEvent, AiBeforeGenerateTextEventHandler, AiAfterGenerateTextEvent, AiAfterGenerateTextEventHandler, AiGenerateTextErrorEvent, AiGenerateTextErrorEventHandler, AiBeforeStreamTextEvent, AiBeforeStreamTextEventHandler } from "./events.js";
+export type { AiBeforeGenerateTextPayload, AiAfterGenerateTextPayload, AiGenerateTextErrorPayload, AiBeforeStreamTextPayload } from "./events.js";
+export { AiFeature } from "./feature.js";

package/features/ai/index.js

@@ -0,0 +1,5 @@
+export { Ai, AiConnectionFactory, AiSdk, AiSdkFactory, AiSdkTool, AiSdkTools } from "./abstractions.js";
+export { AiOutputTool, AiOutputToolRegistry, AiToolPipelineRunner } from "./toolPipeline/index.js";
+export { DefaultTextExtractor, TextExtractor } from "./TextExtractor/index.js";
+export { AiAfterGenerateTextEvent, AiAfterGenerateTextEventHandler, AiBeforeGenerateTextEvent, AiBeforeGenerateTextEventHandler, AiBeforeStreamTextEvent, AiBeforeStreamTextEventHandler, AiGenerateTextErrorEvent, AiGenerateTextErrorEventHandler } from "./events.js";
+export { AiFeature } from "./feature.js";

package/features/ai/toolPipeline/AiOutputToolRegistry.d.ts

@@ -0,0 +1,11 @@
+import { type IAiOutputTool, type IAiOutputToolRegistry } from "./abstractions.js";
+declare class AiOutputToolRegistryImpl implements IAiOutputToolRegistry {
+    private toolMap;
+    constructor(tools: IAiOutputTool[]);
+    has(name: string): boolean;
+    invoke(name: string, params: Record<string, unknown>): Promise<unknown>;
+}
+export declare const AiOutputToolRegistry: typeof AiOutputToolRegistryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<IAiOutputToolRegistry>;
+};
+export {};

package/features/ai/toolPipeline/AiOutputToolRegistry.js

@@ -0,0 +1,31 @@
+import { AiOutputTool, AiOutputToolRegistry } from "./abstractions.js";
+class AiOutputToolRegistryImpl {
+    constructor(tools){
+        this.toolMap = new Map(tools.map((t)=>[
+                t.name,
+                t
+            ]));
+    }
+    has(name) {
+        return this.toolMap.has(name);
+    }
+    async invoke(name, params) {
+        const tool = this.toolMap.get(name);
+        if (!tool) return;
+        return tool.execute(params);
+    }
+}
+const AiOutputToolRegistry_AiOutputToolRegistry = AiOutputToolRegistry.createImplementation({
+    implementation: AiOutputToolRegistryImpl,
+    dependencies: [
+        [
+            AiOutputTool,
+            {
+                multiple: true
+            }
+        ]
+    ]
+});
+export { AiOutputToolRegistry_AiOutputToolRegistry as AiOutputToolRegistry };
+
+//# sourceMappingURL=AiOutputToolRegistry.js.map

package/features/ai/toolPipeline/AiOutputToolRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/ai/toolPipeline/AiOutputToolRegistry.js","sources":["../../../../src/features/ai/toolPipeline/AiOutputToolRegistry.ts"],"sourcesContent":["import {\n    AiOutputTool,\n    AiOutputToolRegistry as Abstraction,\n    type IAiOutputTool,\n    type IAiOutputToolRegistry\n} from \"./abstractions.js\";\n\nclass AiOutputToolRegistryImpl implements IAiOutputToolRegistry {\n    private toolMap: Map<string, IAiOutputTool>;\n\n    constructor(tools: IAiOutputTool[]) {\n        this.toolMap = new Map(tools.map(t => [t.name, t]));\n    }\n\n    has(name: string): boolean {\n        return this.toolMap.has(name);\n    }\n\n    async invoke(name: string, params: Record<string, unknown>): Promise<unknown> {\n        const tool = this.toolMap.get(name);\n        if (!tool) {\n            return undefined;\n        }\n        return tool.execute(params);\n    }\n}\n\nexport const AiOutputToolRegistry = Abstraction.createImplementation({\n    implementation: AiOutputToolRegistryImpl,\n    dependencies: [[AiOutputTool, { multiple: true }]]\n});\n"],"names":["AiOutputToolRegistryImpl","tools","Map","t","name","params","tool","AiOutputToolRegistry","Abstraction","AiOutputTool"],"mappings":";AAOA,MAAMA;IAGF,YAAYC,KAAsB,CAAE;QAChC,IAAI,CAAC,OAAO,GAAG,IAAIC,IAAID,MAAM,GAAG,CAACE,CAAAA,IAAK;gBAACA,EAAE,IAAI;gBAAEA;aAAE;IACrD;IAEA,IAAIC,IAAY,EAAW;QACvB,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAACA;IAC5B;IAEA,MAAM,OAAOA,IAAY,EAAEC,MAA+B,EAAoB;QAC1E,MAAMC,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAACF;QAC9B,IAAI,CAACE,MACD;QAEJ,OAAOA,KAAK,OAAO,CAACD;IACxB;AACJ;AAEO,MAAME,4CAAuBC,qBAAAA,oBAAgC,CAAC;IACjE,gBAAgBR;IAChB,cAAc;QAAC;YAACS;YAAc;gBAAE,UAAU;YAAK;SAAE;KAAC;AACtD"}

package/features/ai/toolPipeline/AiToolPipelineRunner.d.ts

@@ -0,0 +1,10 @@
+import { type IAiOutputToolRegistry, type IAiToolPipelineRunner } from "./abstractions.js";
+declare class AiToolPipelineRunnerImpl implements IAiToolPipelineRunner {
+    private registry;
+    constructor(registry: IAiOutputToolRegistry);
+    resolve(data: unknown): Promise<unknown>;
+}
+export declare const AiToolPipelineRunner: typeof AiToolPipelineRunnerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<IAiToolPipelineRunner>;
+};
+export {};

package/features/ai/toolPipeline/AiToolPipelineRunner.js

@@ -0,0 +1,36 @@
+import { AiOutputToolRegistry, AiToolPipelineRunner } from "./abstractions.js";
+function isToolEnvelope(value) {
+    return "object" == typeof value && null !== value && "tool" in value && "string" == typeof value.tool && "params" in value && "object" == typeof value.params;
+}
+class AiToolPipelineRunnerImpl {
+    constructor(registry){
+        this.registry = registry;
+    }
+    async resolve(data) {
+        if (null == data) return data;
+        if (isToolEnvelope(data)) {
+            if (!this.registry.has(data.tool)) return data;
+            const result = await this.registry.invoke(data.tool, data.params);
+            return this.resolve(result);
+        }
+        if (Array.isArray(data)) return Promise.all(data.map((item)=>this.resolve(item)));
+        if ("object" == typeof data) {
+            const entries = Object.entries(data);
+            const resolvedValues = await Promise.all(entries.map(([, value])=>this.resolve(value)));
+            return Object.fromEntries(entries.map(([key], i)=>[
+                    key,
+                    resolvedValues[i]
+                ]));
+        }
+        return data;
+    }
+}
+const AiToolPipelineRunner_AiToolPipelineRunner = AiToolPipelineRunner.createImplementation({
+    implementation: AiToolPipelineRunnerImpl,
+    dependencies: [
+        AiOutputToolRegistry
+    ]
+});
+export { AiToolPipelineRunner_AiToolPipelineRunner as AiToolPipelineRunner };
+
+//# sourceMappingURL=AiToolPipelineRunner.js.map

package/features/ai/toolPipeline/AiToolPipelineRunner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/ai/toolPipeline/AiToolPipelineRunner.js","sources":["../../../../src/features/ai/toolPipeline/AiToolPipelineRunner.ts"],"sourcesContent":["import {\n    AiOutputToolRegistry,\n    AiToolPipelineRunner as Abstraction,\n    type IAiOutputToolRegistry,\n    type IAiToolPipelineRunner\n} from \"./abstractions.js\";\n\nfunction isToolEnvelope(\n    value: unknown\n): value is { tool: string; params: Record<string, unknown> } {\n    return (\n        typeof value === \"object\" &&\n        value !== null &&\n        \"tool\" in value &&\n        typeof (value as Record<string, unknown>).tool === \"string\" &&\n        \"params\" in value &&\n        typeof (value as Record<string, unknown>).params === \"object\"\n    );\n}\n\nclass AiToolPipelineRunnerImpl implements IAiToolPipelineRunner {\n    constructor(private registry: IAiOutputToolRegistry) {}\n\n    async resolve(data: unknown): Promise<unknown> {\n        if (data === null || data === undefined) {\n            return data;\n        }\n\n        if (isToolEnvelope(data)) {\n            if (!this.registry.has(data.tool)) {\n                return data;\n            }\n            const result = await this.registry.invoke(data.tool, data.params);\n            return this.resolve(result);\n        }\n\n        if (Array.isArray(data)) {\n            return Promise.all(data.map(item => this.resolve(item)));\n        }\n\n        if (typeof data === \"object\") {\n            const entries = Object.entries(data as Record<string, unknown>);\n            const resolvedValues = await Promise.all(\n                entries.map(([, value]) => this.resolve(value))\n            );\n            return Object.fromEntries(entries.map(([key], i) => [key, resolvedValues[i]]));\n        }\n\n        return data;\n    }\n}\n\nexport const AiToolPipelineRunner = Abstraction.createImplementation({\n    implementation: AiToolPipelineRunnerImpl,\n    dependencies: [AiOutputToolRegistry]\n});\n"],"names":["isToolEnvelope","value","AiToolPipelineRunnerImpl","registry","data","result","Array","Promise","item","entries","Object","resolvedValues","key","i","AiToolPipelineRunner","Abstraction","AiOutputToolRegistry"],"mappings":";AAOA,SAASA,eACLC,KAAc;IAEd,OACI,AAAiB,YAAjB,OAAOA,SACPA,AAAU,SAAVA,SACA,UAAUA,SACV,AAAmD,YAAnD,OAAQA,MAAkC,IAAI,IAC9C,YAAYA,SACZ,AAAqD,YAArD,OAAQA,MAAkC,MAAM;AAExD;AAEA,MAAMC;IACF,YAAoBC,QAA+B,CAAE;aAAjCA,QAAQ,GAARA;IAAkC;IAEtD,MAAM,QAAQC,IAAa,EAAoB;QAC3C,IAAIA,QAAAA,MACA,OAAOA;QAGX,IAAIJ,eAAeI,OAAO;YACtB,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAACA,KAAK,IAAI,GAC5B,OAAOA;YAEX,MAAMC,SAAS,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAACD,KAAK,IAAI,EAAEA,KAAK,MAAM;YAChE,OAAO,IAAI,CAAC,OAAO,CAACC;QACxB;QAEA,IAAIC,MAAM,OAAO,CAACF,OACd,OAAOG,QAAQ,GAAG,CAACH,KAAK,GAAG,CAACI,CAAAA,OAAQ,IAAI,CAAC,OAAO,CAACA;QAGrD,IAAI,AAAgB,YAAhB,OAAOJ,MAAmB;YAC1B,MAAMK,UAAUC,OAAO,OAAO,CAACN;YAC/B,MAAMO,iBAAiB,MAAMJ,QAAQ,GAAG,CACpCE,QAAQ,GAAG,CAAC,CAAC,GAAGR,MAAM,GAAK,IAAI,CAAC,OAAO,CAACA;YAE5C,OAAOS,OAAO,WAAW,CAACD,QAAQ,GAAG,CAAC,CAAC,CAACG,IAAI,EAAEC,IAAM;oBAACD;oBAAKD,cAAc,CAACE,EAAE;iBAAC;QAChF;QAEA,OAAOT;IACX;AACJ;AAEO,MAAMU,4CAAuBC,qBAAAA,oBAAgC,CAAC;IACjE,gBAAgBb;IAChB,cAAc;QAACc;KAAqB;AACxC"}

package/features/ai/toolPipeline/abstractions.d.ts

@@ -0,0 +1,23 @@
+export interface IAiOutputTool {
+    readonly name: string;
+    execute(params: Record<string, unknown>): Promise<unknown>;
+}
+export declare const AiOutputTool: import("@webiny/di").Abstraction<IAiOutputTool>;
+export declare namespace AiOutputTool {
+    type Interface = IAiOutputTool;
+}
+export interface IAiOutputToolRegistry {
+    has(name: string): boolean;
+    invoke(name: string, params: Record<string, unknown>): Promise<unknown>;
+}
+export declare const AiOutputToolRegistry: import("@webiny/di").Abstraction<IAiOutputToolRegistry>;
+export declare namespace AiOutputToolRegistry {
+    type Interface = IAiOutputToolRegistry;
+}
+export interface IAiToolPipelineRunner {
+    resolve(data: unknown): Promise<unknown>;
+}
+export declare const AiToolPipelineRunner: import("@webiny/di").Abstraction<IAiToolPipelineRunner>;
+export declare namespace AiToolPipelineRunner {
+    type Interface = IAiToolPipelineRunner;
+}

package/features/ai/toolPipeline/abstractions.js

@@ -0,0 +1,7 @@
+import { createAbstraction } from "@webiny/feature/api";
+const AiOutputTool = createAbstraction("AiOutputTool");
+const AiOutputToolRegistry = createAbstraction("AiOutputToolRegistry");
+const AiToolPipelineRunner = createAbstraction("AiToolPipelineRunner");
+export { AiOutputTool, AiOutputToolRegistry, AiToolPipelineRunner };
+
+//# sourceMappingURL=abstractions.js.map

package/features/ai/toolPipeline/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/ai/toolPipeline/abstractions.js","sources":["../../../../src/features/ai/toolPipeline/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\n\nexport interface IAiOutputTool {\n    readonly name: string;\n    execute(params: Record<string, unknown>): Promise<unknown>;\n}\n\nexport const AiOutputTool = createAbstraction<IAiOutputTool>(\"AiOutputTool\");\n\nexport namespace AiOutputTool {\n    export type Interface = IAiOutputTool;\n}\n\nexport interface IAiOutputToolRegistry {\n    has(name: string): boolean;\n    invoke(name: string, params: Record<string, unknown>): Promise<unknown>;\n}\n\nexport const AiOutputToolRegistry =\n    createAbstraction<IAiOutputToolRegistry>(\"AiOutputToolRegistry\");\n\nexport namespace AiOutputToolRegistry {\n    export type Interface = IAiOutputToolRegistry;\n}\n\nexport interface IAiToolPipelineRunner {\n    resolve(data: unknown): Promise<unknown>;\n}\n\nexport const AiToolPipelineRunner =\n    createAbstraction<IAiToolPipelineRunner>(\"AiToolPipelineRunner\");\n\nexport namespace AiToolPipelineRunner {\n    export type Interface = IAiToolPipelineRunner;\n}\n"],"names":["AiOutputTool","createAbstraction","AiOutputToolRegistry","AiToolPipelineRunner"],"mappings":";AAOO,MAAMA,eAAeC,kBAAiC;AAWtD,MAAMC,uBACTD,kBAAyC;AAUtC,MAAME,uBACTF,kBAAyC"}

package/features/ai/toolPipeline/index.d.ts

@@ -0,0 +1,2 @@
+export { AiOutputTool, AiOutputToolRegistry, AiToolPipelineRunner } from "./abstractions.js";
+export type { IAiOutputTool, IAiOutputToolRegistry, IAiToolPipelineRunner } from "./abstractions.js";

package/features/ai/toolPipeline/index.js

@@ -0,0 +1 @@
+export { AiOutputTool, AiOutputToolRegistry, AiToolPipelineRunner } from "./abstractions.js";

package/features/buildParams/BuildParams.d.ts

@@ -0,0 +1,9 @@
+import { BuildParam, BuildParams as BuildParamsAbstraction } from "./abstractions.js";
+export declare class BuildParamsImpl implements BuildParamsAbstraction.Interface {
+    private params;
+    constructor(params: BuildParam.Interface[]);
+    get<T = any>(key: string): T | null;
+}
+export declare const BuildParams: typeof BuildParamsImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IBuildParams>;
+};

package/features/buildParams/BuildParams.js

@@ -0,0 +1,24 @@
+import { BuildParam, BuildParams } from "./abstractions.js";
+class BuildParamsImpl {
+    constructor(params){
+        this.params = params;
+    }
+    get(key) {
+        const param = this.params.find((p)=>p.key === key);
+        return param ? param.value : null;
+    }
+}
+const BuildParams_BuildParams = BuildParams.createImplementation({
+    implementation: BuildParamsImpl,
+    dependencies: [
+        [
+            BuildParam,
+            {
+                multiple: true
+            }
+        ]
+    ]
+});
+export { BuildParamsImpl, BuildParams_BuildParams as BuildParams };
+
+//# sourceMappingURL=BuildParams.js.map

package/features/buildParams/BuildParams.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/buildParams/BuildParams.js","sources":["../../../src/features/buildParams/BuildParams.ts"],"sourcesContent":["import { BuildParam, BuildParams as BuildParamsAbstraction } from \"./abstractions.js\";\n\nexport class BuildParamsImpl implements BuildParamsAbstraction.Interface {\n    constructor(private params: BuildParam.Interface[]) {}\n\n    get<T = any>(key: string): T | null {\n        const param = this.params.find(p => p.key === key);\n        return param ? param.value : null;\n    }\n}\n\nexport const BuildParams = BuildParamsAbstraction.createImplementation({\n    implementation: BuildParamsImpl,\n    dependencies: [[BuildParam, { multiple: true }]]\n});\n"],"names":["BuildParamsImpl","params","key","param","p","BuildParams","BuildParamsAbstraction","BuildParam"],"mappings":";AAEO,MAAMA;IACT,YAAoBC,MAA8B,CAAE;aAAhCA,MAAM,GAANA;IAAiC;IAErD,IAAaC,GAAW,EAAY;QAChC,MAAMC,QAAQ,IAAI,CAAC,MAAM,CAAC,IAAI,CAACC,CAAAA,IAAKA,EAAE,GAAG,KAAKF;QAC9C,OAAOC,QAAQA,MAAM,KAAK,GAAG;IACjC;AACJ;AAEO,MAAME,0BAAcC,YAAAA,oBAA2C,CAAC;IACnE,gBAAgBN;IAChB,cAAc;QAAC;YAACO;YAAY;gBAAE,UAAU;YAAK;SAAE;KAAC;AACpD"}

package/features/buildParams/abstractions.d.ts

@@ -0,0 +1,17 @@
+export interface IBuildParam {
+    key: string;
+    value: any;
+}
+/** A single build-time configuration parameter. */
+export declare const BuildParam: import("@webiny/di").Abstraction<IBuildParam>;
+export declare namespace BuildParam {
+    type Interface = IBuildParam;
+}
+export interface IBuildParams {
+    get<T = any>(key: string): T | null;
+}
+/** Access build-time configuration parameters. */
+export declare const BuildParams: import("@webiny/di").Abstraction<IBuildParams>;
+export declare namespace BuildParams {
+    type Interface = IBuildParams;
+}

package/features/buildParams/abstractions.js

@@ -0,0 +1,6 @@
+import { createAbstraction } from "@webiny/feature/api";
+const BuildParam = createAbstraction("BuildParam");
+const BuildParams = createAbstraction("BuildParams");
+export { BuildParam, BuildParams };
+
+//# sourceMappingURL=abstractions.js.map

package/features/buildParams/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/buildParams/abstractions.js","sources":["../../../src/features/buildParams/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\n\nexport interface IBuildParam {\n    key: string;\n    value: any;\n}\n\n/** A single build-time configuration parameter. */\nexport const BuildParam = createAbstraction<IBuildParam>(\"BuildParam\");\n\nexport namespace BuildParam {\n    export type Interface = IBuildParam;\n}\n\nexport interface IBuildParams {\n    get<T = any>(key: string): T | null;\n}\n\n/** Access build-time configuration parameters. */\nexport const BuildParams = createAbstraction<IBuildParams>(\"BuildParams\");\n\nexport namespace BuildParams {\n    export type Interface = IBuildParams;\n}\n"],"names":["BuildParam","createAbstraction","BuildParams"],"mappings":";AAQO,MAAMA,aAAaC,kBAA+B;AAWlD,MAAMC,cAAcD,kBAAgC"}

package/features/buildParams/feature.d.ts

@@ -0,0 +1,5 @@
+import { Container } from "@webiny/di";
+export declare const BuildParamsFeature: {
+    name: string;
+    register(container: Container): void;
+};

package/features/buildParams/feature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api";
+import { BuildParams } from "./BuildParams.js";
+const BuildParamsFeature = createFeature({
+    name: "BuildParamsFeature",
+    register (container) {
+        container.register(BuildParams);
+    }
+});
+export { BuildParamsFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/buildParams/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/buildParams/feature.js","sources":["../../../src/features/buildParams/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { Container } from \"@webiny/di\";\nimport { BuildParams } from \"./BuildParams.js\";\n\nexport const BuildParamsFeature = createFeature({\n    name: \"BuildParamsFeature\",\n    register(container: Container) {\n        container.register(BuildParams);\n    }\n});\n"],"names":["BuildParamsFeature","createFeature","container","BuildParams"],"mappings":";;AAIO,MAAMA,qBAAqBC,cAAc;IAC5C,MAAM;IACN,UAASC,SAAoB;QACzBA,UAAU,QAAQ,CAACC;IACvB;AACJ"}

package/features/buildParams/index.d.ts

@@ -0,0 +1 @@
+export { BuildParam, BuildParams } from "./abstractions.js";

package/features/buildParams/index.js

@@ -0,0 +1 @@
+export { BuildParam, BuildParams } from "./abstractions.js";

package/features/encryption/EncryptionService.d.ts

@@ -0,0 +1,10 @@
+import { Encryption as EncryptionAbstraction } from "./abstractions.js";
+import { BuildParams } from "../buildParams/abstractions.js";
+export declare class EncryptionImpl implements EncryptionAbstraction.Interface {
+    private key;
+    private algorithm;
+    constructor(buildParams: BuildParams.Interface);
+    encrypt(value: string): Promise<string>;
+    decrypt(value: string): Promise<string>;
+}
+export declare const Encryption: import("@webiny/di").Implementation<typeof EncryptionImpl>;

package/features/encryption/EncryptionService.js

@@ -0,0 +1,62 @@
+import node_crypto from "node:crypto";
+import { createImplementation } from "@webiny/feature/api";
+import { Encryption } from "./abstractions.js";
+import { BuildParams } from "../buildParams/abstractions.js";
+const DEFAULT_ALGORITHM = "aes-256-gcm";
+function keyLengthForAlgorithm(algorithm) {
+    const bits = parseInt(algorithm.split("-")[1]);
+    if (isNaN(bits)) throw new Error(`Cannot determine key length from algorithm "${algorithm}".`);
+    return bits / 8;
+}
+class EncryptionImpl {
+    constructor(buildParams){
+        const passphrase = buildParams.get("EncryptionPassphrase");
+        if (passphrase) {
+            const salt = buildParams.get("EncryptionSalt") ?? "";
+            this.algorithm = buildParams.get("EncryptionAlgorithm") ?? DEFAULT_ALGORITHM;
+            const keyLength = keyLengthForAlgorithm(this.algorithm);
+            this.key = node_crypto.scryptSync(passphrase, salt, keyLength);
+        } else {
+            this.key = null;
+            this.algorithm = DEFAULT_ALGORITHM;
+        }
+    }
+    async encrypt(value) {
+        if (!this.key) return value;
+        const iv = node_crypto.randomBytes(12);
+        const cipher = node_crypto.createCipheriv(this.algorithm, this.key, iv);
+        const encrypted = Buffer.concat([
+            cipher.update(value, "utf8"),
+            cipher.final()
+        ]);
+        const authTag = cipher.getAuthTag();
+        return Buffer.concat([
+            iv,
+            authTag,
+            encrypted
+        ]).toString("base64");
+    }
+    async decrypt(value) {
+        if (!this.key) return value;
+        const data = Buffer.from(value, "base64");
+        const iv = data.subarray(0, 12);
+        const authTag = data.subarray(12, 28);
+        const ciphertext = data.subarray(28);
+        const decipher = node_crypto.createDecipheriv(this.algorithm, this.key, iv);
+        decipher.setAuthTag(authTag);
+        return Buffer.concat([
+            decipher.update(ciphertext),
+            decipher.final()
+        ]).toString("utf8");
+    }
+}
+const EncryptionService_Encryption = createImplementation({
+    abstraction: Encryption,
+    implementation: EncryptionImpl,
+    dependencies: [
+        BuildParams
+    ]
+});
+export { EncryptionImpl, EncryptionService_Encryption as Encryption };
+
+//# sourceMappingURL=EncryptionService.js.map

package/features/encryption/EncryptionService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/encryption/EncryptionService.js","sources":["../../../src/features/encryption/EncryptionService.ts"],"sourcesContent":["import crypto from \"node:crypto\";\nimport { createImplementation } from \"@webiny/feature/api\";\nimport { Encryption as EncryptionAbstraction } from \"./abstractions.js\";\nimport { BuildParams } from \"../buildParams/abstractions.js\";\n\nconst DEFAULT_ALGORITHM = \"aes-256-gcm\";\n\nfunction keyLengthForAlgorithm(algorithm: string): number {\n    // Parse key size in bits from algorithm name (e.g. \"aes-256-gcm\" → 32 bytes).\n    const bits = parseInt(algorithm.split(\"-\")[1]);\n    if (isNaN(bits)) {\n        throw new Error(`Cannot determine key length from algorithm \"${algorithm}\".`);\n    }\n    return bits / 8;\n}\n\nexport class EncryptionImpl implements EncryptionAbstraction.Interface {\n    private key: Buffer | null;\n    private algorithm: string;\n\n    constructor(buildParams: BuildParams.Interface) {\n        const passphrase = buildParams.get<string>(\"EncryptionPassphrase\");\n\n        if (passphrase) {\n            // Salt is optional. It ensures two projects using the same passphrase derive different keys,\n            // but since passphrases should be unique per project anyway, it's extra insurance rather than a necessity.\n            const salt = buildParams.get<string>(\"EncryptionSalt\") ?? \"\";\n            this.algorithm = buildParams.get<string>(\"EncryptionAlgorithm\") ?? DEFAULT_ALGORITHM;\n            const keyLength = keyLengthForAlgorithm(this.algorithm);\n            this.key = crypto.scryptSync(passphrase, salt, keyLength);\n        } else {\n            this.key = null;\n            this.algorithm = DEFAULT_ALGORITHM;\n        }\n    }\n\n    async encrypt(value: string): Promise<string> {\n        if (!this.key) {\n            return value;\n        }\n        const iv = crypto.randomBytes(12);\n        const cipher = crypto.createCipheriv(this.algorithm, this.key, iv);\n        const encrypted = Buffer.concat([cipher.update(value, \"utf8\"), cipher.final()]);\n        const authTag = (cipher as crypto.CipherGCM).getAuthTag();\n        return Buffer.concat([iv, authTag, encrypted]).toString(\"base64\");\n    }\n\n    async decrypt(value: string): Promise<string> {\n        if (!this.key) {\n            return value;\n        }\n        const data = Buffer.from(value, \"base64\");\n        const iv = data.subarray(0, 12);\n        const authTag = data.subarray(12, 28);\n        const ciphertext = data.subarray(28);\n        const decipher = crypto.createDecipheriv(this.algorithm, this.key, iv);\n        (decipher as crypto.DecipherGCM).setAuthTag(authTag);\n        return Buffer.concat([decipher.update(ciphertext), decipher.final()]).toString(\"utf8\");\n    }\n}\n\nexport const Encryption = createImplementation({\n    abstraction: EncryptionAbstraction,\n    implementation: EncryptionImpl,\n    dependencies: [BuildParams]\n});\n"],"names":["DEFAULT_ALGORITHM","keyLengthForAlgorithm","algorithm","bits","parseInt","isNaN","Error","EncryptionImpl","buildParams","passphrase","salt","keyLength","crypto","value","iv","cipher","encrypted","Buffer","authTag","data","ciphertext","decipher","Encryption","createImplementation","EncryptionAbstraction","BuildParams"],"mappings":";;;;AAKA,MAAMA,oBAAoB;AAE1B,SAASC,sBAAsBC,SAAiB;IAE5C,MAAMC,OAAOC,SAASF,UAAU,KAAK,CAAC,IAAI,CAAC,EAAE;IAC7C,IAAIG,MAAMF,OACN,MAAM,IAAIG,MAAM,CAAC,4CAA4C,EAAEJ,UAAU,EAAE,CAAC;IAEhF,OAAOC,OAAO;AAClB;AAEO,MAAMI;IAIT,YAAYC,WAAkC,CAAE;QAC5C,MAAMC,aAAaD,YAAY,GAAG,CAAS;QAE3C,IAAIC,YAAY;YAGZ,MAAMC,OAAOF,YAAY,GAAG,CAAS,qBAAqB;YAC1D,IAAI,CAAC,SAAS,GAAGA,YAAY,GAAG,CAAS,0BAA0BR;YACnE,MAAMW,YAAYV,sBAAsB,IAAI,CAAC,SAAS;YACtD,IAAI,CAAC,GAAG,GAAGW,YAAAA,UAAiB,CAACH,YAAYC,MAAMC;QACnD,OAAO;YACH,IAAI,CAAC,GAAG,GAAG;YACX,IAAI,CAAC,SAAS,GAAGX;QACrB;IACJ;IAEA,MAAM,QAAQa,KAAa,EAAmB;QAC1C,IAAI,CAAC,IAAI,CAAC,GAAG,EACT,OAAOA;QAEX,MAAMC,KAAKF,YAAAA,WAAkB,CAAC;QAC9B,MAAMG,SAASH,YAAAA,cAAqB,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,GAAG,EAAEE;QAC/D,MAAME,YAAYC,OAAO,MAAM,CAAC;YAACF,OAAO,MAAM,CAACF,OAAO;YAASE,OAAO,KAAK;SAAG;QAC9E,MAAMG,UAAWH,OAA4B,UAAU;QACvD,OAAOE,OAAO,MAAM,CAAC;YAACH;YAAII;YAASF;SAAU,EAAE,QAAQ,CAAC;IAC5D;IAEA,MAAM,QAAQH,KAAa,EAAmB;QAC1C,IAAI,CAAC,IAAI,CAAC,GAAG,EACT,OAAOA;QAEX,MAAMM,OAAOF,OAAO,IAAI,CAACJ,OAAO;QAChC,MAAMC,KAAKK,KAAK,QAAQ,CAAC,GAAG;QAC5B,MAAMD,UAAUC,KAAK,QAAQ,CAAC,IAAI;QAClC,MAAMC,aAAaD,KAAK,QAAQ,CAAC;QACjC,MAAME,WAAWT,YAAAA,gBAAuB,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,GAAG,EAAEE;QAClEO,SAAgC,UAAU,CAACH;QAC5C,OAAOD,OAAO,MAAM,CAAC;YAACI,SAAS,MAAM,CAACD;YAAaC,SAAS,KAAK;SAAG,EAAE,QAAQ,CAAC;IACnF;AACJ;AAEO,MAAMC,+BAAaC,qBAAqB;IAC3C,aAAaC;IACb,gBAAgBjB;IAChB,cAAc;QAACkB;KAAY;AAC/B"}

package/features/encryption/abstractions.d.ts

@@ -0,0 +1,9 @@
+export interface IEncryption {
+    encrypt(value: string): Promise<string>;
+    decrypt(value: string): Promise<string>;
+}
+/** Symmetric encryption and decryption using a configured secret key. */
+export declare const Encryption: import("@webiny/di").Abstraction<IEncryption>;
+export declare namespace Encryption {
+    type Interface = IEncryption;
+}

package/features/encryption/abstractions.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const Encryption = createAbstraction("Encryption");
+export { Encryption };
+
+//# sourceMappingURL=abstractions.js.map

package/features/encryption/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/encryption/abstractions.js","sources":["../../../src/features/encryption/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\n\nexport interface IEncryption {\n    encrypt(value: string): Promise<string>;\n    decrypt(value: string): Promise<string>;\n}\n\n/** Symmetric encryption and decryption using a configured secret key. */\nexport const Encryption = createAbstraction<IEncryption>(\"Encryption\");\n\nexport namespace Encryption {\n    export type Interface = IEncryption;\n}\n"],"names":["Encryption","createAbstraction"],"mappings":";AAQO,MAAMA,aAAaC,kBAA+B"}

package/features/encryption/feature.d.ts

@@ -0,0 +1,4 @@
+export declare const EncryptionFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/encryption/feature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api";
+import { Encryption } from "./EncryptionService.js";
+const EncryptionFeature = createFeature({
+    name: "EncryptionFeature",
+    register (container) {
+        container.register(Encryption);
+    }
+});
+export { EncryptionFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/encryption/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/encryption/feature.js","sources":["../../../src/features/encryption/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { Encryption } from \"./EncryptionService.js\";\n\nexport const EncryptionFeature = createFeature({\n    name: \"EncryptionFeature\",\n    register(container) {\n        container.register(Encryption);\n    }\n});\n"],"names":["EncryptionFeature","createFeature","container","Encryption"],"mappings":";;AAGO,MAAMA,oBAAoBC,cAAc;IAC3C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;IACvB;AACJ"}

package/features/encryption/index.d.ts

@@ -0,0 +1 @@
+export { Encryption } from "./abstractions.js";

package/features/encryption/index.js

@@ -0,0 +1 @@
+export { Encryption } from "./abstractions.js";

package/features/eventPublisher/EventPublisher.d.ts

@@ -0,0 +1,7 @@
+import type { Container } from "@webiny/di";
+import { EventPublisher as Abstraction, DomainEvent } from "./abstractions.js";
+export declare class EventPublisher implements Abstraction.Interface {
+    private container;
+    constructor(container: Container);
+    publish<TEvent extends DomainEvent>(event: TEvent): Promise<void>;
+}

package/features/eventPublisher/EventPublisher.js

@@ -0,0 +1,13 @@
+class EventPublisher {
+    constructor(container){
+        this.container = container;
+    }
+    async publish(event) {
+        const handlerAbstraction = event.getHandlerAbstraction();
+        const handlers = this.container.resolveAll(handlerAbstraction);
+        for (const handler of handlers)await handler.handle(event);
+    }
+}
+export { EventPublisher };
+
+//# sourceMappingURL=EventPublisher.js.map

package/features/eventPublisher/EventPublisher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/eventPublisher/EventPublisher.js","sources":["../../../src/features/eventPublisher/EventPublisher.ts"],"sourcesContent":["import type { Container } from \"@webiny/di\";\nimport { EventPublisher as Abstraction, DomainEvent } from \"./abstractions.js\";\n\nexport class EventPublisher implements Abstraction.Interface {\n    constructor(private container: Container) {}\n\n    async publish<TEvent extends DomainEvent>(event: TEvent): Promise<void> {\n        // Get handler abstraction from the event itself\n        const handlerAbstraction = event.getHandlerAbstraction();\n\n        // Resolve ALL implementations of that abstraction\n        const handlers = this.container.resolveAll(handlerAbstraction);\n\n        // Execute all handlers\n        for (const handler of handlers) {\n            await handler.handle(event);\n        }\n    }\n}\n"],"names":["EventPublisher","container","event","handlerAbstraction","handlers","handler"],"mappings":"AAGO,MAAMA;IACT,YAAoBC,SAAoB,CAAE;aAAtBA,SAAS,GAATA;IAAuB;IAE3C,MAAM,QAAoCC,KAAa,EAAiB;QAEpE,MAAMC,qBAAqBD,MAAM,qBAAqB;QAGtD,MAAME,WAAW,IAAI,CAAC,SAAS,CAAC,UAAU,CAACD;QAG3C,KAAK,MAAME,WAAWD,SAClB,MAAMC,QAAQ,MAAM,CAACH;IAE7B;AACJ"}