@agoric/internal 0.3.3-other-dev-8f8782b.0 → 0.3.3-other-dev-fbe72e7.0.fbe72e7

package/src/ses-utils.js

@@ -0,0 +1,422 @@
+// @ts-check
+// @jessie-check
+/**
+ * @file Utility functions that are dependent upon a hardened environment,
+ *   either directly or indirectly (e.g. by @endo imports).
+ */
+
+import { objectMap } from '@endo/common/object-map.js';
+import { objectMetaMap } from '@endo/common/object-meta-map.js';
+import { fromUniqueEntries } from '@endo/common/from-unique-entries.js';
+import { q, Fail, makeError, annotateError, X } from '@endo/errors';
+import { deeplyFulfilled, isPrimitive } from '@endo/pass-style';
+import { makePromiseKit } from '@endo/promise-kit';
+import { makeQueue } from '@endo/stream';
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore TS7016 The 'jessie.js' library may need to update its package.json or typings
+import { asyncGenerate } from 'jessie.js';
+import { logLevels } from './js-utils.js';
+
+/** @import {LimitedConsole} from './js-utils.js'; */
+
+/** @import {ERef} from '@endo/far'; */
+/** @import {Primitive} from '@endo/pass-style'; */
+/** @import {Permit, Attenuated} from './types.js'; */
+
+export { objectMap, objectMetaMap, fromUniqueEntries };
+
+const { fromEntries, keys, values } = Object;
+
+/** @param {(level: string) => (...args: unknown[]) => void} makeLogger */
+export const makeLimitedConsole = makeLogger => {
+  const limitedConsole = /** @type {any} */ (
+    fromEntries(logLevels.map(level => [level, makeLogger(level)]))
+  );
+  return /** @type {LimitedConsole} */ (harden(limitedConsole));
+};
+harden(makeLimitedConsole);
+
+/**
+ * @template T
+ * @typedef {{ [KeyType in keyof T]: T[KeyType] } & {}} Simplify flatten the
+ *   type output to improve type hints shown in editors
+ *   https://github.com/sindresorhus/type-fest/blob/main/source/simplify.d.ts
+ */
+
+/**
+ * @typedef {(...args: any[]) => any} Callable
+ */
+
+/**
+ * @template {{}} T
+ * @typedef {{
+ *   [K in keyof T]: T[K] extends Callable ? T[K] : DeeplyAwaited<T[K]>;
+ * }} DeeplyAwaitedObject
+ */
+
+/**
+ * @template T
+ * @typedef {T extends PromiseLike<any>
+ *     ? Awaited<T>
+ *     : T extends {}
+ *       ? Simplify<DeeplyAwaitedObject<T>>
+ *       : Awaited<T>} DeeplyAwaited
+ */
+
+/**
+ * A more constrained version of {deeplyFulfilled} for type safety until
+ * https://github.com/endojs/endo/issues/1257 Useful in starting contracts that
+ * need all terms to be fulfilled in order to be durable.
+ *
+ * @type {<T extends {}>(unfulfilledTerms: T) => Promise<DeeplyAwaited<T>>}
+ */
+export const deeplyFulfilledObject = async obj => {
+  !isPrimitive(obj) || Fail`param must be an object`;
+  return deeplyFulfilled(obj);
+};
+
+/**
+ * Tolerate absence of AggregateError in e.g. xsnap.
+ *
+ * @type {(errors: Error[], message?: string, options?: object) => Error}
+ */
+const makeAggregateError =
+  typeof AggregateError === 'function'
+    ? (errors, message, options) => AggregateError(errors, message, options)
+    : (errors, message, options) => {
+        return makeError(message ?? 'multiple errors', undefined, {
+          ...options,
+          errors,
+        });
+      };
+
+/**
+ * @template T
+ * @param {readonly (T | PromiseLike<T>)[]} items
+ * @returns {Promise<T[]>}
+ */
+export const PromiseAllOrErrors = async items => {
+  return Promise.allSettled(items).then(results => {
+    const errors = /** @type {PromiseRejectedResult[]} */ (
+      results.filter(({ status }) => status === 'rejected')
+    ).map(result => result.reason);
+    if (!errors.length) {
+      return /** @type {PromiseFulfilledResult<T>[]} */ (results).map(
+        result => result.value,
+      );
+    } else if (errors.length === 1) {
+      throw errors[0];
+    } else {
+      throw makeAggregateError(errors);
+    }
+  });
+};
+
+/**
+ * @template T
+ * @param {() => Promise<T>} trier
+ * @param {(error?: unknown) => Promise<unknown>} finalizer
+ * @returns {ReturnType<trier>}
+ */
+export const aggregateTryFinally = async (trier, finalizer) =>
+  trier().then(
+    async result => finalizer().then(() => result),
+    async tryError =>
+      finalizer(tryError)
+        .then(
+          () => tryError,
+          finalizeError => makeAggregateError([tryError, finalizeError]),
+        )
+        .then(error => Promise.reject(error)),
+  );
+
+/**
+ * Run a function with the ability to defer last-in-first-out cleanup callbacks.
+ *
+ * @template T
+ * @param {(
+ *   addCleanup: (fn: (err?: unknown) => Promise<void>) => void,
+ * ) => Promise<T>} fn
+ * @returns {ReturnType<fn>}
+ */
+export const withDeferredCleanup = async fn => {
+  /** @type {((err?: unknown) => unknown)[]} */
+  const cleanupsLIFO = [];
+  /** @type {(cleanup: (err?: unknown) => unknown) => void} */
+  const addCleanup = cleanup => {
+    cleanupsLIFO.unshift(cleanup);
+  };
+  /** @type {(err?: unknown) => Promise<void>} */
+  const finalizer = async err => {
+    // Run each cleanup in its own isolated stack.
+    const cleanupResults = cleanupsLIFO.map(async cleanup => {
+      await null;
+      return cleanup(err);
+    });
+    await PromiseAllOrErrors(cleanupResults);
+  };
+  return aggregateTryFinally(() => fn(addCleanup), finalizer);
+};
+
+/**
+ * @template {Record<string, unknown>} T
+ * @typedef {{ [P in keyof T]: Exclude<T[P], undefined> }} AllDefined
+ */
+
+/**
+ * Concise way to check values are available from object literal shorthand.
+ * Throws error message to specify the missing values.
+ *
+ * @template {Record<string, unknown>} T
+ * @param {T} obj
+ * @returns {asserts obj is AllDefined<T>}
+ * @throws if any value in the object entries is not defined
+ */
+export const assertAllDefined = obj => {
+  const missing = [];
+  for (const [key, val] of Object.entries(obj)) {
+    if (val === undefined) {
+      missing.push(key);
+    }
+  }
+  if (missing.length > 0) {
+    Fail`missing ${q(missing)}`;
+  }
+};
+
+/**
+ * Attenuate `specimen` to only properties allowed by `permit`.
+ *
+ * @template T
+ * @template {Permit<T>} P
+ * @param {T} specimen
+ * @param {P} permit
+ * @param {<U, SubP extends Permit<U>>(attenuation: U, permit: SubP) => U} [transform]
+ *   used to replace the results of recursive picks (but not blanket permits)
+ * @returns {Attenuated<T, P>}
+ */
+export const attenuate = (specimen, permit, transform = x => x) => {
+  // Fast-path for no attenuation.
+  if (permit === true || typeof permit === 'string') {
+    return /** @type {Attenuated<T, P>} */ (specimen);
+  }
+
+  /** @type {string[]} */
+  const path = [];
+  /**
+   * @template SubT
+   * @template {Exclude<Permit<SubT>, Primitive>} SubP
+   * @type {(specimen: SubT, permit: SubP) => Attenuated<SubT, SubP>}
+   */
+  const extract = (subSpecimen, subPermit) => {
+    if (subPermit === null || typeof subPermit !== 'object') {
+      throw path.length === 0
+        ? Fail`invalid permit: ${q(permit)}`
+        : Fail`invalid permit at path ${q(path)}: ${q(subPermit)}`;
+    } else if (subSpecimen === null || typeof subSpecimen !== 'object') {
+      throw path.length === 0
+        ? Fail`specimen must be an object for permit ${q(permit)}`
+        : Fail`specimen at path ${q(path)} must be an object for permit ${q(subPermit)}`;
+    }
+    const picks = Object.entries(subPermit).map(([subKey, deepPermit]) => {
+      if (!Object.hasOwn(subSpecimen, subKey)) {
+        throw Fail`specimen is missing path ${q(path.concat(subKey))}`;
+      }
+      const deepSpecimen = Reflect.get(subSpecimen, subKey);
+      if (deepPermit === true || typeof deepPermit === 'string') {
+        return [subKey, deepSpecimen];
+      }
+      path.push(subKey);
+      const extracted = extract(/** @type {any} */ (deepSpecimen), deepPermit);
+      const entry = [subKey, extracted];
+      path.pop();
+      return entry;
+    });
+    return transform(Object.fromEntries(picks), subPermit);
+  };
+
+  // @ts-expect-error cast
+  return extract(specimen, permit);
+};
+
+/** @type {IteratorResult<undefined, never>} */
+const notDone = harden({ done: false, value: undefined });
+
+/** @type {IteratorResult<never, void>} */
+const alwaysDone = harden({ done: true, value: undefined });
+
+export const forever = asyncGenerate(() => notDone);
+
+/**
+ * @template T
+ * @param {() => T} produce The value of `await produce()` is used for its
+ *   truthiness vs falsiness. IOW, it is coerced to a boolean so the caller need
+ *   not bother doing this themselves.
+ * @returns {AsyncIterable<Awaited<T>>}
+ */
+export const whileTrue = produce =>
+  asyncGenerate(async () => {
+    const value = await produce();
+    if (!value) {
+      return alwaysDone;
+    }
+    return harden({
+      done: false,
+      value,
+    });
+  });
+
+/**
+ * @template T
+ * @param {() => T} produce The value of `await produce()` is used for its
+ *   truthiness vs falsiness. IOW, it is coerced to a boolean so the caller need
+ *   not bother doing this themselves.
+ * @returns {AsyncIterable<Awaited<T>>}
+ */
+export const untilTrue = produce =>
+  asyncGenerate(async () => {
+    const value = await produce();
+    if (value) {
+      return harden({
+        done: true,
+        value,
+      });
+    }
+    return harden({
+      done: false,
+      value,
+    });
+  });
+
+/** @type {<X, Y>(xs: X[], ys: Y[]) => [X, Y][]} */
+export const zip = (xs, ys) => harden(xs.map((x, i) => [x, ys[+i]]));
+
+/**
+ * @type {<T extends Record<string, ERef<any>>>(
+ *   obj: T,
+ * ) => Promise<{ [K in keyof T]: Awaited<T[K]> }>}
+ */
+export const allValues = async obj => {
+  const resolved = await Promise.all(values(obj));
+  // @ts-expect-error cast
+  return harden(fromEntries(zip(keys(obj), resolved)));
+};
+
+/**
+ * A tee implementation where all readers are synchronized with each other. They
+ * all consume the source stream in lockstep, and any one returning or throwing
+ * early will affect the others.
+ *
+ * @template [T=unknown]
+ * @param {AsyncIterator<T, void, void>} sourceStream
+ * @param {number} readerCount
+ */
+export const synchronizedTee = (sourceStream, readerCount) => {
+  /** @type {IteratorReturnResult<void> | undefined} */
+  let doneResult;
+
+  /**
+   * @typedef {IteratorResult<
+   *   (value: PromiseLike<IteratorResult<T>>) => void
+   * >} QueuePayload
+   */
+  /** @type {import('@endo/stream').AsyncQueue<QueuePayload>[]} */
+  const queues = [];
+
+  /** @returns {Promise<void>} */
+  const pullNext = async () => {
+    const requests = await Promise.allSettled(queues.map(queue => queue.get()));
+    const rejections = [];
+    /** @type {Array<(value: PromiseLike<IteratorResult<T>>) => void>} */
+    const resolvers = [];
+    let done = false;
+    for (const settledResult of requests) {
+      if (settledResult.status === 'rejected') {
+        rejections.push(settledResult.reason);
+      } else {
+        done ||= !!settledResult.value.done;
+        resolvers.push(settledResult.value.value);
+      }
+    }
+    /** @type {Promise<IteratorResult<T>>} */
+    let result;
+    if (doneResult) {
+      result = Promise.resolve(doneResult);
+    } else if (rejections.length) {
+      const error = makeError(X`Teed stream threw`);
+      annotateError(error, X`Teed rejections: ${rejections}`);
+      result =
+        sourceStream.throw?.(error) ||
+        Promise.resolve(sourceStream.return?.()).then(() =>
+          Promise.reject(error),
+        );
+    } else if (done) {
+      result =
+        sourceStream.return?.() ||
+        Promise.resolve({ done: true, value: undefined });
+    } else {
+      result = sourceStream.next();
+    }
+    result.then(
+      r => {
+        if (r.done) {
+          doneResult = r;
+        }
+      },
+      () => {
+        doneResult = { done: true, value: undefined };
+      },
+    );
+    for (const resolve of resolvers) {
+      resolve(result);
+    }
+    return pullNext();
+  };
+
+  const readers = Array.from({ length: readerCount }).map(() => {
+    /** @type {import('@endo/stream').AsyncQueue<QueuePayload>} */
+    const queue = makeQueue();
+    queues.push(queue);
+
+    /** @type {AsyncGenerator<T, void, void>} */
+    const reader = harden({
+      async next() {
+        /**
+         * @type {import('@endo/promise-kit').PromiseKit<
+         *   IteratorResult<T>
+         * >}
+         */
+        const { promise, resolve } = makePromiseKit();
+        queue.put({ value: resolve, done: false });
+        return promise;
+      },
+      async return() {
+        /**
+         * @type {import('@endo/promise-kit').PromiseKit<
+         *   IteratorResult<T>
+         * >}
+         */
+        const { promise, resolve } = makePromiseKit();
+        queue.put({ value: resolve, done: true });
+        return promise;
+      },
+      async throw(reason) {
+        const rejection = Promise.reject(reason);
+        queue.put(rejection);
+        return rejection;
+      },
+      // eslint-disable-next-line no-restricted-globals
+      [Symbol.asyncIterator]() {
+        return reader;
+      },
+      // eslint-disable-next-line no-restricted-globals
+      async [Symbol.asyncDispose]() {
+        await reader.return();
+      },
+    });
+    return reader;
+  });
+
+  void pullNext();
+  return readers;
+};

