@agoric/async-flow 0.1.1-upgrade-16-dev-d45b478.0 → 0.1.1-upgrade-17-dev-3b97a9f.0

package/src/endowments.js

@@ -0,0 +1,294 @@
+import { Fail } from '@endo/errors';
+import { E } from '@endo/eventual-send';
+import { isPromise } from '@endo/promise-kit';
+import { isRemotable, isPassable, GET_METHOD_NAMES } from '@endo/pass-style';
+import { M, objectMap } from '@endo/patterns';
+import { prepareVowTools, toPassableCap } from '@agoric/vow';
+import { isVow } from '@agoric/vow/src/vow-utils.js';
+import { isUpgradeDisconnection } from '@agoric/internal/src/upgrade-api.js';
+import { PropertyKeyShape } from './type-guards.js';
+
+/**
+ * @import {RemotableObject} from '@endo/pass-style'
+ * @import {Zone} from '@agoric/base-zone'
+ * @import {Callable} from '@agoric/internal'
+ * @import {PreparationOptions} from '../src/types.js'
+ */
+
+/**
+ * @typedef {'promise' | 'storable' | 'far' | 'function' | 'array' | 'record' | 'state'} EndowmentKind
+ */
+
+const {
+  getOwnPropertyDescriptor,
+  getOwnPropertyDescriptors,
+  create,
+  fromEntries,
+  entries,
+  prototype: objectPrototype,
+} = Object;
+const { ownKeys } = Reflect;
+
+const FunctionWrapperI = M.interface('FunctionWrapper', {
+  apply: M.call(M.array()).returns(M.any()),
+});
+
+const StateAccessorI = M.interface('StateAccessor', {
+  get: M.call(PropertyKeyShape).returns(M.any()),
+  set: M.call(PropertyKeyShape, M.any()).returns(),
+});
+
+const UnwrapperI = M.interface('Unwrapper', {
+  unwrap: M.call(M.remotable('guestWrapped')).returns(M.raw()),
+});
+
+export const forwardingMethods = rem => {
+  const keys = rem[GET_METHOD_NAMES]();
+  const makeMethodEntry = key =>
+    entries({
+      [key](...args) {
+        return rem[key](...args);
+      },
+    })[0];
+  return fromEntries(keys.map(makeMethodEntry));
+};
+
+/**
+ * Given a possibly mutable (and therefore unhardened) record, return a
+ * corresponding state record that acts identically for normal
+ * gets and sets, but is implemented using accessors, so it will be recognized
+ * as a state record.
+ *
+ * @template { string | number | symbol } K
+ * @template {Record<K, any>} R
+ * @param {R} dataRecord
+ * @returns {R}
+ */
+export const makeSharedStateRecord = dataRecord =>
+  harden(
+    create(
+      objectPrototype,
+      fromEntries(
+        ownKeys(dataRecord).flatMap(key =>
+          entries(
+            getOwnPropertyDescriptors({
+              get [key]() {
+                return dataRecord[key];
+              },
+              set [key](newValue) {
+                dataRecord[key] = newValue;
+              },
+            }),
+          ),
+        ),
+      ),
+    ),
+  );
+
+/**
+ * @param {Zone} outerZone
+ * @param {PreparationOptions} [outerOptions]
+ */
+export const prepareEndowmentTools = (outerZone, outerOptions = {}) => {
+  const { vowTools = prepareVowTools(outerZone) } = outerOptions;
+  const { makeVowKit } = vowTools;
+
+  const functionUnwrapper = outerZone.exo('FunctionUnwrapper', UnwrapperI, {
+    unwrap(guestWrapped) {
+      const unwrapped = (...args) => guestWrapped.apply(args);
+      return harden(unwrapped);
+    },
+  });
+
+  const makeStateUnwrapper = outerZone.exoClass(
+    'StateUnwrapper',
+    UnwrapperI,
+    keys => ({ keys }),
+    {
+      unwrap(guestWrapped) {
+        const { state } = this;
+        const { keys } = state;
+        return harden(
+          create(
+            objectPrototype,
+            fromEntries(
+              keys.flatMap(key =>
+                entries(
+                  getOwnPropertyDescriptors({
+                    get [key]() {
+                      return guestWrapped.get(key);
+                    },
+                    set [key](newValue) {
+                      guestWrapped.set(key, newValue);
+                    },
+                  }),
+                ),
+              ),
+            ),
+          ),
+        );
+      },
+    },
+  );
+
+  /**
+   * Endowment taxonomy. Expected to grow over time.
+   * Defined within `prepareEndowmentTools` because isStorable depends on zone.
+   *
+   * @param {unknown} e
+   * @returns {EndowmentKind}
+   */
+  const endowmentKindOf = e => {
+    harden(e);
+    if (isPromise(e)) {
+      return 'promise';
+    } else if (outerZone.isStorable(e)) {
+      return 'storable';
+    } else if (isPassable(e) && isRemotable(e)) {
+      return 'far';
+    } else if (typeof e === 'function') {
+      return 'function';
+    } else if (typeof e === 'object') {
+      if (e === null) {
+        throw Fail`internal: null is always storable`;
+      }
+      if (Array.isArray(e)) {
+        return 'array';
+      }
+      const keys = ownKeys(e);
+      keys.length >= 1 || Fail`empty record should be storable ${e}`;
+      const desc = /** @type {PropertyDescriptor} */ (
+        getOwnPropertyDescriptor(e, keys[0])
+      );
+      if ('value' in desc) {
+        return 'record';
+      } else {
+        'get' in desc || Fail`internal: unexpected descriptor ${desc}`;
+        return 'state';
+      }
+    } else {
+      throw Fail`unexpected endowment ${e}`;
+    }
+  };
+  harden(endowmentKindOf);
+
+  const unwrapMap = outerZone.weakMapStore('unwrapMap', {
+    keyShape: M.remotable('wrapped'),
+    valueShape: M.remotable('unwrapper'),
+  });
+
+  const unwrapMapHas = k => {
+    if (isVow(k) || isRemotable(k)) {
+      return unwrapMap.has(toPassableCap(k));
+    } else {
+      return false;
+    }
+  };
+  const unwrapMapGet = k => unwrapMap.get(toPassableCap(k));
+  const unwrapMapSet = (k, v) => {
+    const k2 = toPassableCap(k);
+    if (unwrapMapHas(k)) {
+      unwrapMap.set(k2, v);
+    } else {
+      unwrapMap.init(k2, v);
+    }
+  };
+
+  /**
+   * @param {Zone} zone
+   * @param {string} tag
+   * @param {unknown} e
+   */
+  const prepareEndowment = (zone, tag, e) => {
+    const eKind = endowmentKindOf(e);
+    switch (eKind) {
+      case 'promise': {
+        const p = /** @type {Promise} */ (e);
+        // Not using watch or watchPromise because upgrade rejection
+        // should leave it to be resolved by the next promise endowment
+        const { vow, resolver } = makeVowKit();
+        void E.when(
+          p,
+          v => {
+            resolver.resolve(v);
+          },
+          reason => {
+            if (!isUpgradeDisconnection(reason)) {
+              resolver.reject(reason);
+            }
+          },
+        );
+        return vow;
+      }
+      case 'storable': {
+        return e;
+      }
+      case 'far': {
+        const r = /** @type {RemotableObject} */ (e);
+        const methods = forwardingMethods(r);
+        return zone.exo(
+          tag,
+          M.interface('FarWrapped', {}, { defaultGuards: 'raw' }),
+          methods,
+        );
+      }
+      case 'function': {
+        const f = /** @type {Callable} */ (e);
+        const wrapped = zone.exo(tag, FunctionWrapperI, {
+          apply(args) {
+            return f(...args);
+          },
+        });
+        unwrapMapSet(wrapped, functionUnwrapper);
+        return wrapped;
+      }
+      case 'array': {
+        const a = /** @type {unknown[]} */ (e);
+        const subZone = zone.subZone(tag);
+        return a.map((subE, i) => prepareEndowment(subZone, `${i}`, subE));
+      }
+      case 'record': {
+        const r = /** @type {Record<PropertyKey, unknown>} */ (e);
+        const subZone = zone.subZone(tag);
+        return objectMap(r, (subE, k) =>
+          prepareEndowment(subZone, String(k), subE),
+        );
+      }
+      case 'state': {
+        const state = /** @type {Record<PropertyKey, unknown>} */ (e);
+        const keys = harden(ownKeys(state));
+        const wrapped = zone.exo(tag, StateAccessorI, {
+          get(key) {
+            return state[key];
+          },
+          set(key, newValue) {
+            state[key] = newValue;
+          },
+        });
+        const stateUnwrapper = makeStateUnwrapper(keys);
+        // Need to replace the instance because the keys may be different
+        unwrapMapSet(wrapped, stateUnwrapper);
+        return wrapped;
+      }
+      default: {
+        throw Fail`unexpected endowment ${e}`;
+      }
+    }
+  };
+
+  const unwrap = (wrapped, guestWrapped) => {
+    if (unwrapMapHas(wrapped)) {
+      const unwrapper = unwrapMapGet(wrapped);
+      return unwrapper.unwrap(guestWrapped);
+    } else {
+      return guestWrapped;
+    }
+  };
+
+  return harden({ prepareEndowment, unwrap });
+};
+harden(prepareEndowmentTools);
+
+/**
+ * @typedef {ReturnType<prepareEndowmentTools>} EndowmentTools
+ */

