every-plugin 0.0.5 → 0.1.0

package/dist/runtime/runtime.test.js

@@ -0,0 +1,378 @@
+import { Duration, Effect } from "effect";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { createPluginRuntime, PluginRuntime } from "./index";
+
+// Local template plugin for testing
+const TEST_REGISTRY = {
+	"test-plugin": {
+		remoteUrl: "http://localhost:3000/remoteEntry.js",
+		type: "transformer",
+		version: "0.0.1",
+		description: "Local template plugin for testing",
+	},
+	"invalid-plugin": {
+		remoteUrl: "https://invalid-plugin-url-that-does-not-exist.com/plugin.js",
+		type: "transformer",
+		version: "1.0.0",
+		description: "Invalid plugin for testing error handling",
+	},
+};
+const TEST_CONFIG = {
+	variables: {
+		baseUrl: "http://localhost:1337",
+		timeout: 5000,
+	},
+	secrets: {
+		apiKey: "{{API_KEY}}", // This will be hydrated from secrets config
+	},
+};
+const TEST_INPUT = {
+	query: "test query for processing",
+	options: {
+		limit: 2,
+	},
+};
+// Secrets configuration for hydration
+const SECRETS_CONFIG = {
+	API_KEY: "test-api-key-value",
+};
+describe("Plugin Runtime Integration", () => {
+	let runtime;
+	beforeEach(() => {
+		runtime = createPluginRuntime({
+			registry: TEST_REGISTRY,
+			secrets: SECRETS_CONFIG,
+		});
+	});
+	afterEach(async () => {
+		if (runtime) {
+			await runtime.dispose();
+		}
+	});
+	it("should create and execute plugin end-to-end", async () => {
+		// Execute the test within the runtime
+		const result = await runtime.runPromise(
+			Effect.gen(function* () {
+				const pluginRuntime = yield* PluginRuntime;
+				// Create plugin (load → instantiate → initialize)
+				const initializedPlugin = yield* pluginRuntime.usePlugin(
+					"test-plugin",
+					TEST_CONFIG,
+				);
+				// Verify plugin was initialized
+				expect(initializedPlugin).toBeDefined();
+				expect(initializedPlugin.metadata.pluginId).toBe("test-plugin");
+				expect(initializedPlugin.plugin).toBeDefined();
+				// Execute plugin
+				const output = yield* pluginRuntime.executePlugin(
+					initializedPlugin,
+					TEST_INPUT,
+				);
+				return output;
+			}),
+		);
+		// Validate output structure
+		expect(result).toBeDefined();
+		expect(typeof result).toBe("object");
+		const typedResult = result;
+		// Verify success wrapper structure
+		expect(typedResult).toHaveProperty("success");
+		expect(typedResult).toHaveProperty("data");
+		expect(typedResult.success).toBe(true);
+		// Verify data content
+		expect(typedResult.data).toHaveProperty("results");
+		expect(typedResult.data).toHaveProperty("count");
+		expect(Array.isArray(typedResult.data.results)).toBe(true);
+		expect(typedResult.data.count).toBe(2); // Should match the limit we set
+		expect(typedResult.data.results).toHaveLength(2);
+		// Verify results contain processed query
+		expect(typedResult.data.results[0]).toHaveProperty("id");
+		expect(typedResult.data.results[0]).toHaveProperty("content");
+		expect(typedResult.data.results[0].content).toContain(
+			"test query for processing",
+		);
+		expect(typedResult.data.results[1].content).toContain(
+			"test query for processing",
+		);
+	});
+	it("should handle plugin lifecycle correctly", async () => {
+		await runtime.runPromise(
+			Effect.gen(function* () {
+				const pluginRuntime = yield* PluginRuntime;
+				// Test individual lifecycle steps
+				// 1. Load plugin
+				const pluginConstructor =
+					yield* pluginRuntime.loadPlugin("test-plugin");
+				expect(pluginConstructor).toBeDefined();
+				expect(pluginConstructor.metadata.pluginId).toBe("test-plugin");
+				// 2. Instantiate plugin
+				const pluginInstance =
+					yield* pluginRuntime.instantiatePlugin(pluginConstructor);
+				expect(pluginInstance).toBeDefined();
+				expect(pluginInstance.plugin).toBeDefined();
+				expect(pluginInstance.metadata.pluginId).toBe("test-plugin");
+				// 3. Initialize plugin
+				const initializedPlugin = yield* pluginRuntime.initializePlugin(
+					pluginInstance,
+					TEST_CONFIG,
+				);
+				expect(initializedPlugin).toBeDefined();
+				expect(initializedPlugin.config).toBeDefined();
+				// 4. Execute plugin
+				const output = yield* pluginRuntime.executePlugin(
+					initializedPlugin,
+					TEST_INPUT,
+				);
+				expect(output).toBeDefined();
+			}),
+		);
+	});
+	it("should handle secret hydration", async () => {
+		const configWithSecrets = {
+			variables: {
+				baseUrl: "http://localhost:1337",
+				timeout: 10000,
+			},
+			secrets: {
+				apiKey: "{{API_KEY}}", // This should be hydrated
+			},
+		};
+		const secretsConfig = {
+			API_KEY: "hydrated-api-key-value",
+		};
+		const runtime = createPluginRuntime({
+			registry: TEST_REGISTRY,
+			secrets: secretsConfig,
+		});
+		await runtime.runPromise(
+			Effect.gen(function* () {
+				const pluginRuntime = yield* PluginRuntime;
+				const initializedPlugin = yield* pluginRuntime.usePlugin(
+					"test-plugin",
+					configWithSecrets,
+				);
+				// Verify secrets were hydrated in the config
+				expect(initializedPlugin.config).toBeDefined();
+				// Verify the config structure and that secrets were hydrated
+				const config = initializedPlugin.config;
+				expect(config).toHaveProperty("secrets");
+				expect(config.secrets).toHaveProperty("apiKey");
+				expect(config.secrets.apiKey).toBe("hydrated-api-key-value");
+				// Verify variables are also present
+				expect(config).toHaveProperty("variables");
+				expect(config.variables.baseUrl).toBe("http://localhost:1337");
+				expect(config.variables.timeout).toBe(10000);
+				// Verify the plugin was successfully initialized with hydrated secrets
+				// by executing it to ensure it works with the hydrated config
+				const output = yield* pluginRuntime.executePlugin(
+					initializedPlugin,
+					TEST_INPUT,
+				);
+				expect(output).toBeDefined();
+			}),
+		);
+	});
+	it("should handle validation error for missing apiKey", async () => {
+		const configWithoutApiKey = {
+			variables: {
+				baseUrl: "http://localhost:1337",
+				timeout: 5000,
+			},
+			secrets: {
+				// Missing required apiKey
+			},
+		};
+		const result = await runtime.runPromise(
+			Effect.gen(function* () {
+				const pluginRuntime = yield* PluginRuntime;
+				return yield* pluginRuntime
+					.usePlugin("test-plugin", configWithoutApiKey)
+					.pipe(
+						Effect.catchTag("PluginRuntimeError", (error) => {
+							// Should catch validation error
+							expect(error.operation).toBe("validate-config");
+							expect(error.retryable).toBe(false);
+							expect(error.pluginId).toBe("test-plugin");
+							expect(error.cause).toBeDefined();
+							// The error should mention the missing apiKey
+							const errorMessage = error.cause?.message || "";
+							// Zod validation errors might be in JSON format, so check for both formats
+							const lowerMessage = errorMessage.toLowerCase();
+							const hasApiKeyError =
+								lowerMessage.includes("api key") ||
+								lowerMessage.includes("apikey") ||
+								lowerMessage.includes("required");
+							expect(hasApiKeyError).toBe(true);
+							console.debug("Caught expected validation error:", {
+								operation: error.operation,
+								pluginId: error.pluginId,
+								retryable: error.retryable,
+								cause: error.cause?.message,
+							});
+							return Effect.succeed("validation-error-handled-properly");
+						}),
+						Effect.catchAll((unexpectedError) => {
+							console.error("Unexpected error type:", unexpectedError);
+							expect.fail(
+								`Expected PluginRuntimeError but got: ${unexpectedError._tag || typeof unexpectedError}`,
+							);
+							return Effect.succeed("should-not-reach-here");
+						}),
+					);
+			}),
+		);
+		expect(result).toBe("validation-error-handled-properly");
+	});
+	it("should handle runtime shutdown gracefully", async () => {
+		const runtime = createPluginRuntime({
+			registry: TEST_REGISTRY,
+			secrets: SECRETS_CONFIG,
+		});
+		await runtime.runPromise(
+			Effect.gen(function* () {
+				const pluginRuntime = yield* PluginRuntime;
+				// Test shutdown
+				yield* pluginRuntime.shutdown();
+				// Shutdown should complete without errors
+				expect(true).toBe(true); // If we reach here, shutdown was successful
+			}),
+		);
+	});
+	it("should handle invalid remoteUrl with proper error handling", async () => {
+		const result = await runtime.runPromise(
+			Effect.gen(function* () {
+				const pluginRuntime = yield* PluginRuntime;
+				return yield* pluginRuntime.usePlugin("invalid-plugin", {}).pipe(
+					Effect.catchTag("PluginRuntimeError", (error) => {
+						expect(error.operation).toBe("register-remote");
+						expect(error.retryable).toBe(true);
+						expect(error.pluginId).toBe("invalid-plugin");
+						expect(error.cause).toBeDefined();
+						console.debug("Caught expected PluginRuntimeError:", {
+							operation: error.operation,
+							pluginId: error.pluginId,
+							retryable: error.retryable,
+							cause: error.cause?.message,
+						});
+						return Effect.succeed("error-handled-properly");
+					}),
+					Effect.catchAll((unexpectedError) => {
+						// If any other error type is thrown, fail the test
+						console.error("Unexpected error type:", unexpectedError);
+						expect.fail(
+							`Expected PluginRuntimeError but got: ${unexpectedError._tag || typeof unexpectedError}`,
+						);
+						return Effect.succeed("should-not-reach-here");
+					}),
+				);
+			}),
+		);
+		expect(result).toBe("error-handled-properly");
+	});
+	it("should handle plugin not found in registry", async () => {
+		// Empty registry to test missing plugin
+		const EMPTY_REGISTRY = {};
+		const runtime = createPluginRuntime({
+			registry: EMPTY_REGISTRY,
+			secrets: {},
+		});
+		const result = await runtime.runPromise(
+			Effect.gen(function* () {
+				const pluginRuntime = yield* PluginRuntime;
+				return yield* pluginRuntime.loadPlugin("non-existent-plugin").pipe(
+					Effect.catchTag("PluginRuntimeError", (error) => {
+						// Validate error properties
+						expect(error.operation).toBe("load-plugin");
+						expect(error.retryable).toBe(false);
+						expect(error.pluginId).toBe("non-existent-plugin");
+						expect(error.cause).toBeDefined();
+						expect(error.cause?.message).toContain("not found in registry");
+						// Log error details for debugging
+						console.debug(
+							"Caught expected PluginRuntimeError for missing plugin:",
+							{
+								operation: error.operation,
+								pluginId: error.pluginId,
+								retryable: error.retryable,
+								cause: error.cause?.message,
+							},
+						);
+						// Return success to make test pass
+						return Effect.succeed("plugin-not-found-handled-properly");
+					}),
+					Effect.catchAll((unexpectedError) => {
+						// If any other error type is thrown, fail the test
+						console.error("Unexpected error type:", unexpectedError);
+						expect.fail(
+							`Expected PluginRuntimeError but got: ${unexpectedError._tag || typeof unexpectedError}`,
+						);
+						return Effect.succeed("should-not-reach-here");
+					}),
+				);
+			}),
+		);
+		expect(result).toBe("plugin-not-found-handled-properly");
+	});
+	it("should handle constructor instantiation failure", async () => {
+		// Registry with real remote that should fail during instantiation/initialization
+		const REAL_REMOTE_REGISTRY = {
+			"simple-transform": {
+				remoteUrl:
+					"https://unpkg.com/@curatedotfun/simple-transform@latest/dist/remoteEntry.js",
+				type: "transformer",
+				version: "latest",
+				description: "Real remote plugin for testing constructor failure",
+			},
+		};
+		const runtime = createPluginRuntime({
+			registry: REAL_REMOTE_REGISTRY,
+			secrets: {},
+		});
+		const result = await runtime.runPromise(
+			Effect.gen(function* () {
+				const pluginRuntime = yield* PluginRuntime;
+				return yield* pluginRuntime.usePlugin("simple-transform", {}).pipe(
+					Effect.timeout(Duration.seconds(1)), // Timeout after 3 seconds
+					Effect.catchTag("PluginRuntimeError", (error) => {
+						// Validate error properties
+						expect(["load-remote"]).toContain(error.operation);
+						expect(error.retryable).toBe(false);
+						expect(error.pluginId).toBe("simple-transform");
+						expect(error.cause).toBeDefined();
+						// Log error details for debugging
+						console.debug(
+							"Caught expected PluginRuntimeError for constructor failure:",
+							{
+								operation: error.operation,
+								pluginId: error.pluginId,
+								retryable: error.retryable,
+								cause: error.cause?.message,
+							},
+						);
+						// Return success to make test pass
+						return Effect.succeed("constructor-failure-handled-properly");
+					}),
+					Effect.catchTag("TimeoutException", () => {
+						// Handle timeout as expected failure - remote is too slow
+						console.debug(
+							"Plugin creation timed out - treating as expected failure",
+						);
+						return Effect.succeed("timeout-handled-properly");
+					}),
+					Effect.catchAll((unexpectedError) => {
+						// If any other error type is thrown, fail the test
+						console.error("Unexpected error type:", unexpectedError);
+						expect.fail(
+							`Expected PluginRuntimeError or TimeoutException but got: ${unexpectedError._tag || typeof unexpectedError}`,
+						);
+						return Effect.succeed("should-not-reach-here");
+					}),
+				);
+			}),
+		);
+		expect([
+			"constructor-failure-handled-properly",
+			"timeout-handled-properly",
+		]).toContain(result);
+	});
+});