package/src/storage-test-utils.d.ts

@@ -1,101 +1,66 @@
-export function slotToRemotable(_slotId: string, iface?: string): import("@endo/eventual-send").RemotableBrand<{}, {}>;
+export function slotToRemotable(_slotId: string, iface?: string): import("@endo/pass-style").RemotableObject<string> & import("@endo/eventual-send").RemotableBrand<{}, {}>;
 /**
- * A basic marshaller whose unserializer produces Remotables. It can
- * only serialize plain data, not Remotables.
+ * A basic marshaller whose unserializer produces Remotables. It can only
+ * serialize plain data, not Remotables.
  */
 export const defaultMarshaller: {
-    toCapData: import("@endo/marshal/src/marshal.js").ToCapData<string>;
-    fromCapData: import("@endo/marshal/src/marshal.js").FromCapData<string>;
-    serialize: import("@endo/marshal/src/marshal.js").ToCapData<string>;
-    unserialize: import("@endo/marshal/src/marshal.js").FromCapData<string>;
+    toCapData: import("@endo/marshal").ToCapData<string>;
+    fromCapData: import("@endo/marshal").FromCapData<string>;
+    serialize: import("@endo/marshal").ToCapData<string>;
+    unserialize: import("@endo/marshal").FromCapData<string>;
 };
