@inlang/sdk 0.36.2 → 2.0.0-prerelease.0

package/src/query-utilities/pollQuery.test.ts

@@ -0,0 +1,88 @@
+import { test, expect } from "vitest";
+import { createDialect, createInMemoryDatabase } from "sqlite-wasm-kysely";
+import { Kysely } from "kysely";
+import { pollQuery } from "./pollQuery.js";
+import { firstValueFrom } from "rxjs";
+
+test("it should immediately execute the query irrespective of the interval", async () => {
+	const observable = pollQuery(() => Promise.resolve("hello"), {
+		interval: 100000,
+	});
+
+	const timeBefore = Date.now();
+	const value = await firstValueFrom(observable);
+	const timeAfter = Date.now();
+
+	expect(value).toBe("hello");
+	expect(timeAfter - timeBefore).toBeLessThan(100);
+});
+
+test("polling should work", async () => {
+	const database = await createInMemoryDatabase({});
+
+	const db = new Kysely<{
+		mock: {
+			id: string;
+			path: string;
+		};
+	}>({
+		dialect: createDialect({
+			database,
+		}),
+	});
+
+	await db.schema
+		.createTable("mock")
+		.addColumn("id", "text")
+		.addColumn("path", "text")
+		.execute();
+
+	const emittedValues: any[] = [];
+
+	const interval = 10;
+
+	const observable = pollQuery(
+		() => db.selectFrom("mock").where("id", "=", "joker").selectAll().execute(),
+		{ interval }
+	);
+
+	observable.subscribe((value) => emittedValues.push(value));
+
+	expect(emittedValues).lengthOf(0);
+
+	// first Value from should work
+	await db.insertInto("mock").values({ id: "joker", path: "batman" }).execute();
+	await firstValueFrom(observable);
+	expect(emittedValues).lengthOf(1);
+	expect(emittedValues.at(-1)).toEqual([{ id: "joker", path: "batman" }]);
+
+	// unrelated query
+	await db.insertInto("mock").values({ id: "color", path: "robin" }).execute();
+	await new Promise((resolve) => setTimeout(resolve, interval * 2));
+	await db
+		.updateTable("mock")
+		.where("id", "=", "color")
+		.set({ path: "barney" })
+		.execute();
+
+	// the observable should return the last value if a new subscripton is created.
+	// the subscription is simulated with `firstValueFrom`
+	const valueInObservable = await firstValueFrom(observable);
+	expect(emittedValues).lengthOf(1);
+	expect(emittedValues.at(-1)).toEqual([{ id: "joker", path: "batman" }]);
+	expect(valueInObservable).toEqual([{ id: "joker", path: "batman" }]);
+
+	// mutating the query of interest, this should trigger the observable
+	await db
+		.updateTable("mock")
+		.where("id", "=", "joker")
+		.set({ path: "superman" })
+		.execute();
+
+	await new Promise((resolve) => setTimeout(resolve, interval * 2));
+	const valueInObservable2 = await firstValueFrom(observable);
+
+	expect(emittedValues).lengthOf(2);
+	expect(emittedValues.at(-1)).toEqual([{ id: "joker", path: "superman" }]);
+	expect(valueInObservable2).toEqual([{ id: "joker", path: "superman" }]);
+});

package/src/query-utilities/pollQuery.ts

@@ -0,0 +1,26 @@
+import { distinctUntilChanged, from, switchMap, timer } from "rxjs";
+
+/**
+ * Polls a query at a given interval and only emits an
+ * event if the result of the query has changed.
+ *
+ * @example
+ *   pollQuery(
+ * 	   () => db.selectFrom("mock").where("id", "=", "joker").selectAll().execute(),
+ *     { interval: 100 }
+ *   ).subscribe((value) => console.log(value));
+ */
+export function pollQuery<T>(
+	query: () => Promise<T>,
+	options?: { interval?: number }
+) {
+	return timer(0, options?.interval ?? 1000).pipe(
+		switchMap(() => from(query())),
+		distinctUntilChanged(
+			// using simplified comparison because a deep equal
+			// is not worth the cost (compute, dependency, maintenance)
+			// if a false positives slip through it's not a big deal
+			(prev, curr) => JSON.stringify(prev) === JSON.stringify(curr)
+		)
+	);
+}