package/dist/runtime/services/module-federation.service.d.ts

@@ -0,0 +1,44 @@
+import * as EffectModule from "effect";
+import { Effect } from "effect";
+import { ModuleFederationError } from "../errors";
+export interface IModuleFederationService {
+	readonly registerRemote: (
+		pluginId: string,
+		url: string,
+	) => Effect.Effect<void, ModuleFederationError>;
+	readonly loadRemoteConstructor: (
+		pluginId: string,
+		url: string,
+	) => Effect.Effect<any, ModuleFederationError>;
+}
+declare const ModuleFederationService_base: EffectModule.Context.TagClass<
+	ModuleFederationService,
+	"ModuleFederationService",
+	IModuleFederationService
+> &
+	EffectModule.Effect.Tag.Proxy<
+		ModuleFederationService,
+		IModuleFederationService
+	> & {
+		use: <X>(
+			body: (_: IModuleFederationService) => X,
+		) => [X] extends [EffectModule.Effect.Effect<infer A, infer E, infer R>]
+			? EffectModule.Effect.Effect<A, E, R | ModuleFederationService>
+			: [X] extends [PromiseLike<infer A_1>]
+				? EffectModule.Effect.Effect<
+						A_1,
+						EffectModule.Cause.UnknownException,
+						ModuleFederationService
+					>
+				: EffectModule.Effect.Effect<X, never, ModuleFederationService>;
+	};
+export declare class ModuleFederationService extends ModuleFederationService_base {
+	static Live: EffectModule.Layer.Layer<ModuleFederationService, never, never>;
+}
+export declare const ModuleFederationServiceTag: typeof ModuleFederationService;
+export declare const ModuleFederationServiceLive: EffectModule.Layer.Layer<
+	ModuleFederationService,
+	never,
+	never
+>;
+//# sourceMappingURL=module-federation.service.d.ts.map