-export function slotStringUnserialize(capData: any): any;
-export function makeFakeStorageKit(rootPath: string, rootOptions?: [handleStorageMessage: (message: import("./lib-chainStorage.js").StorageMessage) => any, rootPath: string, rootOptions?: {
-    sequence?: boolean | undefined;
-} | undefined][2]): {
-    rootNode: {
+export namespace defaultSerializer {
+    let parse: (text: string) => unknown;
+    let stringify: (obj: any) => string;
+}
+export const slotStringUnserialize: (capData: any) => any;
+export function makeFakeStorageKit(rootPath: string, rootOptions?: Parameters<typeof makeChainStorageRoot>[2]): {
+    rootNode: import("@endo/exo").Guarded<{
         getPath(): string;
-        getStoreKey(): Promise<import("./lib-chainStorage.js").VStorageKey>;
+        getStoreKey(): Promise<VStorageKey>;
         makeChildNode(name: string, childNodeOptions?: {
-            sequence?: boolean | undefined;
-        } | undefined): import("./lib-chainStorage.js").StorageNode;
-        setValue(value: string): Promise<void>;
-    } & import("@endo/eventual-send").RemotableBrand<{}, {
-        getPath(): string;
-        getStoreKey(): Promise<import("./lib-chainStorage.js").VStorageKey>;
-        makeChildNode(name: string, childNodeOptions?: {
-            sequence?: boolean | undefined;
-        } | undefined): import("./lib-chainStorage.js").StorageNode;
+            sequence?: boolean;
+        }): StorageNode;
         setValue(value: string): Promise<void>;
     }>;
     data: Map<string, string>;
-    messages: import("./lib-chainStorage.js").StorageMessage[];
-    toStorage: (message: import('../src/lib-chainStorage.js').StorageMessage) => string | number | any[] | {
+    updateNewCellBlockHeight: (blockHeight?: number) => void;
+    getValues: (path: string) => string[];
+    messages: StorageMessage[];
+    toStorage: ((message: StorageMessage) => string | number | true | any[] | {
         storeName: string;
         storeSubkey: string;
-    } | null | undefined;
+    } | null) & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, (message: StorageMessage) => string | number | true | any[] | {
+        storeName: string;
+        storeSubkey: string;
+    } | null>;
 };