package/src/query-utilities/selectBundleNested.ts

@@ -0,0 +1,46 @@
+import type { Kysely } from "kysely";
+import { jsonArrayFrom } from "kysely/helpers/sqlite";
+import type { InlangDatabaseSchema } from "../database/schema.js";
+
+/**
+ * Select bundles with nested messages and variants.
+ *
+ * `{ bundle, messages: [{ message, variants: [{ variant }] }] }`
+ *
+ * @example
+ *   // getting one bundle where id is 123
+ *   await selectBundleNested(db)
+ *     .where("bundle.id", "=", "123")
+ *     .executeTakeFirst()
+ *
+ *   // getting all bundles
+ *   await selectBundleNested(db)
+ *     .execute()
+ */
+export const selectBundleNested = (db: Kysely<InlangDatabaseSchema>) => {
+	return db.selectFrom("bundle").select((eb) => [
+		// select all columns from bundle
+		"id",
+		"declarations",
+		// select all columns from messages as "messages"
+		jsonArrayFrom(
+			eb
+				.selectFrom("message")
+				.select((eb) => [
+					// select all columns from message
+					"id",
+					"bundleId",
+					"locale",
+					"selectors",
+					// select all columns from variants as "variants"
+					jsonArrayFrom(
+						eb
+							.selectFrom("variant")
+							.select(["id", "messageId", "matches", "pattern"])
+							.whereRef("variant.messageId", "=", "message.id")
+					).as("variants"),
+				])
+				.whereRef("message.bundleId", "=", "bundle.id")
+		).as("messages"),
+	]);
+};

package/src/query-utilities/updateBundleNested.ts

@@ -0,0 +1,35 @@
+import type { Kysely } from "kysely";
+import type {
+	BundleNestedUpdate,
+	InlangDatabaseSchema,
+} from "../database/schema.js";
+
+export const updateBundleNested = async (
+	db: Kysely<InlangDatabaseSchema>,
+	bundle: BundleNestedUpdate & {
+		id: string;
+		messages: { id: string; variants: { id: string }[] }[];
+	}
+): Promise<void> => {
+	await db
+		.updateTable("bundle")
+		.set(bundle)
+		.where("id", "=", bundle.id)
+		.execute();
+
+	for (const message of bundle.messages) {
+		await db
+			.updateTable("message")
+			.set(message)
+			.where("id", "=", message.id)
+			.execute();
+
+		for (const variant of message.variants) {
+			await db
+				.updateTable("variant")
+				.set(variant)
+				.where("id", "=", variant.id)
+				.execute();
+		}
+	}
+};

package/src/query-utilities/upsertBundleNested.ts

@@ -0,0 +1,61 @@
+import type { Kysely } from "kysely";
+import type {
+	InlangDatabaseSchema,
+	NewBundleNested,
+} from "../database/schema.js";
+
+export const upsertBundleNested = async (
+	db: Kysely<InlangDatabaseSchema>,
+	bundle: NewBundleNested
+): Promise<void> => {
+	await db.transaction().execute(async (trx) => {
+		const insertedBundle = await trx
+			.insertInto("bundle")
+			.values({
+				id: bundle.id,
+				declarations: bundle.declarations,
+			})
+			.returning("id")
+			.onConflict((oc) =>
+				oc.column("id").doUpdateSet({
+					...bundle,
+					// @ts-expect-error - undefined
+					messages: undefined,
+				})
+			)
+			.executeTakeFirstOrThrow();
+
+		for (const message of bundle.messages) {
+			const insertedMessage = await trx
+				.insertInto("message")
+				.values({
+					id: message.id,
+					bundleId: insertedBundle.id,
+					locale: message.locale,
+					selectors: message.selectors,
+				})
+				.onConflict((oc) =>
+					oc.column("id").doUpdateSet({
+						...message,
+						// @ts-expect-error - undefined
+						variants: undefined,
+					})
+				)
+				.returning("id")
+				.executeTakeFirstOrThrow();
+
+			for (const variant of message.variants) {
+				await trx
+					.insertInto("variant")
+					.values({
+						id: variant.id,
+						messageId: insertedMessage.id,
+						matches: variant.matches,
+						pattern: variant.pattern,
+					})
+					.onConflict((oc) => oc.column("id").doUpdateSet(variant))
+					.execute();
+			}
+		}
+	});
+};

