@mtkruto/browser 0.142.0 → 0.144.0

package/esm/client/6_client_dispatcher.js

@@ -399,7 +399,7 @@ export class ClientDispatcher extends Composer {
         return await this.#dispatch("updateProfile", params);
     }
     /**
-     * Update the profile photo of the current user.
+     * Update the profile photo of the current user or a bot managed by the current user.
      *
      * @method ac
      * @param photo The photo to set as profile photo.
@@ -408,7 +408,7 @@ export class ClientDispatcher extends Composer {
         return await this.#dispatch("updateProfilePhoto", photo, params);
     }
     /**
-     * Update the profile video of the current user.
+     * Update the profile video of the current user or a bot managed by the current user.
      *
      * @method ac
      * @param video The video to set as profile video.
@@ -416,6 +416,14 @@ export class ClientDispatcher extends Composer {
     async updateProfileVideo(video, params) {
         return await this.#dispatch("updateProfileVideo", video, params);
     }
+    /**
+     * Remove the profile video of the current user or a bot managed by the current user.
+     *
+     * @method ac
+     */
+    async removeProfilePhoto(params) {
+        return await this.#dispatch("removeProfilePhoto", params);
+    }
     /**
      * Set the birthday of the current user. User-only.
      *
@@ -666,6 +674,18 @@ export class ClientDispatcher extends Composer {
     async sendPhoto(chatId, photo, params) {
         return await this.#dispatch("sendPhoto", chatId, photo, params);
     }
+    /**
+     * Send a live photo.
+     *
+     * @method ms
+     * @param chatId The identifier of a chat to send the photo to.
+     * @param photo The photo to send.
+     * @param photo The video version of the photo.
+     * @returns The sent live photo.
+     */
+    async sendLivePhoto(chatId, photo, video, params) {
+        return await this.#dispatch("sendLivePhoto", chatId, photo, video, params);
+    }
     /**
      * Send a document.
      *
@@ -2351,6 +2371,27 @@ export class ClientDispatcher extends Composer {
     async removeReaction(chatId, messageId, reaction) {
         return await this.#dispatch("removeReaction", chatId, messageId, reaction);
     }
+    /**
+     * Undo a reaction by another user.
+     *
+     * @method re
+     * @param chatId The identifier of the chat which the message belongs to.
+     * @param messageId The identifier of the message which the reaction was made to.
+     * @param userId The identifier of the user who made the reaction.
+     */
+    async removeUserReaction(chatId, messageId, userId) {
+        return await this.#dispatch("removeUserReaction", chatId, messageId, userId);
+    }
+    /**
+     * Undo recent reactions to messages made by another user.
+     *
+     * @method re
+     * @param chatId The identifier of the chat which the messages belongs to.
+     * @param userId The identifier of the user who made the reactions.
+     */
+    async removeUserReactions(chatId, userId) {
+        return await this.#dispatch("removeUserReactions", chatId, userId);
+    }
     /**
      * Clear recent reactions. User-only.
      *
@@ -3096,4 +3137,36 @@ export class ClientDispatcher extends Composer {
     async revokeManagedBotToken(userId) {
         return await this.#dispatch("revokeManagedBotToken", userId);
     }
+    /**
+     * Set the access settings of a managed bot. Bot-only.
+     *
+     * @method mb
+     * @param userId The identifier of the bot user.
+     * @param isAccessRestricted Whether access is restricted to specific users.
+     */
+    async setManagedBotAccessSettings(userId, isAccessRestricted, params) {
+        return await this.#dispatch("setManagedBotAccessSettings", userId, isAccessRestricted, params);
+    }
+    /**
+     * Set the access settings of a managed bot. Bot-only.
+     *
+     * @method mb
+     * @param userId The identifier of the bot user.
+     */
+    async getManagedBotAccessSettings(userId) {
+        return await this.#dispatch("getManagedBotAccessSettings", userId);
+    }
+    //
+    // ========================= GUEST QUERIES ========================= //
+    //
+    /**
+     * Answer a guest query. Bot-only.
+     *
+     * @method gq
+     * @param id The identifier of the guest query to answer.
+     * @returns The identifier of the sent message.
+     */
+    async answerGuestQuery(id, result) {
+        return await this.#dispatch("answerGuestQuery", id, result);
+    }
 }

package/esm/connection/1_connection_web_socket.d.ts