package/dist/runtime/services/module-federation.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-federation.service.d.ts","sourceRoot":"","sources":["../../../src/runtime/services/module-federation.service.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,YAAY,MAAM,QAAQ,CAAC;AACvC,OAAO,EAAE,MAAM,EAAS,MAAM,QAAQ,CAAC;AAEvC,OAAO,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAC;AAElD,MAAM,WAAW,wBAAwB;IACxC,QAAQ,CAAC,cAAc,EAAE,CACxB,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,KACP,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,qBAAqB,CAAC,CAAC;IAChD,QAAQ,CAAC,qBAAqB,EAAE,CAC/B,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,KACP,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,qBAAqB,CAAC,CAAC;CAC/C;;;;AAyCD,qBAAa,uBAAwB,SAAQ,4BAES;IACrD,MAAM,CAAC,IAAI,kEAwFT;CACF;AAED,eAAO,MAAM,0BAA0B,gCAA0B,CAAC;AAClE,eAAO,MAAM,2BAA2B,iEAA+B,CAAC"}

package/dist/runtime/services/module-federation.service.js

@@ -0,0 +1,131 @@
+import { betterFetch } from "@better-fetch/fetch";
+import {
+	createInstance,
+	getInstance,
+} from "@module-federation/enhanced/runtime";
+import { setGlobalFederationInstance } from "@module-federation/runtime-core";
+import * as EffectModule from "effect";
+import { Effect, Layer } from "effect";
+import * as ZodModule from "zod";
+import { ModuleFederationError } from "../errors";
+
+const createModuleFederationInstance = Effect.cached(
+	Effect.sync(() => {
+		try {
+			let instance = getInstance();
+			if (!instance) {
+				instance = createInstance({
+					name: "host",
+					remotes: [],
+					shared: {
+						effect: {
+							shareConfig: {
+								singleton: true,
+								requiredVersion: "^3.17.6",
+								eager: true,
+							},
+							lib: () => EffectModule,
+						},
+						zod: {
+							shareConfig: {
+								singleton: true,
+								requiredVersion: "^4.0.8",
+								eager: true,
+							},
+							lib: () => ZodModule,
+						},
+					},
+				});
+				setGlobalFederationInstance(instance);
+			}
+			return instance;
+		} catch (error) {
+			throw new Error(`Failed to initialize Module Federation: ${error}`);
+		}
+	}),
+);
+export class ModuleFederationService extends Effect.Tag(
+	"ModuleFederationService",
+)() {
+	static Live = Layer.effect(
+		ModuleFederationService,
+		Effect.gen(function* () {
+			const mf = yield* Effect.flatten(createModuleFederationInstance);
+			return {
+				registerRemote: (pluginId, url) =>
+					Effect.gen(function* () {
+						// Check if remote is available
+						const { error } = yield* Effect.tryPromise({
+							try: () => betterFetch(url, { method: "HEAD" }),
+							catch: (error) =>
+								new ModuleFederationError({
+									pluginId,
+									remoteUrl: url,
+									cause:
+										error instanceof Error ? error : new Error(String(error)),
+								}),
+						});
+						if (error) {
+							return yield* Effect.fail(
+								new ModuleFederationError({
+									pluginId,
+									remoteUrl: url,
+									cause: new Error(`Remote not available: ${error}`),
+								}),
+							);
+						}
+						// Register remote
+						const remoteName = pluginId
+							.toLowerCase()
+							.replace("@", "")
+							.replace("/", "_");
+						yield* Effect.try({
+							try: () => mf.registerRemotes([{ name: remoteName, entry: url }]),
+							catch: (error) =>
+								new ModuleFederationError({
+									pluginId,
+									remoteUrl: url,
+									cause:
+										error instanceof Error ? error : new Error(String(error)),
+								}),
+						});
+					}),
+				loadRemoteConstructor: (pluginId, url) =>
+					Effect.gen(function* () {
+						const remoteName = pluginId
+							.toLowerCase()
+							.replace("@", "")
+							.replace("/", "_");
+						const modulePath = `${remoteName}/plugin`;
+						return yield* Effect.tryPromise({
+							try: async () => {
+								const container = await mf.loadRemote(modulePath);
+								if (!container) {
+									throw new Error(`No container returned for ${modulePath}`);
+								}
+								const Constructor =
+									typeof container === "function"
+										? container
+										: container?.default;
+								if (!Constructor || typeof Constructor !== "function") {
+									throw new Error(
+										`No valid constructor found. Container type: ${typeof container}`,
+									);
+								}
+								return Constructor;
+							},
+							catch: (error) =>
+								new ModuleFederationError({
+									pluginId,
+									remoteUrl: url,
+									cause:
+										error instanceof Error ? error : new Error(String(error)),
+								}),
+						});
+					}),
+			};
+		}),
+	);
+}
+export const ModuleFederationServiceTag = ModuleFederationService;
+export const ModuleFederationServiceLive = ModuleFederationService.Live;