package/src/services/env-variables/createIndexFile.js

@@ -0,0 +1,40 @@
+/* eslint-disable no-restricted-imports */
+/* eslint-disable no-undef */
+/**
+ * This script writes public environment variables
+ * to an importable env file.
+ *
+ * - The SDK must bundle this file with the rest of the SDK
+ * - This scripts avoids the need for a bundler
+ * - Must be ran before building the SDK
+ */
+
+import fs from "node:fs/promises";
+import url from "node:url";
+import path from "node:path";
+
+const dirname = path.dirname(url.fileURLToPath(import.meta.url));
+
+const packageJson = JSON.parse(
+	await fs.readFile(path.resolve(dirname, "../../../package.json"), "utf-8")
+);
+
+await fs.writeFile(
+	dirname + "/index.ts",
+	`
+export const ENV_VARIABLES = {
+  PUBLIC_POSTHOG_TOKEN: ${ifDefined(process.env.PUBLIC_POSTHOG_TOKEN)},
+	PUBLIC_INLANG_SDK_SENTRY_DSN: ${ifDefined(
+		process.env.PUBLIC_INLANG_SDK_SENTRY_DSN
+	)},
+	SDK_VERSION: ${ifDefined(packageJson.version)},
+}
+`
+);
+
+// eslint-disable-next-line no-console
+// console.log("✅ Created env variable index file.");
+
+function ifDefined(value) {
+	return value ? `"${value}"` : undefined;
+}

package/src/services/env-variables/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Avoiding TypeScript errors before the `createIndexFile` script
+ * is invoked by defining the type ahead of time.
+ */
+
+/**
+ * Env variables that are available at runtime.
+ */
+export declare const ENV_VARIABLES: {
+	PUBLIC_POSTHOG_TOKEN?: string;
+	PUBLIC_INLANG_SDK_SENTRY_DSN?: string;
+	/**
+	 * As defined in the package.json
+	 */
+	SDK_VERSION: string;
+};

package/src/services/error-reporting/index.ts

@@ -0,0 +1,28 @@
+import { init, setUser, captureException } from "@sentry/browser";
+import { ENV_VARIABLES } from "../env-variables/index.js";
+
+export function initErrorReporting(args: { projectId: string }) {
+	if (ENV_VARIABLES.PUBLIC_INLANG_SDK_SENTRY_DSN) {
+		// in order to receive alerts like "if more than 100 "users" are effected, notify the team"
+		// the user id is set to the project id
+		setUser({ id: args.projectId });
+		init({
+			dsn: ENV_VARIABLES.PUBLIC_INLANG_SDK_SENTRY_DSN,
+			release: ENV_VARIABLES.SDK_VERSION,
+		});
+	}
+}
+
+/**
+ * Capture an error.
+ *
+ * @example
+ *   try {
+ *     throw new Error("Something went wrong");
+ *   } catch (error) {
+ *     captureError(error);
+ *   }
+ */
+export function captureError(error: Error | any) {
+	return captureException(error);
+}

package/src/services/telemetry/capture.test.ts

@@ -0,0 +1,48 @@
+import { expect, test, vi } from "vitest";
+import { capture } from "./capture.js";
+
+test("it should not capture if telemetry is off", async () => {
+	// @ts-expect-error - global.fetch is not defined
+	global.fetch = vi.fn(() => Promise.resolve());
+
+	vi.mock("../env-variables/index.js", async () => {
+		return {
+			ENV_VARIABLES: {
+				PUBLIC_POSTHOG_TOKEN: "mock-defined",
+			},
+		};
+	});
+
+	await capture("SDK loaded project", {
+		projectId: "test",
+		settings: {
+			telemetry: "off",
+		},
+		properties: {},
+	});
+
+	expect(global.fetch).not.toHaveBeenCalled();
+});
+
+test("it should not capture if telemetry is NOT off", async () => {
+	// @ts-expect-error - global.fetch is not defined
+	global.fetch = vi.fn(() => Promise.resolve());
+
+	vi.mock("../env-variables/index.js", async () => {
+		return {
+			ENV_VARIABLES: {
+				PUBLIC_POSTHOG_TOKEN: "mock-defined",
+			},
+		};
+	});
+
+	await capture("SDK loaded project", {
+		projectId: "test",
+		settings: {
+			telemetry: undefined,
+		},
+		properties: {},
+	});
+
+	expect(global.fetch).toHaveBeenCalled();
+});

