@evolu/common 6.0.1-preview.9 → 7.1.0

package/dist/src/Resources.js

@@ -0,0 +1,197 @@
+import { err, ok } from "./Result.js";
+import { PositiveInt } from "./Type.js";
+/**
+ * Creates {@link Resources}.
+ *
+ * This tracks which consumers are using which resources and maintains reference
+ * counts to know when it's safe to dispose resources. Resources are created
+ * on-demand and disposed with a configurable delay to avoid churn.
+ *
+ * ### Example Usage
+ *
+ * ```ts
+ * // WebSocket connections
+ * interface WebSocketConfig {
+ *   readonly url: WebSocketUrl;
+ * }
+ *
+ * type WebSocketUrl = string & Brand<"WebSocketUrl">;
+ * type UserId = string & Brand<"UserId">;
+ *
+ * const webSockets = createResources<
+ *   WebSocket,
+ *   WebSocketUrl,
+ *   WebSocketConfig,
+ *   User,
+ *   UserId
+ * >({
+ *   createResource: (config) => new WebSocket(config.url),
+ *   getResourceKey: (config) => config.url,
+ *   getConsumerId: (user) => user.id,
+ *   disposalDelay: 1000,
+ * });
+ *
+ * // Add users to WebSocket connections
+ * webSockets.addConsumer(user1, [
+ *   { url: "ws://server1.com" as WebSocketUrl },
+ *   { url: "ws://server2.com" as WebSocketUrl },
+ * ]);
+ * webSockets.addConsumer(user2, [
+ *   { url: "ws://server1.com" as WebSocketUrl },
+ * ]);
+ *
+ * // Remove users - server1 stays alive (user2 still using it)
+ * webSockets.removeConsumer(user1, [
+ *   { url: "ws://server1.com" as WebSocketUrl },
+ *   { url: "ws://server2.com" as WebSocketUrl },
+ * ]);
+ *
+ * // server2 gets disposed after delay, server1 stays alive
+ * ```
+ */
+export const createResources = (config) => {
+    let isDisposed = false;
+    const resourcesMap = new Map();
+    const consumerCounts = new Map();
+    const consumers = new Map();
+    const disposalTimeouts = new Map();
+    const disposalDelay = config.disposalDelay ?? 100;
+    const ensureResource = (resourceConfig) => {
+        const key = config.getResourceKey(resourceConfig);
+        const timeout = disposalTimeouts.get(key);
+        if (timeout) {
+            clearTimeout(timeout);
+            disposalTimeouts.delete(key);
+        }
+        if (!resourcesMap.has(key)) {
+            const resource = config.createResource(resourceConfig);
+            resourcesMap.set(key, resource);
+        }
+    };
+    const scheduleDisposal = (key) => {
+        const timeout = setTimeout(() => {
+            const resource = resourcesMap.get(key);
+            if (resource) {
+                resource[Symbol.dispose]();
+                resourcesMap.delete(key);
+            }
+            disposalTimeouts.delete(key);
+        }, disposalDelay);
+        disposalTimeouts.set(key, timeout);
+    };
+    const resources = {
+        addConsumer: (consumer, resourceConfigs) => {
+            if (isDisposed)
+                return;
+            const consumerId = config.getConsumerId(consumer);
+            // Store consumer (last added consumer for this ID)
+            consumers.set(consumerId, consumer);
+            for (const resourceConfig of resourceConfigs) {
+                ensureResource(resourceConfig);
+                const resourceKey = config.getResourceKey(resourceConfig);
+                let counts = consumerCounts.get(resourceKey);
+                if (!counts) {
+                    counts = new Map();
+                    consumerCounts.set(resourceKey, counts);
+                }
+                const currentCount = counts.get(consumerId) ?? 0;
+                const newCount = currentCount + 1;
+                counts.set(consumerId, PositiveInt.orThrow(newCount));
+                // Call onConsumerAdded callback only when consumer is added for the first time (0 -> 1)
+                if (currentCount === 0 && config.onConsumerAdded) {
+                    const resource = resourcesMap.get(resourceKey);
+                    if (resource) {
+                        config.onConsumerAdded(consumer, resource, resourceKey);
+                    }
+                }
+            }
+        },
+        removeConsumer: (consumer, resourceConfigs) => {
+            if (isDisposed)
+                return ok();
+            const consumerId = config.getConsumerId(consumer);
+            for (const resourceConfig of resourceConfigs) {
+                const key = config.getResourceKey(resourceConfig);
+                const counts = consumerCounts.get(key);
+                if (!counts) {
+                    return err({ type: "ResourceNotFoundError", resourceKey: key });
+                }
+                const currentCount = counts.get(consumerId);
+                if (currentCount == null) {
+                    return err({
+                        type: "ConsumerNotFoundError",
+                        consumerId: consumerId,
+                        resourceKey: key,
+                    });
+                }
+                if (currentCount === 1) {
+                    counts.delete(consumerId);
+                    // Call onConsumerRemoved callback only when consumer is completely removed (1 -> 0)
+                    if (config.onConsumerRemoved) {
+                        const resource = resourcesMap.get(key);
+                        if (resource) {
+                            config.onConsumerRemoved(consumer, resource, key);
+                        }
+                    }
+                    if (counts.size === 0) {
+                        consumerCounts.delete(key);
+                        scheduleDisposal(key);
+                    }
+                }
+                else {
+                    counts.set(consumerId, PositiveInt.orThrow(currentCount - 1));
+                }
+            }
+            if (!resources.hasConsumerAnyResource(consumer)) {
+                consumers.delete(consumerId);
+            }
+            return ok();
+        },
+        getResource: (key) => {
+            if (isDisposed)
+                return null;
+            return resourcesMap.get(key) ?? null;
+        },
+        getConsumersForResource: (key) => {
+            if (isDisposed)
+                return [];
+            const counts = consumerCounts.get(key);
+            return counts ? Array.from(counts.keys()) : [];
+        },
+        hasConsumerAnyResource: (consumer) => {
+            if (isDisposed)
+                return false;
+            const consumerId = config.getConsumerId(consumer);
+            // If slow, can be optimized with reverse index
+            return Array.from(consumerCounts.values()).some((counts) => counts.has(consumerId));
+        },
+        getConsumer: (consumerId) => {
+            if (isDisposed)
+                return null;
+            const consumer = consumers.get(consumerId);
+            if (!consumer)
+                return null;
+            // Only return consumer if it's currently using any resources
+            if (!resources.hasConsumerAnyResource(consumer)) {
+                return null;
+            }
+            return consumer;
+        },
+        [Symbol.dispose]: () => {
+            if (isDisposed)
+                return;
+            isDisposed = true;
+            for (const timeout of disposalTimeouts.values()) {
+                clearTimeout(timeout);
+            }
+            disposalTimeouts.clear();
+            for (const resource of resourcesMap.values()) {
+                resource[Symbol.dispose]();
+            }
+            resourcesMap.clear();
+            consumerCounts.clear();
+            consumers.clear();
+        },
+    };
+    return resources;
+};