package/src/ephemera.d.ts

@@ -1,2 +1,3 @@
 export function makeEphemera<S extends WeakKey = WeakKey, V extends unknown = any>(reinit: (self: S) => V): Ephemera<S, V>;
+import type { Ephemera } from './types.js';
 //# sourceMappingURL=ephemera.d.ts.map

package/src/ephemera.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ephemera.d.ts","sourceRoot":"","sources":["ephemera.js"],"names":[],"mappings":"AAkBO,6BAFe,CAAC,4BAAC,CAAC,gCADd,CAAC,IAAI,EACM,CAAC,AADJ,KACK,CAAC,AADA,GACZ,QAAQ,CAAC,CAAC,EAAC,CAAC,CAAC,CAiBzB"}
+{"version":3,"file":"ephemera.d.ts","sourceRoot":"","sources":["ephemera.js"],"names":[],"mappings":"AAsBO,6BALiB,CAAC,SAAX,OAAQ,YACF,CAAC,gCACV,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GACZ,SAAS,CAAC,EAAC,CAAC,CAAC,CAiBzB;8BApC0B,YAAY"}

package/src/ephemera.js

@@ -1,3 +1,7 @@
+/**
+ * @import {Ephemera} from './types.js';
+ */
+
 /**
  * Used by a possibly-durable exo to store per-instance ephemeral state.
  * Each ephemera is created at the exo class prepare level, and then

package/src/equate.js

@@ -1,8 +1,8 @@
 import { Fail, X, annotateError, q } from '@endo/errors';
 import { throwLabeled } from '@endo/common/throw-labeled.js';
 import { getTag, isObject, passStyleOf } from '@endo/pass-style';
-import { isVow } from '@agoric/vow/src/vow-utils.js';
 import { recordNames } from '@endo/marshal';
+import { isVow } from '@agoric/vow/src/vow-utils.js';
 
 const { is } = Object;
 
@@ -46,7 +46,7 @@ export const makeEquate = bijection => {
       // `init` does not yet do enough checking anyway. For this case,
       // we should ensure that h is a host wrapper of a guest promise,
       // which is a wrapping we don't yet support.
-      // bijection.init(g, h);
+      // bijection.unwrapInit(g, h);
       // return;
     }
     const hPassStyle = passStyleOf(h);
@@ -98,7 +98,7 @@ export const makeEquate = bijection => {
         // `init` does not yet do enough checking anyway. For this case,
         // we should ensure that h is a host wrapper of a guest remotable,
         // which is a wrapping we don't yet support.
-        // bijection.init(g, h);
+        // bijection.unwrapInit(g, h);
         // return;
       }
       case 'promise': {
@@ -110,7 +110,7 @@ export const makeEquate = bijection => {
         // `init` does not yet do enough checking anyway. For this case,
         // we should ensure that h is a host wrapper of a guest promise,
         // which is a wrapping we don't yet support.
-        // bijection.init(g, h);
+        // bijection.unwrapInit(g, h);
         // return;
       }
       default: {

package/src/log-store.d.ts

@@ -7,7 +7,7 @@ export function prepareLogStore(zone: Zone): () => import("@endo/exo").Guarded<{
     peekEntry(): LogEntry;
     nextEntry(): LogEntry;
     pushEntry(entry: any): number;
-    dump(): ([op: "doFulfill", vow: Vow<Passable>, fulfillment: Passable] | [op: "doReject", vow: Vow<Passable>, reason: Passable] | [op: "doReturn", callIndex: number, result: Passable] | [op: "doThrow", callIndex: number, problem: Passable] | [op: "checkCall", target: Passable, optVerb: PropertyKey | undefined, args: Passable[], callIndex: number])[];
+    dump(): ([op: "doFulfill", vow: import("@agoric/vow").Vow<import("@endo/pass-style").Passable>, fulfillment: import("@endo/pass-style").Passable] | [op: "doReject", vow: import("@agoric/vow").Vow<import("@endo/pass-style").Passable>, reason: import("@endo/pass-style").Passable] | [op: "doReturn", callIndex: number, result: import("@endo/pass-style").Passable] | [op: "doThrow", callIndex: number, problem: import("@endo/pass-style").Passable] | [op: "checkCall", target: import("@endo/pass-style").Passable, optVerb: PropertyKey | undefined, args: import("@endo/pass-style").Passable[], callIndex: number] | [op: "checkSendOnly", target: import("@endo/pass-style").Passable, optVerb: PropertyKey | undefined, args: import("@endo/pass-style").Passable[], callIndex: number] | [op: "checkSend", target: import("@endo/pass-style").Passable, optVerb: PropertyKey | undefined, args: import("@endo/pass-style").Passable[], callIndex: number])[];
     promiseReplayDone(): Promise<undefined>;
 }>;
 export type LogStore = ReturnType<ReturnType<(zone: Zone) => () => import("@endo/exo").Guarded<{
@@ -19,7 +19,9 @@ export type LogStore = ReturnType<ReturnType<(zone: Zone) => () => import("@endo
     peekEntry(): LogEntry;
     nextEntry(): LogEntry;
     pushEntry(entry: any): number;
-    dump(): ([op: "doFulfill", vow: Vow<Passable>, fulfillment: Passable] | [op: "doReject", vow: Vow<Passable>, reason: Passable] | [op: "doReturn", callIndex: number, result: Passable] | [op: "doThrow", callIndex: number, problem: Passable] | [op: "checkCall", target: Passable, optVerb: PropertyKey | undefined, args: Passable[], callIndex: number])[];
+    dump(): ([op: "doFulfill", vow: import("@agoric/vow").Vow<import("@endo/pass-style").Passable>, fulfillment: import("@endo/pass-style").Passable] | [op: "doReject", vow: import("@agoric/vow").Vow<import("@endo/pass-style").Passable>, reason: import("@endo/pass-style").Passable] | [op: "doReturn", callIndex: number, result: import("@endo/pass-style").Passable] | [op: "doThrow", callIndex: number, problem: import("@endo/pass-style").Passable] | [op: "checkCall", target: import("@endo/pass-style").Passable, optVerb: PropertyKey | undefined, args: import("@endo/pass-style").Passable[], callIndex: number] | [op: "checkSendOnly", target: import("@endo/pass-style").Passable, optVerb: PropertyKey | undefined, args: import("@endo/pass-style").Passable[], callIndex: number] | [op: "checkSend", target: import("@endo/pass-style").Passable, optVerb: PropertyKey | undefined, args: import("@endo/pass-style").Passable[], callIndex: number])[];
     promiseReplayDone(): Promise<undefined>;
 }>>>;
+import type { Zone } from '@agoric/base-zone';
+import type { LogEntry } from './types.js';
 //# sourceMappingURL=log-store.d.ts.map

package/src/log-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"log-store.d.ts","sourceRoot":"","sources":["log-store.js"],"names":[],"mappings":"AA4BO;;;;;;;;;;;GAoIN;uBAGY,UAAU,CAAC,UAAU;;;;;;;;;;;GAAiB,CAAC"}
+{"version":3,"file":"log-store.d.ts","sourceRoot":"","sources":["log-store.js"],"names":[],"mappings":"AA+BO,sCAFI,IAAI;;;;;;;;;;;GAuId;uBAGY,UAAU,CAAC,UAAU,QA1IvB,IAAI;;;;;;;;;;;GA0IoC,CAAC;0BA/J7B,mBAAmB;8BAEL,YAAY"}

package/src/log-store.js

@@ -5,7 +5,10 @@ import { LogEntryShape } from './type-guards.js';
 import { makeEphemera } from './ephemera.js';
 
 /**
- * @import {MapStore} from '@agoric/store'
+ * @import {PromiseKit} from '@endo/promise-kit'
+ * @import {Zone} from '@agoric/base-zone'
+ * @import {MapStore} from '@agoric/store';
+ * @import {Ephemera, LogEntry} from './types.js';
  */
 
 const LogStoreI = M.interface('LogStore', {
@@ -138,6 +141,7 @@ export const prepareLogStore = zone => {
           Fail`internal: index confusion ${q(eph.index)} vs ${q(
             mapStore.getSize(),
           )}`;
+        // console.log('LOG ENTRY ', eph.index - 1, entry);
         return eph.index;
       },
       dump() {

package/src/replay-membrane.d.ts

@@ -1,28 +1,10 @@
-export function makeReplayMembrane(log: import("@endo/exo").Guarded<{
-    reset(): void;
-    dispose(): void;
-    getIndex(): number;
-    getLength(): number;
-    isReplaying(): boolean;
-    peekEntry(): LogEntry;
-    nextEntry(): LogEntry;
-    pushEntry(entry: any): number;
-    dump(): ([op: "doFulfill", vow: Vow<Passable>, fulfillment: Passable] | [op: "doReject", vow: Vow<Passable>, reason: Passable] | [op: "doReturn", callIndex: number, result: Passable] | [op: "doThrow", callIndex: number, problem: Passable] | [op: "checkCall", target: Passable, optVerb: PropertyKey | undefined, args: Passable[], callIndex: number])[];
-    promiseReplayDone(): Promise<undefined>;
-}>, bijection: import("@endo/exo").Guarded<{
-    reset(): void;
-    init(g: any, h: any): void;
-    hasGuest(g: any): boolean;
-    hasHost(h: any): boolean;
-    has(g: any, h: any): boolean;
-    guestToHost(g: any): any;
-    hostToGuest(h: any): any;
-}>, vowTools: {
-    when: <T, TResult1 = import("@agoric/vow").Unwrap<T>, TResult2 = never>(specimenP: T, onFulfilled?: ((value: import("@agoric/vow").Unwrap<T>) => TResult1 | PromiseLike<TResult1>) | undefined, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined) => Promise<TResult1 | TResult2>;
-    watch: <T_1 = any, TResult1_1 = T_1, TResult2_1 = never, C = any>(specimenP: import("@agoric/vow").ERef<T_1 | Vow<T_1>>, watcher?: import("@agoric/vow").Watcher<T_1, TResult1_1, TResult2_1> | undefined, watcherContext?: C | undefined) => Vow<Exclude<TResult1_1, void> | Exclude<TResult2_1, void> extends never ? TResult1_1 : Exclude<TResult1_1, void> | Exclude<TResult2_1, void>>;
-    makeVowKit: <T_2>() => import("@agoric/vow").VowKit<T_2>;
-    allVows: (vows: unknown[]) => Vow<any[]>;
-}, watchWake: (vowish: Promise<any> | Vow) => void, panic: (problem: Error) => never): {
+export function makeReplayMembrane({ log, bijection, vowTools, watchWake, panic, }: {
+    log: LogStore;
+    bijection: Bijection;
+    vowTools: VowTools;
+    watchWake: (vowish: Promise<any> | Vow) => void;
+    panic: (problem: Error) => never;
+}): {
     hostToGuest: (specimen: Passable, label?: string | undefined) => any;
     guestToHost: (specimen: Passable, label?: string | undefined) => any;
     wake: () => void;
@@ -33,31 +15,13 @@ export function makeReplayMembrane(log: import("@endo/exo").Guarded<{
     wake: () => void;
     stop: () => void;
 }>;
-export type ReplayMembrane = ReturnType<(log: import("@endo/exo").Guarded<{
-    reset(): void;
-    dispose(): void;
-    getIndex(): number;
-    getLength(): number;
-    isReplaying(): boolean;
-    peekEntry(): LogEntry;
-    nextEntry(): LogEntry;
-    pushEntry(entry: any): number;
-    dump(): ([op: "doFulfill", vow: Vow<Passable>, fulfillment: Passable] | [op: "doReject", vow: Vow<Passable>, reason: Passable] | [op: "doReturn", callIndex: number, result: Passable] | [op: "doThrow", callIndex: number, problem: Passable] | [op: "checkCall", target: Passable, optVerb: PropertyKey | undefined, args: Passable[], callIndex: number])[];
-    promiseReplayDone(): Promise<undefined>;
-}>, bijection: import("@endo/exo").Guarded<{
-    reset(): void;
-    init(g: any, h: any): void;
-    hasGuest(g: any): boolean;
-    hasHost(h: any): boolean;
-    has(g: any, h: any): boolean;
-    guestToHost(g: any): any;
-    hostToGuest(h: any): any;
-}>, vowTools: {
-    when: <T, TResult1 = import("@agoric/vow").Unwrap<T>, TResult2 = never>(specimenP: T, onFulfilled?: ((value: import("@agoric/vow").Unwrap<T>) => TResult1 | PromiseLike<TResult1>) | undefined, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined) => Promise<TResult1 | TResult2>;
-    watch: <T_1 = any, TResult1_1 = T_1, TResult2_1 = never, C = any>(specimenP: import("@agoric/vow").ERef<T_1 | Vow<T_1>>, watcher?: import("@agoric/vow").Watcher<T_1, TResult1_1, TResult2_1> | undefined, watcherContext?: C | undefined) => Vow<Exclude<TResult1_1, void> | Exclude<TResult2_1, void> extends never ? TResult1_1 : Exclude<TResult1_1, void> | Exclude<TResult2_1, void>>;
-    makeVowKit: <T_2>() => import("@agoric/vow").VowKit<T_2>;
-    allVows: (vows: unknown[]) => Vow<any[]>;
-}, watchWake: (vowish: Promise<any> | Vow) => void, panic: (problem: Error) => never) => {
+export type ReplayMembrane = ReturnType<({ log, bijection, vowTools, watchWake, panic, }: {
+    log: LogStore;
+    bijection: Bijection;
+    vowTools: VowTools;
+    watchWake: (vowish: Promise<any> | Vow) => void;
+    panic: (problem: Error) => never;
+}) => {
     hostToGuest: (specimen: Passable, label?: string | undefined) => any;
     guestToHost: (specimen: Passable, label?: string | undefined) => any;
     wake: () => void;
@@ -68,4 +32,9 @@ export type ReplayMembrane = ReturnType<(log: import("@endo/exo").Guarded<{
     wake: () => void;
     stop: () => void;
 }>>;
+import type { LogStore } from '../src/log-store.js';
+import type { Bijection } from '../src/bijection.js';
+import type { VowTools } from '@agoric/vow';
+import type { Vow } from '@agoric/vow';
+import type { Passable } from '@endo/pass-style';
 //# sourceMappingURL=replay-membrane.d.ts.map

package/src/replay-membrane.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"replay-membrane.d.ts","sourceRoot":"","sources":["replay-membrane.js"],"names":[],"mappings":"AAqBO;;;;;;;;;;;;;;;;;;;;uFAZuC,CAAC;;;oBAqBtC,SAAS;8CAZoB,IAAI,SAC/B,CAAC,OAAO,EAAE,KAAK,KAAK,KAAK;;;;;;;;;;GAqdnC;6BAGa,UAAU;;;;;;;;;;;;;;;;;;;;uFAlesB,CAAC;;;oBAqBtC,SAAS;2DAXP,CAAC,OAAO,EAAE,KAAK,KAAK,KAAK;;;;;;;;;;GAwdQ"}
+{"version":3,"file":"replay-membrane.d.ts","sourceRoot":"","sources":["replay-membrane.js"],"names":[],"mappings":"AA8BO,oFANJ;IAAsB,GAAG,EAAjB,QAAQ;IACO,SAAS,EAAxB,SAAS;IACK,QAAQ,EAAtB,QAAQ;IAC6B,SAAS,EAA9C,CAAC,MAAM,EAAE,eAAU,GAAG,KAAK,IAAI;IACA,KAAK,EAApC,CAAC,OAAO,EAAE,KAAK,KAAK,KAAK;CACnC;;;;;;;;;;GAmpBA;6BAGa,UAAU,mDA3pBrB;IAAsB,GAAG,EAAjB,QAAQ;IACO,SAAS,EAAxB,SAAS;IACK,QAAQ,EAAtB,QAAQ;IAC6B,SAAS,EAA9C,CAAC,MAAM,EAAE,eAAU,GAAG,KAAK,IAAI;IACA,KAAK,EAApC,CAAC,OAAO,EAAE,KAAK,KAAK,KAAK;CACnC;;;;;;;;;;GAspB2C;8BApqBjB,qBAAqB;+BACpB,qBAAqB;8BAFT,aAAa;yBAAb,aAAa;8BADD,kBAAkB"}