package/src/services/telemetry/capture.ts

@@ -0,0 +1,98 @@
+// import { ENV_VARIABLES } from "../env-variables/index.js";
+
+import type { ProjectSettings } from "../../json-schema/settings.js";
+import { ENV_VARIABLES } from "../env-variables/index.js";
+import { captureError } from "../error-reporting/index.js";
+
+/**
+ * List of telemetry events for typesafety.
+ *
+ * - prefix with `SDK` to avoid collisions with other apps
+ * - use past tense to indicate that the event is completed
+ */
+type TelemetryEvent = "SDK loaded project";
+
+/**
+ * Capture an event.
+ *
+ * - manually calling the PostHog API because the SDKs were not platform angostic (and generally bloated)
+ */
+export const capture = async (
+	event: TelemetryEvent,
+	args: {
+		projectId: string;
+		/**
+		 * Please use snake_case for property names.
+		 */
+		properties: Record<string, any>;
+		settings: Pick<ProjectSettings, "telemetry">;
+	}
+) => {
+	if (args.settings.telemetry === "off") {
+		return;
+	} else if (ENV_VARIABLES.PUBLIC_POSTHOG_TOKEN === undefined) {
+		return;
+	}
+	try {
+		await fetch("https://eu.posthog.com/capture/", {
+			method: "POST",
+			body: JSON.stringify({
+				api_key: ENV_VARIABLES.PUBLIC_POSTHOG_TOKEN,
+				event,
+				// id is "unknown" because no user information is available
+				distinct_id: "unknown",
+				properties: {
+					$groups: { project: args.projectId },
+					...args.properties,
+				},
+			}),
+		});
+		await identifyProject({
+			projectId: args.projectId,
+			// using the id for now as a name but can be changed in the future
+			// we need at least one property to make a project visible in the dashboar
+			properties: { name: args.projectId },
+		});
+	} catch (e) {
+		captureError(e);
+	}
+};
+
+/**
+ * Identifying a project is needed.
+ *
+ * Otherwise, the project will not be visible in the PostHog dashboard.
+ */
+const identifyProject = async (args: {
+	projectId: string;
+	/**
+	 * Please use snake_case for property names.
+	 */
+	properties: Record<string, any>;
+}) => {
+	// do not send events if the token is not set
+	// (assuming this eases testing)
+	if (ENV_VARIABLES.PUBLIC_POSTHOG_TOKEN === undefined) {
+		return;
+	}
+	try {
+		await fetch("https://eu.posthog.com/capture/", {
+			method: "POST",
+			body: JSON.stringify({
+				api_key: ENV_VARIABLES.PUBLIC_POSTHOG_TOKEN,
+				event: "$groupidentify",
+				// id is "unknown" because no user information is available
+				distinct_id: "unknown",
+				properties: {
+					$group_type: "project",
+					$group_key: args.projectId,
+					$group_set: {
+						...args.properties,
+					},
+				},
+			}),
+		});
+	} catch (e) {
+		captureError(e);
+	}
+};

package/src/utilities/detectJsonFormatting.test.ts