-export function makeMockChainStorageRoot(): {
-    /**
-     * Defaults to deserializing slot references into plain Remotable
-     * objects having the specified interface name (as from `Far(iface)`),
-     * but can accept a different marshaller for producing Remotables
-     * that e.g. embed the slot string in their iface name.
-     *
-     * @param {string} path
-     * @param {import('./lib-chainStorage.js').Marshaller} marshaller
-     * @param {number} [index]
-     * @returns {unknown}
-     */
-    getBody: (path: string, marshaller?: import('./lib-chainStorage.js').Marshaller, index?: number | undefined) => unknown;
-    keys: () => string[];
-    getPath(): string;
-    getStoreKey(): Promise<import("./lib-chainStorage.js").VStorageKey>;
-    makeChildNode(name: string, childNodeOptions?: {
-        sequence?: boolean | undefined;
-    } | undefined): import("./lib-chainStorage.js").StorageNode;
-    setValue(value: string): Promise<void>;
-} & import("@endo/eventual-send").RemotableBrand<{}, {
+export function makeMockChainStorageRoot(): MockChainStorageRoot;
+export function documentStorageSchema(t: import("ava").ExecutionContext<unknown>, storage: MockChainStorageRoot | FakeStorageKit, opts: ({
+    note: string;
+} | {
+    node: string;
+    owner: string;
+}) & ({
+    pattern: string;
+    replacement: string;
+} | {}) & {
+    showValue?: (v: string) => unknown;
+}): Promise<void>;
+export type FakeStorageKit = ReturnType<typeof makeFakeStorageKit>;
+export type MockChainStorageRootMethods = {
     /**
-     * Defaults to deserializing slot references into plain Remotable
-     * objects having the specified interface name (as from `Far(iface)`),
-     * but can accept a different marshaller for producing Remotables
-     * that e.g. embed the slot string in their iface name.
-     *
-     * @param {string} path
-     * @param {import('./lib-chainStorage.js').Marshaller} marshaller
-     * @param {number} [index]
-     * @returns {unknown}
+     *   Defaults to deserializing slot references into plain Remotable objects having
+     *   the specified interface name (as from `Far(iface)`), but can accept a
+     *   different marshaller for producing Remotables that e.g. embed the slot
+     *   string in their iface name.
      */
-    getBody: (path: string, marshaller?: import('./lib-chainStorage.js').Marshaller, index?: number | undefined) => unknown;
+    getBody: (path: string, marshaller?: Marshaller, index?: number) => unknown;
     keys: () => string[];
-    getPath(): string;
-    getStoreKey(): Promise<import("./lib-chainStorage.js").VStorageKey>;
-    makeChildNode(name: string, childNodeOptions?: {
-        sequence?: boolean | undefined;
-    } | undefined): import("./lib-chainStorage.js").StorageNode;
-    setValue(value: string): Promise<void>;
-}>;
-/**
- * A map corresponding with a total function such that `get(key)`
- * is assumed to always succeed.
- */
-export type TotalMap<K, V> = {
-    [Symbol.iterator]: () => IterableIterator<[K, V]>;
-    [Symbol.toStringTag]: string;
-    entries: () => IterableIterator<[K, V]>;
-    keys: () => IterableIterator<K>;
-    values: () => IterableIterator<V>;
-    has: (key: K) => boolean;
-    size: number;
-    set: (key: K, value: V) => Map<K, V>;
-    clear: () => void;
-    delete: (key: K) => boolean;
-    forEach: (callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any) => void;
-} & {
-    get: (key: K) => V;
 };
-export type TotalMapFrom<T> = T extends Map<infer K, infer V> ? TotalMap<K, V> : never;
-export type FakeStorageKit = ReturnType<typeof makeFakeStorageKit>;
-export type MockChainStorageRoot = ReturnType<typeof makeMockChainStorageRoot>;
+export type MockChainStorageRoot = StorageNode & MockChainStorageRootMethods;
+import { makeChainStorageRoot } from './lib-chainStorage.js';
+import type { StorageNode } from './lib-chainStorage.js';
+import type { StorageMessage } from './lib-chainStorage.js';
+import type { Marshaller } from './lib-chainStorage.js';
 //# sourceMappingURL=storage-test-utils.d.ts.map

package/src/storage-test-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"storage-test-utils.d.ts","sourceRoot":"","sources":["storage-test-utils.js"],"names":[],"mappings":"AAkCO,yCAHI,MAAM,UACN,MAAM,wDAGC;AAElB;;;GAGG;AACH;;;;;EAEG;AAsBW,+CAAU,GAAG,GAAK,GAAG,CAAA;AAgC5B,6CAHI,MAAM,gBACN;;eAAwC,CAAC,CAAC;;;;;;;;;;;;;;;;;;yBAyBvC,OAAO,4BAA4B,EAAE,cAAc;;;;EAoFhE;AAIM;IAIH;;;;;;;;;;OAUG;oBAJQ,MAAM,eACN,OAAO,uBAAuB,EAAE,UAAU,iCAExC,OAAO;;;;;;;;;IATpB;;;;;;;;;;OAUG;oBAJQ,MAAM,eACN,OAAO,uBAAuB,EAAE,UAAU,iCAExC,OAAO;;;;;;;;GAWvB;;;;;;;;;;;;;;;;;;eApNiF,CAAC,KAAK,CAAC;;;6BA0L3E,WAAY,yBAAyB,CAAC;mCA2BtC,WAAW,+BAA+B,CAAC"}
+{"version":3,"file":"storage-test-utils.d.ts","sourceRoot":"","sources":["storage-test-utils.js"],"names":[],"mappings":"AAyBO,yCAHI,MAAM,UACN,MAAM,6GAGC;AAElB;;;GAGG;AACH;;;;;EAEG;;eAMU,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO;mBAEzB,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM;;AA8CjC,8CAtBuB,GAAG,KAAK,GAAG,CAsB+B;AAU1D,6CAHI,MAAM,gBACN,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC,CAAC,CAAC;;;;;oBAuFhB,CAAC;;;;UAwDjB,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;;sBAd3B,MAAM,KACJ,MAAM,EAAE;;0BA9FP,cAAc;;;8IAAd,cAAc;;;;EAiH7B;AAoBM,4CADO,oBAAoB,CA6BjC;AAUM,yCAPI,OAAO,KAAK,EAAE,gBAAgB,CAAC,OAAO,CAAC,WACvC,oBAAoB,GAAG,cAAc,QACrC,CAAC;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,GAC9D,CAAK;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GAAG,EAAE,CAAC,GAAG;IAChD,SAAS,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC;CACpC,iBAkDL;6BAxGa,UAAU,CAAC,OAAO,kBAAkB,CAAC;;;;;;;;aAIrC,CACT,IAAI,EAAE,MAAM,EACZ,UAAU,CAAC,EAAE,UAAU,EACvB,KAAK,CAAC,EAAE,MAAM,KACX,OAAO;UAKD,MAAM,MAAM,EAAE;;mCAEd,WAAW,GAAG,2BAA2B;qCAhQJ,uBAAuB;iCAOU,uBAAuB;oCAAvB,uBAAuB;gCAAvB,uBAAuB"}