package/dist/runtime/services/plugin.service.d.ts

@@ -0,0 +1,75 @@
+import { Effect, Layer } from "effect";
+import { PluginLoggerTag, type PluginRegistry } from "../../plugin";
+import { PluginRuntimeError } from "../errors";
+import type {
+	AnyPlugin,
+	InitializedPlugin,
+	PluginConstructor,
+	PluginInstance,
+	SecretsConfig,
+} from "../types";
+import { ModuleFederationService } from "./module-federation.service";
+import { SecretsService } from "./secrets.service";
+export interface IPluginService {
+	readonly loadPlugin: (
+		pluginId: string,
+	) => Effect.Effect<PluginConstructor, PluginRuntimeError>;
+	readonly instantiatePlugin: <T extends AnyPlugin>(
+		pluginConstructor: PluginConstructor,
+	) => Effect.Effect<PluginInstance<T>, PluginRuntimeError>;
+	readonly initializePlugin: <T extends AnyPlugin>(
+		pluginInstance: PluginInstance<T>,
+		config: unknown,
+	) => Effect.Effect<InitializedPlugin<T>, PluginRuntimeError>;
+	readonly executePlugin: <T extends AnyPlugin>(
+		initializedPlugin: InitializedPlugin<T>,
+		input: unknown,
+	) => Effect.Effect<any, PluginRuntimeError>;
+	readonly usePlugin: <T extends AnyPlugin>(
+		pluginId: string,
+		config: unknown,
+	) => Effect.Effect<InitializedPlugin<T>, PluginRuntimeError>;
+	readonly shutdownPlugin: (
+		plugin: InitializedPlugin<AnyPlugin>,
+	) => Effect.Effect<void, PluginRuntimeError>;
+	readonly clearCache: () => Effect.Effect<void, never>;
+	readonly cleanup: () => Effect.Effect<void, never>;
+}
+declare const PluginService_base: import("effect/Context").TagClass<
+	PluginService,
+	"PluginService",
+	IPluginService
+> &
+	Effect.Tag.Proxy<PluginService, IPluginService> & {
+		use: <X>(
+			body: (_: IPluginService) => X,
+		) => [X] extends [Effect.Effect<infer A, infer E, infer R>]
+			? Effect.Effect<A, E, R | PluginService>
+			: [X] extends [PromiseLike<infer A_1>]
+				? Effect.Effect<
+						A_1,
+						import("effect/Cause").UnknownException,
+						PluginService
+					>
+				: Effect.Effect<X, never, PluginService>;
+	};
+export declare class PluginService extends PluginService_base {
+	static Live: (
+		registry: PluginRegistry,
+		secrets: SecretsConfig,
+	) => Layer.Layer<
+		PluginService,
+		never,
+		PluginLoggerTag | SecretsService | ModuleFederationService
+	>;
+}
+export declare const PluginServiceTag: typeof PluginService;
+export declare const PluginServiceLive: (
+	registry: PluginRegistry,
+	secrets: SecretsConfig,
+) => Layer.Layer<
+	PluginService,
+	never,
+	PluginLoggerTag | SecretsService | ModuleFederationService
+>;
+//# sourceMappingURL=plugin.service.d.ts.map