@@ -0,0 +1,38 @@
+import { expect, it } from "vitest";
+import { detectJsonFormatting } from "./detectJsonFormatting.js";
+
+it("should detect spacing", () => {
+	// test all possible spacings
+	for (const value of [1, 2, 3, 4, 6, 8, "\t"]) {
+		const spacing = value === "\t" ? "\t" : " ".repeat(value as number);
+		const objectWithSpacing = `{\n${spacing}"test": "test"\n}`;
+
+		const serialize = detectJsonFormatting(objectWithSpacing);
+		expect(serialize(JSON.parse(objectWithSpacing))).toBe(objectWithSpacing);
+	}
+});
+
+it("should detect spacing if the json is an array", () => {
+	// testing with one element only because dynamic generation of
+	// arrays with different spacings is too complex
+	const objectWithSpacing = `[\n\t"test",\n\t"test"\n]`;
+
+	const serialize = detectJsonFormatting(objectWithSpacing);
+	expect(serialize(JSON.parse(objectWithSpacing))).toBe(objectWithSpacing);
+});
+
+it("should detect new lines correctly", () => {
+	const withNewLine = `{"test":"test"}\n`;
+	const withoutNewLine = `{"test":"test"}`;
+	const withNewLineAndSpacing = `{\n\t"test": "test"\n}`;
+
+	const serialize1 = detectJsonFormatting(withNewLine);
+	const serialize2 = detectJsonFormatting(withoutNewLine);
+	const serialize3 = detectJsonFormatting(withNewLineAndSpacing);
+
+	expect(serialize1(JSON.parse(withNewLine))).toBe(withNewLine);
+	expect(serialize2(JSON.parse(withoutNewLine))).toBe(withoutNewLine);
+	expect(serialize3(JSON.parse(withNewLineAndSpacing))).toBe(
+		withNewLineAndSpacing
+	);
+});

package/src/utilities/detectJsonFormatting.ts

@@ -0,0 +1,109 @@
+/**
+ * Detects the formatting of a JSON file and returns a function
+ * that can be used to stringify JSON with the same formatting.
+ *
+ * @example
+ *   const file = await fs.readFile("./messages.json", { encoding: "utf-8" })
+ *   const stringify = detectJsonFormatting(file)
+ *   const newFile = stringify(json)
+ */
+export const detectJsonFormatting = (
+	file: string
+): ((
+	value: Parameters<typeof JSON.stringify>[0],
+	replacer?: Parameters<typeof JSON.stringify>[1]
+	// space is provided by the function
+) => string) => {
+	const endsWithNewLine = file.endsWith("\n");
+	const spacing = guessJsonIndent(file);
+
+	return (value, replacer) =>
+		JSON.stringify(value, replacer, spacing as any) +
+		(endsWithNewLine ? "\n" : "");
+};
+
+/**
+ * vendored from https://github.com/ehmicky/guess-json-indent
+ */
+// Guess the indentation of a JSON string
+const guessJsonIndent = (jsonString: string) => {
+	const firstIndex = skipWhitespaces(jsonString, 0);
+
+	if (
+		firstIndex === undefined ||
+		!isJsonObjectOrArray(jsonString[firstIndex])
+	) {
+		return;
+	}
+
+	const secondIndex = skipWhitespaces(jsonString, firstIndex + 1);
+
+	if (secondIndex === undefined) {
+		return;
+	}
+
+	return getIndent(jsonString, firstIndex, secondIndex);
+};
+
+// Whitespaces are ignored before|between|after tokens in JSON.
+// Uses imperative logic for performance.
+const skipWhitespaces = (jsonString: string | any[], startIndex: number) => {
+	for (let index = startIndex; index < jsonString.length; index += 1) {
+		const character = jsonString[index];
+
+		if (!isJsonWhitespace(character)) {
+			return index;
+		}
+	}
+	return;
+};
+
+// JSON defines only those are valid whitespaces
+const isJsonWhitespace = (character: string) =>
+	character === " " ||
+	character === "\t" ||
+	character === "\n" ||
+	character === "\r";
+
+// If the top-level value is another type than an object or an array, there is
+// no possible indentation
+const isJsonObjectOrArray = (character: string | undefined) =>
+	character === "{" || character === "[";
+
+// Uses imperative logic for performance
+// @ts-expect-error - not all code paths return a value
+const getIndent = (
+	jsonString: string | any[],
+	firstIndex: number,
+	secondIndex: number
+) => {
+	let indent;
+
+	for (let index = secondIndex - 1; index > firstIndex; index -= 1) {
+		const character = jsonString[index];
+
+		if (character === "\r") {
+			return;
+		}
+
+		if (character === "\n") {
+			return normalizeIndent(indent);
+		}
+
+		if (indent === undefined) {
+			indent = character;
+		} else if (indent[0] === character) {
+			indent += character;
+		} else {
+			return;
+		}
+	}
+};
+
+const normalizeIndent = (indent: string | any[] | undefined) => {
+	if (indent === undefined) {
+		return 0;
+	}
+
+	return indent[0] === " " ? indent.length : indent;
+};

package/dist/adapter/solidAdapter.d.ts