package/dist/src/Result.d.ts

@@ -1,36 +1,17 @@
 /**
- * 🛡️ Type-safe errors
- *
- * ## Intro
- *
  * The problem with throwing an exception in JavaScript is that the caught error
  * is always of an unknown type. The unknown type is a problem because we can't
  * be sure all errors have been handled because the TypeScript compiler can't
- * help us.
- *
- * Some other languages like Rust 🦀 or Haskell 📚 use a type-safe approach to
- * error handling, where errors are explicitly represented as part of the return
- * type, such as Result or Either, allowing the developer to handle all errors
- * safely. ✅
- *
- * ✨ Evolu uses {@link Result}, and it looks like this:
- *
- * ```ts
- * type Result<T, E> = Ok<T> | Err<E>;
+ * tell us.
  *
- * interface Ok<T> {
- *   readonly ok: true;
- *   readonly value: T;
- * }
- *
- * interface Err<E> {
- *   readonly ok: false;
- *   readonly error: E;
- * }
+ * Languages like Rust or Haskell use a type-safe approach to error handling,
+ * where errors are explicitly represented as part of the return type, such as
+ * Result or Either, allowing the developer to handle errors safely. TypeScript
+ * can have this too via the `Result` type.
  *
- * const ok = <T>(value: T): Ok<T> => ({ ok: true, value });
- * const err = <E>(error: E): Err<E> => ({ ok: false, error });
- * ```
+ * The `Result` type can be either {@link Ok} (success) or {@link Err} (error).
+ * Use {@link ok} to create a successful result and {@link err} to create an error
+ * result.
  *
  * Now let's look at how `Result` can be used for safe JSON parsing:
  *
@@ -77,12 +58,10 @@
  *
  * Let's summarize it:
  *
- * - For synchronous safe code, use `ok` and `err`.
+ * - For safe code, use `ok` and `err`.
  * - For unsafe code, use `trySync` or `tryAsync`.
- * - For asynchronous safe code, use `Promise` with {@link Result}.
  *
- * Asynchronous safe (because of a Promise using Result) code is
- * straightforward:
+ * Safe asynchronous code (using Result with a Promise):
  *
  * ```ts
  * const fetchUser = async (
@@ -103,9 +82,40 @@
  * };
  * ```
  *
- * ## Examples
+ * ### Naming convention
  *
- * ### Sequential Operations with Short-Circuiting
+ * - For values: `const user = getUser()`
+ * - For a single void operation: `const result = foo()`
+ * - For multiple void operations: use descriptive names for all
+ *
+ * ```ts
+ * const processUser = () => {
+ *   // we have a value
+ *   const user = getUser();
+ *   if (!user.ok) return user;
+ *
+ *   // single void operation
+ *   const result = saveToDatabase(user.value);
+ *   if (!result.ok) return result;
+ *
+ *   return ok();
+ * };
+ *
+ * const setupDatabase = () => {
+ *   // multiple void operations - use descriptive names
+ *   const baseTables = createBaseTables();
+ *   if (!baseTables.ok) return baseTables;
+ *
+ *   const relayTables = createRelayTables();
+ *   if (!relayTables.ok) return relayTables;
+ *
+ *   return ok();
+ * };
+ * ```
+ *
+ * ### Examples
+ *
+ * #### Sequential operations with short-circuiting
  *
  * When performing a sequence of operations where any failure should stop
  * further processing, use the `Result` type with early returns.
@@ -155,37 +165,127 @@
  * This approach ensures type-safe error handling, avoids nested try/catch
  * blocks, and clearly communicates the control flow.
  *
- * ### A function with two different errors:
+ * #### A function with two different errors:
  *
  * ```ts
  * const example = (value: string): Result<number, FooError | BarError> => {
  *   const foo = getFoo(value);
  *   if (!foo.ok) return foo;
  *
- *   const bar = barize(foo.value);
+ *   const bar = getBar(foo.value);
  *   if (!bar.ok) return bar;
  *
  *   return ok(barToNumber(bar.value));
  * };
  * ```
  *
- * ## FAQ
+ * ### Handling unexpected errors
+ *
+ * Even with disciplined use of `trySync` and `tryAsync`, unexpected errors can
+ * still occur due to programming mistakes, third-party library bugs, or edge
+ * cases. These should be logged for debugging, but **unexpected errors are not
+ * recoverable** - they represent bugs that must be fixed.
+ *
+ * **Important**: "Graceful shutdown" and error recovery can only come from
+ * expected errors handled via the `Result` type. Unexpected errors should fail
+ * fast - the operation fails immediately and the error bubbles up.
+ *
+ * #### In browser environments
+ *
+ * ```ts
+ * // Global error handler for unexpected errors
+ * window.addEventListener("error", (event) => {
+ *   console.error("Uncaught error:", event.error);
+ *   // Send to error reporting service
+ *   errorReportingService.report(event.error);
+ * });
+ *
+ * // For unhandled promise rejections
+ * window.addEventListener("unhandledrejection", (event) => {
+ *   console.error("Unhandled promise rejection:", event.reason);
+ *   errorReportingService.report(event.reason);
+ * });
+ * ```
+ *
+ * #### In Node.js environments
+ *
+ * ```ts
+ * // Handle uncaught exceptions - log and fail fast
+ * process.on("uncaughtException", (error) => {
+ *   console.error("Uncaught exception:", error);
+ *   errorReportingService.report(error);
+ *   // Exit immediately - unexpected errors are not recoverable
+ *   process.exit(1);
+ * });
+ *
+ * // Handle unhandled promise rejections
+ * process.on("unhandledRejection", (reason) => {
+ *   console.error("Unhandled promise rejection:", reason);
+ *   errorReportingService.report(reason);
+ * });
+ * ```
+ *
+ * These global handlers serve as a safety net to log and report unexpected
+ * errors for debugging purposes. They do not attempt recovery - unexpected
+ * errors represent bugs that must be fixed. The discipline of explicit error
+ * handling through the `Result` pattern remains the primary approach for all
+ * recoverable scenarios.
  *
- * ### What if my function doesn't return a value on success?
+ * ### FAQ
+ *
+ * #### When should a function return a plain value instead of `Result<T, E>`?
+ *
+ * Use `Result<T, E>` only when a function can fail with **known, expected
+ * errors** that callers need to handle. If a function cannot fail with a known
+ * error, return the value directly.
+ *
+ * - ✅ Return `Result<User, UserNotFoundError>` - can fail with a known error
+ * - ✅ Return `User` - cannot fail with a known error
+ * - ❌ Don't return `Result<User, never>` - unnecessary wrapper
+ *
+ * This keeps the codebase clean and makes error handling intentional. The type
+ * system communicates which operations can fail and which cannot.
+ *
+ * Unsafe code from external libraries (not under our control) should be wrapped
+ * with `trySync` or `tryAsync` at the boundaries. Once wrapped, if the error is
+ * not important to callers, functions can safely return plain values. If the
+ * error matters, use `Result` with a typed error.
+ *
+ * ```ts
+ * // ✅ Safe to return void - unsafe code is wrapped and error is handled
+ * const processData = (data: string): void => {
+ *   const parseResult = trySync(
+ *     () => JSON.parse(data),
+ *     (error) => ({ type: "ParseError", message: String(error) }),
+ *   );
+ *
+ *   if (!parseResult.ok) {
+ *     logError(parseResult.error);
+ *     return;
+ *   }
+ *
+ *   // Continue with safe operations...
+ * };
+ *
+ * // ✅ Can call without try-catch since it returns void
+ * processData(jsonString);
+ * ```
+ *
+ * #### What if my function doesn't return a value on success?
  *
  * If your function performs an operation but doesn't need to return a value on
  * success, you can use `Result<void, E>`. Using `Result<void, E>` is clearer
  * than using `Result<true, E>` or `Result<null, E>` because it communicates
  * that the function doesn't produce a value but can produce errors.
  *
- * ### How do I short-circuit processing of an array on the first error?
+ * #### How do I short-circuit processing of an array on the first error?
  *
  * If you want to stop processing as soon as an error occurs (short-circuit),
  * you should produce and check each `Result` inside a loop:
  *
  * ```ts
  * for (const query of [
- *   sql`drop table evolu_owner;`,
+ *   sql`drop table evolu_config;`,
  *   sql`drop table evolu_message;`,
  * ]) {
  *   const result = deps.sqlite.exec(query);
@@ -194,12 +294,11 @@
  * // All queries succeeded
  * ```
  *
- * ### How do I handle an array of operations and short-circuit on the first error?
+ * #### How do I handle an array of operations and short-circuit on the first error?
  *
  * If you have an array of operations (not results), you should make them
- * _lazy_—that is, represent each operation as a function (see `LazyValue` in
- * `Function.ts`). This way, you only execute each operation as needed, and can
- * stop on the first error:
+ * _lazy_—that is, represent each operation as a function. This way, you only
+ * execute each operation as needed, and can stop on the first error:
  *
  * ```ts
  * import type { LazyValue } from "./Function";
@@ -232,16 +331,7 @@
  * above) over monadic helpers. Imperative code is generally more readable,
  * easier to debug, and more familiar to most JavaScript and TypeScript
  * developers. While monads and functional helpers can be powerful, they often
- * obscure control flow and make debugging harder. Evolu's approach keeps error
- * handling explicit and straightforward.
- *
- * @module
- */
-/**
- * A `Result` can be either {@link Ok} (success) or {@link Err} (error).
- *
- * Use {@link ok} to create a successful result and {@link err} to create an error
- * result.
+ * obscure control flow and make debugging harder.
  */
 export type Result<T, E> = Ok<T> | Err<E>;
 /** A successful {@link Result}. */