@@ -25,7 +25,7 @@ export declare class ConnectionWebSocket implements Connection {
     get isConnected(): boolean;
     open(): Promise<void>;
     read(p: Uint8Array): Promise<void>;
-    write(p: Uint8Array): Promise<void>;
+    write(p: Uint8Array<ArrayBuffer>): Promise<void>;
     close(): void;
 }
 //# sourceMappingURL=1_connection_web_socket.d.ts.map

package/esm/connection/1_connection_web_socket.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"1_connection_web_socket.d.ts","sourceRoot":"","sources":["../../src/connection/1_connection_web_socket.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAKH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAKpD,qBAAa,mBAAoB,YAAW,UAAU;;IAOpD,kBAAkB,CAAC,EAAE,UAAU,CAAC,oBAAoB,CAAC,CAAC;gBAE1C,GAAG,EAAE,MAAM;IA8CvB,IAAI,WAAW,IAAI,OAAO,CAEzB;IAGK,IAAI;IAmBJ,IAAI,CAAC,CAAC,EAAE,UAAU;IAgBlB,KAAK,CAAC,CAAC,EAAE,UAAU;IAkBzB,KAAK;CAMN"}
+{"version":3,"file":"1_connection_web_socket.d.ts","sourceRoot":"","sources":["../../src/connection/1_connection_web_socket.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAKH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAKpD,qBAAa,mBAAoB,YAAW,UAAU;;IAOpD,kBAAkB,CAAC,EAAE,UAAU,CAAC,oBAAoB,CAAC,CAAC;gBAE1C,GAAG,EAAE,MAAM;IA8CvB,IAAI,WAAW,IAAI,OAAO,CAEzB;IAGK,IAAI;IAmBJ,IAAI,CAAC,CAAC,EAAE,UAAU;IAgBlB,KAAK,CAAC,CAAC,EAAE,UAAU,CAAC,WAAW,CAAC;IAkBtC,KAAK;CAMN"}

package/{script/deps/jsr.io/@std/async/1.2.0 → esm/deps/jsr.io/@std/async/1.3.0}/delay.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"delay.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/async/1.2.0/delay.ts"],"names":[],"mappings":"AAGA,qCAAqC;AACrC,MAAM,WAAW,YAAY;IAC3B,sCAAsC;IACtC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAKD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,GAAE,YAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CA2B3E"}
+{"version":3,"file":"delay.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/async/1.3.0/delay.ts"],"names":[],"mappings":"AAGA,qCAAqC;AACrC,MAAM,WAAW,YAAY;IAC3B,sCAAsC;IACtC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAKD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,GAAE,YAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CA2B3E"}

package/{script/deps/jsr.io/@std/async/1.2.0 → esm/deps/jsr.io/@std/async/1.3.0}/pool.d.ts

@@ -25,9 +25,11 @@
  * @typeParam T the input type.
  * @typeParam R the output type.
  * @param poolLimit The maximum count of items being processed concurrently.
+ * Must be a positive integer.
  * @param array The input array for mapping.
  * @param iteratorFn The function to call for every item of the array.
  * @returns The async iterator with the transformed values.
+ * @throws {RangeError} If `poolLimit` is not a positive integer.
  */
 export declare function pooledMap<T, R>(poolLimit: number, array: Iterable<T> | AsyncIterable<T>, iteratorFn: (data: T) => Promise<R>): AsyncIterableIterator<R>;
 //# sourceMappingURL=pool.d.ts.map

package/esm/deps/jsr.io/@std/async/1.3.0/pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pool.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/async/1.3.0/pool.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAC5B,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,EACrC,UAAU,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,GAClC,qBAAqB,CAAC,CAAC,CAAC,CAwE1B"}

package/esm/deps/jsr.io/@std/async/{1.2.0 → 1.3.0}/pool.js

@@ -29,12 +29,16 @@ const ERROR_WHILE_MAPPING_MESSAGE = "Cannot complete the mapping as an error was
  * @typeParam T the input type.
  * @typeParam R the output type.
  * @param poolLimit The maximum count of items being processed concurrently.
+ * Must be a positive integer.
  * @param array The input array for mapping.
  * @param iteratorFn The function to call for every item of the array.
  * @returns The async iterator with the transformed values.