@@ -1,33 +0,0 @@
-import type { InlangProject, MessageLintReportsQueryApi } from "../api.js";
-import { type from as solidFrom } from "../reactivity/solid.js";
-import type { MessageQueryApi } from "@inlang/sdk";
-export declare const solidAdapter: (project: InlangProject, arg: {
-    from: typeof solidFrom;
-}) => InlangProjectWithSolidAdapter;
-export type InlangProjectWithSolidAdapter = {
-    id: InlangProject["id"];
-    customApi: () => ReturnType<InlangProject["customApi"]>;
-    installed: {
-        plugins: () => ReturnType<InlangProject["installed"]["plugins"]>;
-        messageLintRules: () => ReturnType<InlangProject["installed"]["messageLintRules"]>;
-    };
-    errors: () => ReturnType<InlangProject["errors"]>;
-    settings: () => ReturnType<InlangProject["settings"]>;
-    setSettings: InlangProject["setSettings"];
-    query: {
-        messages: {
-            create: MessageQueryApi["create"];
-            update: MessageQueryApi["update"];
-            delete: MessageQueryApi["delete"];
-            upsert: MessageQueryApi["upsert"];
-            get: MessageQueryApi["get"];
-            getAll: () => ReturnType<MessageQueryApi["getAll"]>;
-            includedMessageIds: () => ReturnType<MessageQueryApi["includedMessageIds"]>;
-        };
-        messageLintReports: {
-            get: MessageLintReportsQueryApi["get"];
-            getAll: () => ReturnType<MessageLintReportsQueryApi["getAll"]>;
-        };
-    };
-};
-//# sourceMappingURL=solidAdapter.d.ts.map

package/dist/adapter/solidAdapter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"solidAdapter.d.ts","sourceRoot":"","sources":["../../src/adapter/solidAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,0BAA0B,EAAE,MAAM,WAAW,CAAA;AAC1E,OAAO,EAAc,KAAK,IAAI,IAAI,SAAS,EAAE,MAAM,wBAAwB,CAAA;AAC3E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAElD,eAAO,MAAM,YAAY,YACf,aAAa,OACjB;IACJ,IAAI,EAAE,OAAO,SAAS,CAAA;CACtB,KACC,6BAoCF,CAAA;AAED,MAAM,MAAM,6BAA6B,GAAG;IAC3C,EAAE,EAAE,aAAa,CAAC,IAAI,CAAC,CAAA;IACvB,SAAS,EAAE,MAAM,UAAU,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC,CAAA;IACvD,SAAS,EAAE;QACV,OAAO,EAAE,MAAM,UAAU,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,CAAC,CAAA;QAChE,gBAAgB,EAAE,MAAM,UAAU,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAAA;KAClF,CAAA;IACD,MAAM,EAAE,MAAM,UAAU,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAA;IACjD,QAAQ,EAAE,MAAM,UAAU,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC,CAAA;IACrD,WAAW,EAAE,aAAa,CAAC,aAAa,CAAC,CAAA;IACzC,KAAK,EAAE;QACN,QAAQ,EAAE;YACT,MAAM,EAAE,eAAe,CAAC,QAAQ,CAAC,CAAA;YACjC,MAAM,EAAE,eAAe,CAAC,QAAQ,CAAC,CAAA;YACjC,MAAM,EAAE,eAAe,CAAC,QAAQ,CAAC,CAAA;YACjC,MAAM,EAAE,eAAe,CAAC,QAAQ,CAAC,CAAA;YACjC,GAAG,EAAE,eAAe,CAAC,KAAK,CAAC,CAAA;YAE3B,MAAM,EAAE,MAAM,UAAU,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC,CAAA;YACnD,kBAAkB,EAAE,MAAM,UAAU,CAAC,eAAe,CAAC,oBAAoB,CAAC,CAAC,CAAA;SAC3E,CAAA;QACD,kBAAkB,EAAE;YACnB,GAAG,EAAE,0BAA0B,CAAC,KAAK,CAAC,CAAA;YACtC,MAAM,EAAE,MAAM,UAAU,CAAC,0BAA0B,CAAC,QAAQ,CAAC,CAAC,CAAA;SAC9D,CAAA;KACD,CAAA;CACD,CAAA"}