@@ -253,16 +343,16 @@ export interface Ok<T> {
  * An error {@link Result}.
  *
  * The `error` property can be any type that describes the error. For normal
- * business logic, use a plain object. This allows us to structure errors with
+ * domain logic, use a plain object. This allows us to structure errors with
  * custom fields (e.g., `{ type: "MyError", code: 123 }`). Messages for users
  * belong to translations, not to error objects.
  *
- * If you need a stacktrace for debugging, use an `Error` instance or a custom
+ * If you need a stack trace for debugging, use an `Error` instance or a custom
  * error class to include additional metadata.
  *
  * ### Examples
  *
- * #### Business Logic Error (Plain Object, Recommended)
+ * #### Domain logic error (plain object, recommended)
  *
  * ```ts
  * const failure = err({
@@ -272,13 +362,13 @@ export interface Ok<T> {
  * });
  * ```
  *
- * #### Debugging with Stack Trace (Error Instance)
+ * #### Debugging with stack trace (error instance)
  *
  * ```ts
  * const failure = err(new Error("Something went wrong"));
  * ```
  *
- * #### Custom Error Class
+ * #### Custom error class
  *
  * ```ts
  * class MyCustomError extends Error {
@@ -297,6 +387,18 @@ export interface Err<E> {
     readonly ok: false;
     readonly error: E;
 }
+/**
+ * Extracts the value type from a {@link Result}.
+ *
+ * @category Utilities
+ */
+export type InferOk<R extends Result<any, any>> = R extends Ok<infer T> ? T : never;
+/**
+ * Extracts the error type from a {@link Result}.
+ *
+ * @category Utilities
+ */
+export type InferErr<R extends Result<any, any>> = R extends Err<infer E> ? E : never;
 /**
  * Creates an {@link Ok} result.
  *
@@ -346,8 +448,33 @@ export declare const err: <E>(error: E) => Err<E>;
  * const config = getOrThrow(loadConfig());
  * // Safe to use config here
  * ```
+ *
+ * Throws: `Error` with the original error attached as `cause`.
  */
 export declare const getOrThrow: <T, E>(result: Result<T, E>) => T;
+/**
+ * Extracts the value from a {@link Result} if it is an `Ok`, or returns `null`
+ * if it is an `Err`.
+ *
+ * **Intended usage:**
+ *
+ * - When you need to convert a `Result` to a nullable value for APIs that expect
+ *   `T | null`.
+ * - When the error is not important and you just want the value or nothing.
+ *
+ * ### Example
+ *
+ * ```ts
+ * const parseResult = parseJson('{"key": "value"}');
+ * const value = getOrNull(parseResult);
+ * // value is unknown | null
+ *
+ * if (value != null) {
+ *   console.log("Parsed value:", value);
+ * }
+ * ```
+ */
+export declare const getOrNull: <T, E>(result: Result<T, E>) => T | null;
 /**
  * Wraps synchronous functions that may throw exceptions, returning a
  * {@link Result}.
@@ -368,7 +495,10 @@ export declare const getOrThrow: <T, E>(result: Result<T, E>) => T;
  * const parseJson = (value: string): Result<unknown, ParseJsonError> =>
  *   trySync(
  *     () => JSON.parse(value) as unknown,
- *     (error) => ({ type: "ParseJsonError", message: String(error) }),
+ *     (error): ParseJsonError => ({
+ *       type: "ParseJsonError",
+ *       message: String(error),
+ *     }),
  *   );
  * ```
  */

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

@@ -1 +1 @@
-{"version":3,"file":"Result.d.ts","sourceRoot":"","sources":["../../src/Result.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8OG;AAEH;;;;;GAKG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;AAE1C,mCAAmC;AACnC,MAAM,WAAW,EAAE,CAAC,CAAC;IACnB,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAClB,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,MAAM,WAAW,GAAG,CAAC,CAAC;IACpB,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IACnB,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,EAAE,IAAI,EAAE,CAAC,IAAI,CAAC,CAAC;AAC/B,2DAA2D;AAC3D,wBAAgB,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;AAKvC;;;;;;;;;GASG;AACH,eAAO,MAAM,GAAG,GAAI,CAAC,EAAE,OAAO,CAAC,KAAG,GAAG,CAAC,CAAC,CAA2B,CAAC;AAEnE;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,UAAU,GAAI,CAAC,EAAE,CAAC,EAAE,QAAQ,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,CAMvD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,EAAE,CAAC,EAC1B,IAAI,MAAM,CAAC,EACX,UAAU,CAAC,KAAK,EAAE,OAAO,KAAK,CAAC,KAC9B,MAAM,CAAC,CAAC,EAAE,CAAC,CAMb,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,eAAO,MAAM,QAAQ,GAAU,CAAC,EAAE,CAAC,EACjC,WAAW,MAAM,OAAO,CAAC,CAAC,CAAC,EAC3B,UAAU,CAAC,KAAK,EAAE,OAAO,KAAK,CAAC,KAC9B,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAIpB,CAAC"}
+{"version":3,"file":"Result.d.ts","sourceRoot":"","sources":["../../src/Result.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8UG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;AAE1C,mCAAmC;AACnC,MAAM,WAAW,EAAE,CAAC,CAAC;IACnB,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAClB,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,MAAM,WAAW,GAAG,CAAC,CAAC;IACpB,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IACnB,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;CACnB;AAED;;;;GAIG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,IAC5C,CAAC,SAAS,EAAE,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAEpC;;;;GAIG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,IAC7C,CAAC,SAAS,GAAG,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAErC;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,EAAE,IAAI,EAAE,CAAC,IAAI,CAAC,CAAC;AAC/B,2DAA2D;AAC3D,wBAAgB,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;AAKvC;;;;;;;;;GASG;AACH,eAAO,MAAM,GAAG,GAAI,CAAC,EAAE,OAAO,CAAC,KAAG,GAAG,CAAC,CAAC,CAA2B,CAAC;AAEnE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,UAAU,GAAI,CAAC,EAAE,CAAC,EAAE,QAAQ,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,CAMvD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,EAAE,CAAC,EAAE,QAAQ,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,CAAC,GAAG,IAC1B,CAAC;AAElC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,EAAE,CAAC,EAC1B,IAAI,MAAM,CAAC,EACX,UAAU,CAAC,KAAK,EAAE,OAAO,KAAK,CAAC,KAC9B,MAAM,CAAC,CAAC,EAAE,CAAC,CAMb,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,eAAO,MAAM,QAAQ,GAAU,CAAC,EAAE,CAAC,EACjC,WAAW,MAAM,OAAO,CAAC,CAAC,CAAC,EAC3B,UAAU,CAAC,KAAK,EAAE,OAAO,KAAK,CAAC,KAC9B,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAIpB,CAAC"}