+ * @throws {RangeError} If `poolLimit` is not a positive integer.
  */
 export function pooledMap(poolLimit, array, iteratorFn) {
-    // Create the async iterable that is returned from this function.
+    if (!Number.isInteger(poolLimit) || poolLimit < 1) {
+        throw new RangeError("'poolLimit' must be a positive integer");
+    }
     const res = new TransformStream({
         async transform(p, controller) {
             try {

package/esm/deps/jsr.io/@std/cache/{0.2.2 → 0.2.3}/_serialize_arg_list.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"_serialize_arg_list.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/cache/0.2.2/_serialize_arg_list.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAErD;;;;;;;;GAQG;AAEH,wBAAgB,iBAAiB,CAAC,MAAM,EACtC,KAAK,EAAE,gBAAgB,CAAC,OAAO,EAAE,MAAM,CAAC,GACvC,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,MAAM,CAmE/C"}
+{"version":3,"file":"_serialize_arg_list.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/cache/0.2.3/_serialize_arg_list.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAErD;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EACtC,KAAK,EAAE,gBAAgB,CAAC,OAAO,EAAE,MAAM,CAAC,GACvC,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,MAAM,CAgF/C"}

package/esm/deps/jsr.io/@std/cache/{0.2.2 → 0.2.3}/_serialize_arg_list.js

@@ -8,9 +8,17 @@
  * @returns `getKey`, the function for getting cache keys.
  */
 export function _serializeArgList(cache) {
+    // Three cooperating data structures track weak (reference-type) arguments:
+    //   1. weakKeyToKeySegmentCache: WeakMap from object/symbol → segment id
+    //      (e.g. `"{0}"`) so the same reference always maps to the same segment.
+    //   2. weakKeySegmentToKeyCache: Map from segment id → set of composite cache
+    //      keys that contain that segment, used by the finalization callback.
+    //   3. registry (FinalizationRegistry): when a weak key is garbage-collected,
+    //      looks up its segment in (2) and deletes all associated entries from the
+    //      caller-provided cache.
     const weakKeyToKeySegmentCache = new WeakMap();
     const weakKeySegmentToKeyCache = new Map();
-    let i = 0;
+    let nextWeakKeyId = 0;
     const registry = new FinalizationRegistry((keySegment) => {
         for (const key of weakKeySegmentToKeyCache.get(keySegment) ?? []) {
             cache.delete(key);
@@ -35,35 +43,38 @@ export function _serializeArgList(cache) {
                 // e.g. https://github.com/tc39/proposal-record-tuple
                 return JSON.stringify(arg);
             }
+            if (typeof arg === "symbol") {
+                try {
+                    new WeakRef(arg);
+                }
+                catch {
+                    return `Symbol.for(${JSON.stringify(arg.description)})`;
+                }
+            }
             try {
-                assertWeakKey(arg);
+                new WeakRef(arg);
             }
             catch {
-                if (typeof arg === "symbol") {
-                    return `Symbol.for(${JSON.stringify(arg.description)})`;
-                }
-                // Non-weak keys other than `Symbol.for(...)` are handled by the branches above.
                 throw new Error("Should be unreachable: please open an issue at https://github.com/denoland/std/issues/new");
             }
-            if (!weakKeyToKeySegmentCache.has(arg)) {
-                const keySegment = `{${i++}}`;
-                weakKeySegments.push(keySegment);
+            let keySegment = weakKeyToKeySegmentCache.get(arg);
+            if (keySegment === undefined) {
+                keySegment = `{${nextWeakKeyId++}}`;
                 registry.register(arg, keySegment);
                 weakKeyToKeySegmentCache.set(arg, keySegment);
             }
-            const keySegment = weakKeyToKeySegmentCache.get(arg);
             weakKeySegments.push(keySegment);
             return keySegment;
         });
         const key = keySegments.join(",");
         for (const keySegment of weakKeySegments) {
-            const keys = weakKeySegmentToKeyCache.get(keySegment) ?? [];
-            keys.push(key);
-            weakKeySegmentToKeyCache.set(keySegment, keys);
+            let keys = weakKeySegmentToKeyCache.get(keySegment);
+            if (keys === undefined) {
+                keys = new Set();
+                weakKeySegmentToKeyCache.set(keySegment, keys);
+            }
+            keys.add(key);
         }
         return key;
     };
 }
-function assertWeakKey(arg) {
-    new WeakRef(arg);
-}

package/{script/deps/jsr.io/@std/cache/0.2.2 → esm/deps/jsr.io/@std/cache/0.2.3}/lru_cache.d.ts

@@ -1,5 +1,38 @@
 import type { MemoizationCache } from "./memoize.js";
 export type { MemoizationCache };
+/**
+ * The reason an entry was removed from the cache.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * - `"evicted"` — removed automatically because the cache exceeded
+ *   {@linkcode LruCache.prototype.maxSize | maxSize}.
+ * - `"deleted"` — removed by an explicit
+ *   {@linkcode LruCache.prototype.delete | delete()} call.
+ * - `"cleared"` — removed by
+ *   {@linkcode LruCache.prototype.clear | clear()}.
+ */
+export type LruCacheEjectionReason = "evicted" | "deleted" | "cleared";
+/**
+ * Options for the {@linkcode LruCache} constructor.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ */
+export interface LruCacheOptions<K, V> {
+    /**
+     * Callback invoked when an entry is removed, whether by eviction,
+     * manual deletion, or clearing the cache. The entry is already removed
+     * from the cache when this callback fires. Overwriting an existing key
+     * via {@linkcode LruCache.prototype.set | set()} does **not** trigger
+     * this callback. The cache is not re-entrant during this callback:
+     * calling `set`, `delete`, or `clear` will throw.
+     *
+     * @param ejectedKey The key of the removed entry.
+     * @param ejectedValue The value of the removed entry.
+     * @param reason Why the entry was removed.
+     */
+    onEject?: (ejectedKey: K, ejectedValue: V, reason: LruCacheEjectionReason) => void;
+}
 /**
  * Least-recently-used cache.
  *
@@ -8,7 +41,7 @@ export type { MemoizationCache };
  * @see {@link https://en.wikipedia.org/wiki/Cache_replacement_policies#LRU | Least-recently-used cache}
  *
  * Automatically removes entries above the max size based on when they were
- * last accessed with `get`, `set`, or `has`.
+ * last accessed with `get` or `set`.
  *
  * @typeParam K The type of the cache keys.
  * @typeParam V The type of the cache values.
@@ -35,32 +68,42 @@ export type { MemoizationCache };
  * assert(!cache.has("a"));
  * ```
  *
- * @example Adding a onEject function.
+ * @example Adding an onEject callback
  * ```ts
  * import { LruCache } from "@std/cache";
  * import { assertEquals } from "@std/assert";
  *
- * const cache = new LruCache<string, string>(3, { onEject: (key, value) => {
- *  console.log("Revoking: ", key)
- *  URL.revokeObjectURL(value)
- * }});
+ * const ejected: [string, number, string][] = [];
+ * const cache = new LruCache<string, number>(2, {
+ *   onEject: (key, value, reason) => ejected.push([key, value, reason]),
+ * });
  *
- * cache.set(
- *  "fast-url",
- *  URL.createObjectURL(new Blob(["Hello, World"], { type: "text/plain" }))
- * );
+ * cache.set("a", 1);
+ * cache.set("b", 2);
+ * cache.set("c", 3);
  *
- * cache.delete("fast-url") // "Revoking: fast-url"
- * assertEquals(cache.get("fast-url"), undefined)
+ * assertEquals(ejected, [["a", 1, "evicted"]]);
  * ```
  */
 export declare class LruCache<K, V> extends Map<K, V> implements MemoizationCache<K, V> {
     #private;
+    /**
+     * Constructs a new `LruCache`.
+     *
+     * @experimental **UNSTABLE**: New API, yet to be vetted.
+     *
+     * @param maxSize The maximum number of entries to store in the cache. Must
+     * be a positive integer.
+     * @param options Additional options.
+     */
+    constructor(maxSize: number, options?: LruCacheOptions<K, V>);
     /**
      * The maximum number of entries to store in the cache.
      *
+     * @returns The maximum number of entries in the cache.
+     *
      * @example Max size
-     * ```ts no-assert
+     * ```ts
      * import { LruCache } from "@std/cache";
      * import { assertEquals } from "@std/assert";
      *
@@ -68,18 +111,10 @@ export declare class LruCache<K, V> extends Map<K, V> implements MemoizationCach
      * assertEquals(cache.maxSize, 100);
      * ```
      */
-    maxSize: number;
+    get maxSize(): number;
     /**
-     * Constructs a new `LruCache`.
-     *
-     * @param maxSize The maximum number of entries to store in the cache.
-     * @param options Additional options.
-     */
-    constructor(maxSize: number, options?: {
-        onEject: (ejectedKey: K, ejectedValue: V) => void;
-    });
-    /**
-     * Checks whether an element with the specified key exists or not.
+     * Checks whether an element with the specified key exists or not. Does
+     * **not** update the entry's position in the eviction order.
      *
      * @param key The key to check.
      * @returns `true` if the cache contains the specified key, otherwise `false`.
@@ -100,7 +135,8 @@ export declare class LruCache<K, V> extends Map<K, V> implements MemoizationCach
      * Gets the element with the specified key.
      *
      * @param key The key to get the value for.
-     * @returns The value associated with the specified key, or `undefined` if the key is not present in the cache.
+     * @returns The value associated with the specified key, or `undefined` if
+     * the key is not present in the cache.
      *
      * @example Getting a value from the cache
      * ```ts
@@ -114,6 +150,35 @@ export declare class LruCache<K, V> extends Map<K, V> implements MemoizationCach
      * ```
      */
     get(key: K): V | undefined;
+    /**
+     * Returns the value associated with the given key, or `undefined` if the
+     * key is not present, **without** updating its position in the eviction
+     * order.
+     *
+     * @experimental **UNSTABLE**: New API, yet to be vetted.
+     *
+     * @param key The key to look up.
+     * @returns The value, or `undefined` if not present.
+     *
+     * @example Peeking at a value without promoting it
+     * ```ts
+     * import { LruCache } from "@std/cache";
+     * import { assertEquals } from "@std/assert";
+     *
+     * const cache = new LruCache<string, number>(3);
+     * cache.set("a", 1);
+     * cache.set("b", 2);
+     * cache.set("c", 3);
+     *
+     * // peek does not promote "a"
+     * assertEquals(cache.peek("a"), 1);
+     *
+     * // "a" is still the least recently used and gets evicted
+     * cache.set("d", 4);
+     * assertEquals(cache.peek("a"), undefined);
+     * ```
+     */
+    peek(key: K): V | undefined;
     /**
      * Sets the specified key to the specified value.
      *
@@ -151,5 +216,24 @@ export declare class LruCache<K, V> extends Map<K, V> implements MemoizationCach
      * ```
      */
     delete(key: K): boolean;
+    /**
+     * Clears the cache.
+     *
+     * @experimental **UNSTABLE**: New API, yet to be vetted.
+     *
+     * @example Usage
+     * ```ts
+     * import { LruCache } from "@std/cache";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const cache = new LruCache<string, number>(100);
+     *
+     * cache.set("a", 1);
+     * cache.set("b", 2);
+     * cache.clear();
+     * assertEquals(cache.size, 0);
+     * ```
+     */
+    clear(): void;
 }
 //# sourceMappingURL=lru_cache.d.ts.map

package/esm/deps/jsr.io/@std/cache/0.2.3/lru_cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lru_cache.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/cache/0.2.3/lru_cache.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrD,YAAY,EAAE,gBAAgB,EAAE,CAAC;AAEjC;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,sBAAsB,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAAC;AAEvE;;;;GAIG;AACH,MAAM,WAAW,eAAe,CAAC,CAAC,EAAE,CAAC;IACnC;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,EAAE,CACR,UAAU,EAAE,CAAC,EACb,YAAY,EAAE,CAAC,EACf,MAAM,EAAE,sBAAsB,KAC3B,IAAI,CAAC;CACX;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,qBAAa,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAE,SAAQ,GAAG,CAAC,CAAC,EAAE,CAAC,CAC1C,YAAW,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC;;IAOjC;;;;;;;;OAQG;gBAED,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC;IAYjC;;;;;;;;;;;;;OAaG;IACH,IAAI,OAAO,IAAI,MAAM,CAEpB;IAsBD;;;;;;;;;;;;;;;;;OAiBG;IACM,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAI7B;;;;;;;;;;;;;;;;;OAiBG;IACM,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAUnC;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,IAAI,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAI3B;;;;;;;;;;;;;;OAcG;IACM,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAYpC;;;;;;;;;;;;;;;;;;;OAmBG;IACM,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAqBhC;;;;;;;;;;;;;;;;;OAiBG;IACM,KAAK,IAAI,IAAI;CA2BvB"}