@evolu/common 6.0.1-preview.9 → 7.1.0

package/src/Types.ts

@@ -22,6 +22,23 @@ import * as Kysely from "kysely";
  */
 export type Predicate<T> = (value: T) => boolean;
 
+/**
+ * Checks a condition on a value at a given index and returns a boolean.
+ *
+ * Useful for callbacks that need both the element and its position.
+ *
+ * ### Example
+ *
+ * ```ts
+ * const isEvenIndex: PredicateWithIndex<string> = (value, index) =>
+ *   index % 2 === 0;
+ *
+ * const items = ["a", "b", "c", "d"];
+ * const evenIndexItems = items.filter(isEvenIndex); // ["a", "c"]
+ * ```
+ */
+export type PredicateWithIndex<T> = (value: T, index: number) => boolean;
+
 /**
  * A type guard function that refines type `A` to a narrower type `B`.
  *
@@ -42,6 +59,31 @@ export type Predicate<T> = (value: T) => boolean;
  */
 export type Refinement<in A, out B extends A> = (a: A) => a is B;
 
+/**
+ * A type guard function that refines type `A` to a narrower type `B` at a given
+ * index.
+ *
+ * Useful for callbacks that need both the element and its position while
+ * maintaining type narrowing.
+ *
+ * ### Example
+ *
+ * ```ts
+ * type Item = { type: "number" | "string"; value: unknown };
+ *
+ * const isNumberItem: RefinementWithIndex<Item, Item & { type: "number" }> =
+ *   (item, index): item is Item & { type: "number" } =>
+ *     index > 0 && item.type === "number";
+ *
+ * const items: ReadonlyArray<Item> = [...];
+ * const [numbers, others] = partitionArray(items, isNumberItem);
+ * ```
+ */
+export type RefinementWithIndex<in A, out B extends A> = (
+  a: A,
+  index: number,
+) => a is B;
+
 /**
  * Makes properties optional if they accept `null` as a value.
  *
@@ -79,83 +121,7 @@ export type NullablePartial<
 export type IntentionalNever = never;
 
 /**
- * A utility interface for creating branded types.
- *
- * Branded types enhance type safety by differentiating otherwise identical base
- * types, such as `number` or `string`, to enforce stricter type checks.
- *
- * Supports multiple brands, allowing types to act like flags.
- *
- * ### Example 1: Single Brand
- *
- * ```ts
- * // A branded type definition
- * type UserId = number & Brand<"UserId">;
- *
- * // A function that creates `UserId` values.
- * // Casting with `as UserId` is unsafe, so `createUserId` must be unit-tested.
- * const createUserId = (): UserId => {
- *   return 123 as UserId; // Unsafe casting
- * };
- *
- * const userId = createUserId();
- *
- * // A function that accepts only `UserId`.
- * const getUser = (id: UserId) => {
- *   // Implementation
- * };
- *
- * getUser(userId); // ✅ Valid
- * getUser(123); // ❌ TypeScript error
- * getUser("123"); // ❌ TypeScript error
- * ```
- *
- * ### Example 2: Multiple Brands
- *
- * ```ts
- * // Define branded types
- * type Min1 = string & Brand<"Min1">;
- * type Max100 = string & Brand<"Max100">;
- * type Min1Max100 = string & Brand<"Min1" | "Max100">;
- *
- * // Functions requiring specific brands
- * const requiresMin1 = (value: Min1): void => {};
- * const requiresMax100 = (value: Max100): void => {};
- *
- * // Values with single brands
- * const min1Value: Min1 = "hello" as Min1;
- * const max100Value: Max100 = "world" as Max100;
- *
- * // Value with multiple brands
- * const min1Max100Value: Min1Max100 = "typescript" as Min1Max100;
- *
- * // Valid cases
- * requiresMin1(min1Value); // ✅ Valid
- * requiresMax100(max100Value); // ✅ Valid
- * requiresMin1(min1Max100Value); // ✅ Valid: Min1Max100 satisfies Min1
- * requiresMax100(min1Max100Value); // ✅ Valid: Min1Max100 satisfies Max100
- * ```
- */
-export interface Brand<B extends string> {
-  readonly [__brand]: Readonly<Record<B, true>>;
-}
-
-declare const __brand: unique symbol;
-
-/**
- * Determines whether a type `T` is a branded type.
- *
- * Works with any base type intersected with a `Brand`.
- *
- * ### Examples
- *
- * - `IsBranded<string>` -> false
- * - `IsBranded<string & Brand<"X">>` -> true
- */
-export type IsBranded<T> = T extends Brand<string> ? true : false;
-
-/**
- * String | number | bigint | boolean | undefined | null
+ * String, number, bigint, boolean, undefined, null
  *
  * https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types
  */