package/dist/runtime/services/plugin.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.service.d.ts","sourceRoot":"","sources":["../../../src/runtime/services/plugin.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,MAAM,EAAQ,KAAK,EAAY,MAAM,QAAQ,CAAC;AACxE,OAAO,EAAE,eAAe,EAAE,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AACpE,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,KAAK,EACX,SAAS,EACT,iBAAiB,EACjB,iBAAiB,EACjB,cAAc,EACd,aAAa,EACb,MAAM,UAAU,CAAC;AAElB,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEnD,MAAM,WAAW,cAAc;IAC9B,QAAQ,CAAC,UAAU,EAAE,CACpB,QAAQ,EAAE,MAAM,KACZ,MAAM,CAAC,MAAM,CAAC,iBAAiB,EAAE,kBAAkB,CAAC,CAAC;IAC1D,QAAQ,CAAC,iBAAiB,EAAE,CAAC,CAAC,SAAS,SAAS,EAC/C,iBAAiB,EAAE,iBAAiB,KAChC,MAAM,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,kBAAkB,CAAC,CAAC;IAC1D,QAAQ,CAAC,gBAAgB,EAAE,CAAC,CAAC,SAAS,SAAS,EAC9C,cAAc,EAAE,cAAc,CAAC,CAAC,CAAC,EACjC,MAAM,EAAE,OAAO,KACX,MAAM,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAAE,kBAAkB,CAAC,CAAC;IAC7D,QAAQ,CAAC,aAAa,EAAE,CAAC,CAAC,SAAS,SAAS,EAC3C,iBAAiB,EAAE,iBAAiB,CAAC,CAAC,CAAC,EACvC,KAAK,EAAE,OAAO,KACV,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,kBAAkB,CAAC,CAAC;IAC5C,QAAQ,CAAC,SAAS,EAAE,CAAC,CAAC,SAAS,SAAS,EACvC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,OAAO,KACX,MAAM,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAAE,kBAAkB,CAAC,CAAC;IAC7D,QAAQ,CAAC,cAAc,EAAE,CAAC,MAAM,EAAE,iBAAiB,CAAC,SAAS,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,kBAAkB,CAAC,CAAC;IAC3G,QAAQ,CAAC,UAAU,EAAE,MAAM,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IACtD,QAAQ,CAAC,OAAO,EAAE,MAAM,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;CACnD;;;;AAED,qBAAa,aAAc,SAAQ,kBAGhC;IACF,MAAM,CAAC,IAAI,GAAI,UAAU,cAAc,EAAE,SAAS,aAAa,mGAiY5D;CACH;AAED,eAAO,MAAM,gBAAgB,sBAAgB,CAAC;AAC9C,eAAO,MAAM,iBAAiB,aArYJ,cAAc,WAAW,aAAa,kGAqYb,CAAC"}