package/src/WebSocket.ts

@@ -1,13 +1,7 @@
-/**
- * Websocket with auto-reconnect and offline support
- *
- * @module
- */
-
-import { assertNoErrorInCatch } from "./Assert.js";
 import { constVoid } from "./Function.js";
-import { retry, RetryError, RetryOptions } from "./Promise.js";
 import { err, ok, Result } from "./Result.js";
+import { retry, RetryError, RetryOptions } from "./Task.js";
+import { maxPositiveInt } from "./Type.js";
 
 /** WebSocket with auto-reconnect and offline support. */
 export interface WebSocket extends Disposable {
@@ -20,10 +14,14 @@ export interface WebSocket extends Disposable {
   ) => Result<void, WebSocketSendError>;
 
   readonly getReadyState: () => WebSocketReadyState;
+
+  /** Returns true if the WebSocket is open and ready to send data. */
+  readonly isOpen: () => boolean;
 }
 
 /**
- * An error that occurs when trying to send data but WebSocket is connecting.
+ * An error that occurs when trying to send data but WebSocket is not available
+ * or is in the CONNECTING state.
  *
  * https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send
  */
@@ -141,8 +139,9 @@ export interface WebSocketConnectionCloseError {
  *
  * TODO:
  */
-export const createWebSocket: CreateWebSocket = (url, options = {}) => {
-  const {
+export const createWebSocket: CreateWebSocket = (
+  url,
+  {
     protocols,
     binaryType,
     onOpen,
@@ -151,14 +150,14 @@ export const createWebSocket: CreateWebSocket = (url, options = {}) => {
     onError,
     retryOptions,
     WebSocketConstructor = globalThis.WebSocket,
-  } = options;
+  } = {},
+) => {
   let isDisposed = false;
 
   const reconnectController = new AbortController();
 
   const defaultRetryOptions: RetryOptions<WebSocketRetryError> = {
-    signal: reconnectController.signal,
-    maxRetries: Infinity,
+    retries: maxPositiveInt, // Practically infinite retries
   };
 
   let socket: globalThis.WebSocket | null = null;
@@ -186,7 +185,11 @@ export const createWebSocket: CreateWebSocket = (url, options = {}) => {
    * - Is rejected when a connection is closed.
    * - Is resolved when WebSocket is disposed().
    */
-  retry(
+  void retry(
+    {
+      ...defaultRetryOptions,
+      ...retryOptions,
+    },
     (): Promise<Result<void, WebSocketRetryError>> =>
       new Promise((resolve) => {
         disposePromise = () => {
@@ -212,6 +215,7 @@ export const createWebSocket: CreateWebSocket = (url, options = {}) => {
             ? { type: "WebSocketConnectionError", event }
             : { type: "WebSocketConnectError", event };
           onError?.(error);
+
           // Trigger reconnect only on WebSocketConnectError.
           if (error.type === "WebSocketConnectError") {
             resolve(err(error));
@@ -227,20 +231,12 @@ export const createWebSocket: CreateWebSocket = (url, options = {}) => {
           onMessage?.(event.data as string | ArrayBuffer | Blob);
         };
       }),
-    {
-      ...defaultRetryOptions,
-      ...retryOptions,
-    },
-  )
-    .then((result) => {
-      if (result.ok || result.error.type === "RetryAbortError") return;
-      onError?.(result.error);
-    })
-    .catch((error: unknown) => {
-      assertNoErrorInCatch("WebSocket retry", error);
-    });
-
-  const webSocket: WebSocket = {
+  )(reconnectController).then((result) => {
+    if (result.ok || result.error.type === "AbortError") return;
+    onError?.(result.error as WebSocketError);
+  });
+
+  return {
     send: (data) => {
       // https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send
       if (!socket || socket.readyState === socket.CONNECTING) {
@@ -253,6 +249,8 @@ export const createWebSocket: CreateWebSocket = (url, options = {}) => {
     getReadyState: () =>
       socket ? nativeToStringState[socket.readyState] : "connecting",
 
+    isOpen: () => (socket ? socket.readyState === socket.OPEN : false),
+
     [Symbol.dispose]() {
       if (isDisposed) return;
       isDisposed = true;
@@ -261,8 +259,6 @@ export const createWebSocket: CreateWebSocket = (url, options = {}) => {
       disposePromise?.();
     },
   };
-
-  return webSocket;
 };
 
 const nativeToStringState: Record<number, WebSocketReadyState> = {

package/src/Worker.ts

@@ -1,9 +1,3 @@
-/**
- * Cross-platform worker abstraction
- *
- * @module
- */
-
 import { assert } from "./Assert.js";
 import { createTransferableError, TransferableError } from "./Error.js";
 
@@ -20,6 +14,32 @@ export interface WorkerPostMessageDep<Output> {
   readonly postMessage: (message: Output) => void;
 }
 
+/**
+ * Error reporting wrapper that catches synchronous errors in handlers and
+ * converts them to transferable error messages sent to the main thread.
+ */
+export type WithErrorReporting = <A extends Array<any>>(
+  handler: (...args: A) => void,
+) => (...args: A) => void;
+
+type HasInit<Input> =
+  Extract<Input, { type: "init" }> extends never
+    ? ["Input must contain a variant with { type: 'init' }"]
+    : unknown;
+
+type HasWorkerErrorOutput<T> =
+  Extract<T, { type: "onError" }> extends infer E
+    ? [E] extends [never]
+      ? [
+          "Output must contain { type: 'onError'; error: TransferableError | ... }",
+        ]
+      : E extends { error: infer Err }
+        ? TransferableError extends Err
+          ? unknown
+          : ["Output.onError.error must include TransferableError"]
+        : ["Output.onError must have an error property"]
+    : never;
+
 /**
  * Creates a {@link Worker} that supports initialization with dependencies and
  * safe error handling.
@@ -35,9 +55,7 @@ export const createInitializedWorker = <
   readonly init: (
     initMessage: Extract<Input, { type: "init" }>,
     postMessage: (msg: Output) => void,
-    safeHandler: <A extends Array<any>>(
-      handler: (...args: A) => void,
-    ) => (...args: A) => void,
+    withErrorReporting: WithErrorReporting,
   ) => Promise<Deps | null>;
   readonly onMessage: (
     deps: Deps,
@@ -62,7 +80,11 @@ export const createInitializedWorker = <
     } as unknown as Output);
   };
 
-  const safeHandler =
+  /**
+   * Wraps function to catch errors and send them to the main thread instead of
+   * crashing the worker.
+   */
+  const withErrorReporting =
     <A extends Array<any>>(handler: (...args: A) => void) =>
     (...args: A) => {
       try {
@@ -78,7 +100,7 @@ export const createInitializedWorker = <
         if (!deps) {
           pendingMessages.push(message);
         } else {
-          safeHandler(onMessage(deps))(message as NonInitMessage);
+          withErrorReporting(onMessage(deps))(message as NonInitMessage);
         }
         return;
       }
@@ -89,13 +111,13 @@ export const createInitializedWorker = <
       init(
         message as Extract<Input, { type: "init" }>,
         postMessage,
-        safeHandler,
+        withErrorReporting,
       )
         .then((_deps) => {
           if (_deps == null) return;
           deps = _deps;
           for (const message of pendingMessages) {
-            safeHandler(onMessage(deps))(message as NonInitMessage);
+            withErrorReporting(onMessage(deps))(message as NonInitMessage);
           }
           pendingMessages.length = 0;
         })
@@ -110,20 +132,41 @@ export const createInitializedWorker = <
   return worker;
 };
 
-type HasInit<Input> =
-  Extract<Input, { type: "init" }> extends never
-    ? ["Input must contain a variant with { type: 'init' }"]
-    : unknown;
+/** Type helper to extract message types from a union type */
+export type MessageHandlers<Input extends { readonly type: string }, Deps> = {
+  readonly [K in Input["type"]]: (
+    deps: Deps,
+  ) => (message: Extract<Input, { type: K }>) => void;
+};
 
-type HasWorkerErrorOutput<T> =
-  Extract<T, { type: "onError" }> extends infer E
-    ? [E] extends [never]
-      ? [
-          "Output must contain { type: 'onError'; error: TransferableError | ... }",
-        ]
-      : E extends { error: infer Err }
-        ? TransferableError extends Err
-          ? unknown
-          : ["Output.onError.error must include TransferableError"]
-        : ["Output.onError must have an error property"]
-    : never;
+/**
+ * Creates a {@link Worker} with type-safe message handlers for each message
+ * type. This provides better type safety and organization compared to a single
+ * onMessage handler.
+ */
+export const createInitializedWorkerWithHandlers = <
+  Input extends { readonly type: string } & HasInit<Input>,
+  Output extends { readonly type: string } & HasWorkerErrorOutput<Output>,
+  Deps,
+>({
+  init,
+  handlers,
+}: {
+  readonly init: (
+    initMessage: Extract<Input, { type: "init" }>,
+    postMessage: (msg: Output) => void,
+    withErrorReporting: WithErrorReporting,
+  ) => Promise<Deps | null>;
+  readonly handlers: Omit<MessageHandlers<Input, Deps>, "init">;
+}): Worker<Input, Output> =>
+  createInitializedWorker({
+    init,
+    onMessage: (deps) => (message) => {
+      type NonInitMessageType = Exclude<Input["type"], "init">;
+      const messageType = message.type as NonInitMessageType;
+      const handler = handlers[messageType];
+
+      // TypeScript knows handler exists because handlers covers all non-init message types
+      handler(deps)(message as Extract<Input, { type: typeof messageType }>);
+    },
+  });

package/src/index.ts

@@ -1,7 +1,9 @@
 export * from "./Array.js";
 export * from "./Assert.js";
 export * from "./BigInt.js";
+export * from "./Brand.js";
 export * from "./Buffer.js";
+export * from "./Cache.js";
 export * from "./Callbacks.js";
 export * from "./Console.js";
 export * from "./Crypto.js";
@@ -9,18 +11,21 @@ export * from "./Eq.js";
 export * from "./Error.js";
 export * from "./Evolu/Public.js";
 export * from "./Function.js";
-export * from "./ManyToManyMap.js";
-export * from "./NanoId.js";
+export * from "./Identicon.js";
+export * from "./Instances.js";
 export * from "./Number.js";
 export * from "./Object.js";
 export * from "./Order.js";
-export * from "./Promise.js";
+export * from "./Platform.js";
 export * from "./Random.js";
 export * from "./Ref.js";
+export * from "./Relation.js";
+export * from "./Resources.js";
 export * from "./Result.js";
 export * from "./Sqlite.js";
 export * from "./Store.js";
 export * from "./String.js";
+export * from "./Task.js";
 export * from "./Time.js";
 export * from "./Type.js";
 export * from "./Types.js";

package/dist/src/Evolu/Config.d.ts

@@ -1,69 +0,0 @@
-import { ConsoleConfig } from "../Console.js";
-import { Mnemonic, SimpleName } from "../Type.js";
-import type { DbIndexesBuilder } from "./Kysely.js";
-export interface Config extends ConsoleConfig {
-    /**
-     * The name of Evolu instances. Evolu is multitenant - it can run more
-     * instances concurrently. Every Evolu instance has to have its own unique
-     * name. Database files are separated and invisible to each other.
-     *
-     * The default value is: `Evolu`.
-     *
-     * ### Example
-     *
-     * ```ts
-     * // name: getOrThrow(SimpleName.from("MyApp"))
-     * ```
-     */
-    readonly name: SimpleName;
-    /**
-     * URL for Evolu sync and backup server.
-     *
-     * The default value is `https://free.evoluhq.com`.
-     */
-    readonly syncUrl: string;
-    /**
-     * URL to reload browser tabs after reset or restore.
-     *
-     * The default value is `/`.
-     */
-    readonly reloadUrl: string;
-    /**
-     * Maximum physical clock drift allowed in ms.
-     *
-     * The default value is 5 * 60 * 1000 (5 minutes).
-     */
-    readonly maxDrift: number;
-    /**
-     * Use the `indexes` option to define SQLite indexes.
-     *
-     * Table and column names are not typed because Kysely doesn't support it.
-     *
-     * https://medium.com/@JasonWyatt/squeezing-performance-from-sqlite-indexes-indexes-c4e175f3c346
-     *
-     * ### Example
-     *
-     * ```ts
-     * const evolu = createEvolu(evoluReactDeps)(Schema, {
-     *   indexes: (create) => [
-     *     create("todoCreatedAt").on("todo").column("createdAt"),
-     *     create("todoCategoryCreatedAt")
-     *       .on("todoCategory")
-     *       .column("createdAt"),
-     *   ],
-     * });
-     * ```
-     */
-    readonly indexes?: DbIndexesBuilder;
-    /**
-     * Use this option to create Evolu with the specified mnemonic. If omitted,
-     * the mnemonic will be autogenerated. That should be the default behavior
-     * until special UX requirements are needed (e.g., multitenancy).
-     */
-    readonly mnemonic?: Mnemonic;
-}
-export interface ConfigDep {
-    readonly config: Config;
-}
-export declare const defaultConfig: Config;
-//# sourceMappingURL=Config.d.ts.map

package/dist/src/Evolu/Config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Config.d.ts","sourceRoot":"","sources":["../../../src/Evolu/Config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAE9C,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD,MAAM,WAAW,MAAO,SAAQ,aAAa;IAC3C;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAE1B;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAEzB;;;;OAIG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAE3B;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAE1B;;;;;;;;;;;;;;;;;;;OAmBG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,gBAAgB,CAAC;IAEpC;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC;CAC9B;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,eAAO,MAAM,aAAa,EAAE,MAM3B,CAAC"}

package/dist/src/Evolu/Config.js

@@ -1,9 +0,0 @@
-import { getOrThrow } from "../Result.js";
-import { SimpleName } from "../Type.js";
-export const defaultConfig = {
-    name: getOrThrow(SimpleName.fromParent("Evolu")),
-    syncUrl: "wss://free.evoluhq.com",
-    reloadUrl: "/",
-    maxDrift: 5 * 60 * 1000,
-    enableLogging: false,
-};

package/dist/src/Evolu/Kysely.d.ts

@@ -1,6 +0,0 @@
-import { CreateIndexBuilder, Kysely } from "kysely";
-import { DbIndex } from "./Db.js";
-export declare const kysely: Kysely<unknown>;
-export type DbIndexesBuilder = (create: (indexName: string) => CreateIndexBuilder) => ReadonlyArray<CreateIndexBuilder<any>>;
-export declare const createIndexes: (indexes?: DbIndexesBuilder) => ReadonlyArray<DbIndex>;
-//# sourceMappingURL=Kysely.d.ts.map

package/dist/src/Evolu/Kysely.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Kysely.d.ts","sourceRoot":"","sources":["../../../src/Evolu/Kysely.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAElB,MAAM,EAGP,MAAM,QAAQ,CAAC;AAChB,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAGlC,eAAO,MAAM,MAAM,iBASjB,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAC7B,MAAM,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,kBAAkB,KAC9C,aAAa,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC,CAAC;AAI5C,eAAO,MAAM,aAAa,GACxB,UAAU,gBAAgB,KACzB,aAAa,CAAC,OAAO,CAQvB,CAAC"}

package/dist/src/Evolu/Kysely.js

@@ -1,21 +0,0 @@
-import { DummyDriver, Kysely, SqliteAdapter, SqliteQueryCompiler, } from "kysely";
-// https://kysely.dev/docs/recipes/splitting-query-building-and-execution
-export const kysely = new Kysely({
-    dialect: {
-        createAdapter: () => new SqliteAdapter(),
-        createDriver: () => new DummyDriver(),
-        createIntrospector() {
-            throw new Error("Not implemeneted");
-        },
-        createQueryCompiler: () => new SqliteQueryCompiler(),
-    },
-});
-const createIndex = kysely.schema.createIndex.bind(kysely.schema);
-export const createIndexes = (indexes) => {
-    if (!indexes)
-        return [];
-    return indexes(createIndex).map((index) => ({
-        name: index.toOperationNode().name.name,
-        sql: index.compile().sql,
-    }));
-};

package/dist/src/ManyToManyMap.d.ts

@@ -1,26 +0,0 @@
-/** Represents a many-to-many mapping between keys and values. */
-export interface ManyToManyMap<K, V> {
-    /** Adds a key-value association to the map. */
-    add: (key: K, value: V) => ManyToManyMap<K, V>;
-    /** Removes a specific key-value association. */
-    remove: (key: K, value: V) => boolean;
-    /** Gets all values associated with a key. */
-    getValues: (key: K) => Set<V> | undefined;
-    /** Gets all keys associated with a value. */
-    getKeys: (value: V) => Set<K> | undefined;
-    /** Checks if a specific key-value pair exists. */
-    hasPair: (key: K, value: V) => boolean;
-    /** Checks if a key exists in the map. */
-    hasKey(key: K): boolean;
-    /** Checks if a value exists in the map. */
-    hasValue: (value: V) => boolean;
-    /** Deletes all associations for a key. */
-    deleteKey: (key: K) => boolean;
-    /** Deletes all associations for a value. */
-    deleteValue: (value: V) => boolean;
-    /** Clears all associations in the map. */
-    clear(): void;
-}
-/** Creates a {@link ManyToManyMap}. */
-export declare const createManyToManyMap: <K, V>() => ManyToManyMap<K, V>;
-//# sourceMappingURL=ManyToManyMap.d.ts.map

package/dist/src/ManyToManyMap.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ManyToManyMap.d.ts","sourceRoot":"","sources":["../../src/ManyToManyMap.ts"],"names":[],"mappings":"AAAA,iEAAiE;AACjE,MAAM,WAAW,aAAa,CAAC,CAAC,EAAE,CAAC;IACjC,+CAA+C;IAC/C,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAE/C,gDAAgD;IAChD,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC;IAEtC,6CAA6C;IAC7C,SAAS,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;IAE1C,6CAA6C;IAC7C,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;IAE1C,kDAAkD;IAClD,OAAO,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC;IAEvC,yCAAyC;IACzC,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC;IAExB,2CAA2C;IAC3C,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC;IAEhC,0CAA0C;IAC1C,SAAS,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,OAAO,CAAC;IAE/B,4CAA4C;IAC5C,WAAW,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC;IAEnC,0CAA0C;IAC1C,KAAK,IAAI,IAAI,CAAC;CACf;AAED,uCAAuC;AACvC,eAAO,MAAM,mBAAmB,GAAI,CAAC,EAAE,CAAC,OAAK,aAAa,CAAC,CAAC,EAAE,CAAC,CAyG9D,CAAC"}