@livestore/common 0.3.0-dev.4 → 0.3.0-dev.41

package/dist/sync/syncstate.d.ts

@@ -1,123 +1,254 @@
 import { Schema } from '@livestore/utils/effect';
-import * as EventId from '../schema/EventId.js';
-import * as MutationEvent from '../schema/MutationEvent.js';
+import { UnexpectedError } from '../adapter-types.js';
+import * as LiveStoreEvent from '../schema/LiveStoreEvent.js';
+declare const SyncState_base: Schema.Class<SyncState, {
+    pending: Schema.Array$<typeof LiveStoreEvent.EncodedWithMeta>;
+    /** What this node expects the next upstream node to have as its own local head */
+    upstreamHead: Schema.Struct<{
+        global: Schema.BrandSchema<number & import("effect/Brand").Brand<"GlobalEventId">, number, never>;
+        client: Schema.BrandSchema<number & import("effect/Brand").Brand<"ClientEventId">, number, never>;
+    }>;
+    /** Equivalent to `pending.at(-1)?.id` if there are pending events */
+    localHead: Schema.Struct<{
+        global: Schema.BrandSchema<number & import("effect/Brand").Brand<"GlobalEventId">, number, never>;
+        client: Schema.BrandSchema<number & import("effect/Brand").Brand<"ClientEventId">, number, never>;
+    }>;
+}, Schema.Struct.Encoded<{
+    pending: Schema.Array$<typeof LiveStoreEvent.EncodedWithMeta>;
+    /** What this node expects the next upstream node to have as its own local head */
+    upstreamHead: Schema.Struct<{
+        global: Schema.BrandSchema<number & import("effect/Brand").Brand<"GlobalEventId">, number, never>;
+        client: Schema.BrandSchema<number & import("effect/Brand").Brand<"ClientEventId">, number, never>;
+    }>;
+    /** Equivalent to `pending.at(-1)?.id` if there are pending events */
+    localHead: Schema.Struct<{
+        global: Schema.BrandSchema<number & import("effect/Brand").Brand<"GlobalEventId">, number, never>;
+        client: Schema.BrandSchema<number & import("effect/Brand").Brand<"ClientEventId">, number, never>;
+    }>;
+}>, never, {
+    readonly upstreamHead: {
+        readonly global: number & import("effect/Brand").Brand<"GlobalEventId">;
+        readonly client: number & import("effect/Brand").Brand<"ClientEventId">;
+    };
+} & {
+    readonly localHead: {
+        readonly global: number & import("effect/Brand").Brand<"GlobalEventId">;
+        readonly client: number & import("effect/Brand").Brand<"ClientEventId">;
+    };
+} & {
+    readonly pending: readonly LiveStoreEvent.EncodedWithMeta[];
+}, {}, {}>;
 /**
  * SyncState represents the current sync state of a sync node relative to an upstream node.
  * Events flow from local to upstream, with each state maintaining its own event head.
  *
- * Event Chain Structure:
+ * Example:
  * ```
- *                 +-------------------------+------------------------+
- *                 |      ROLLBACK TAIL      |     PENDING EVENTS     |
- *                 +-------------------------+------------------------+
- *                                         ▼                       ▼
- *                                  Upstream Head             Local Head
- *   Example:              (0,0), (0,1), (1,0)     (1,1), (1,2), (2,0)
+ *                 +------------------------+
+ *                 |     PENDING EVENTS     |
+ *                 +------------------------+
+ *               ▼                       ▼
+ *        Upstream Head             Local Head
+ *             (1,0)     (1,1), (1,2), (2,0)
  * ```
  *
- * State:
- * - **Pending Events**: Events awaiting acknowledgment from the upstream.
- *   - Can be confirmed or rejected by the upstream.
- *   - Subject to rebase if rejected.
- * - **Rollback Tail**: Events that are kept around temporarily for potential rollback until confirmed by upstream.
+ * **Pending Events**: Events awaiting acknowledgment from the upstream.
+ * - Can be confirmed or rejected by the upstream.
+ * - Subject to rebase if rejected.
  *
  * Payloads:
  * - `PayloadUpstreamRebase`: Upstream has performed a rebase, so downstream must roll back to the specified event
  *    and rebase the pending events on top of the new events.
  * - `PayloadUpstreamAdvance`: Upstream has advanced, so downstream must rebase the pending events on top of the new events.
- * - `PayloadUpstreamTrimRollbackTail`: Upstream has advanced, so downstream can trim the rollback tail.
  * - `PayloadLocalPush`: Local push payload
  *
  * Invariants:
  * 1. **Chain Continuity**: Each event must reference its immediate parent.
  * 2. **Head Ordering**: Upstream Head ≤ Local Head.
- * 3. **ID Sequence**: Must follow the pattern (1,0)→(1,1)→(1,2)→(2,0).
+ * 3. **Event number sequence**: Must follow the pattern (1,0)→(1,1)→(1,2)→(2,0).
  *
- * The `updateSyncState` function processes updates to the sync state based on incoming payloads,
- * handling cases such as upstream rebase, advance, local push, and rollback tail trimming.
+ * A few further notes to help form an intuition:
+ * - The goal is to keep the pending events as small as possible (i.e. to have synced with the next upstream node)
+ * - There are 2 cases for rebasing:
+ *   - The conflicting event only conflicts with the pending events -> only (some of) the pending events need to be rolled back
+ *
+ * The `merge` function processes updates to the sync state based on incoming payloads,
+ * handling cases such as upstream rebase, advance and local push.
  */
-export interface SyncState {
-    pending: ReadonlyArray<MutationEvent.EncodedWithMeta>;
-    rollbackTail: ReadonlyArray<MutationEvent.EncodedWithMeta>;
-    upstreamHead: EventId.EventId;
-    localHead: EventId.EventId;
+export declare class SyncState extends SyncState_base {
+    toJSON: () => any;
 }
-export declare const SyncState: Schema.Struct<{
-    pending: Schema.Array$<typeof MutationEvent.EncodedWithMeta>;
-    rollbackTail: Schema.Array$<typeof MutationEvent.EncodedWithMeta>;
-    upstreamHead: Schema.Struct<{
-        global: typeof Schema.Number;
-        local: typeof Schema.Number;
-    }>;
-    localHead: Schema.Struct<{
-        global: typeof Schema.Number;
-        local: typeof Schema.Number;
-    }>;
-}>;
 declare const PayloadUpstreamRebase_base: Schema.TaggedStruct<"upstream-rebase", {
-    /** Rollback until this event in the rollback tail (inclusive). Starting from the end of the rollback tail. */
-    rollbackUntil: Schema.Struct<{
-        global: typeof Schema.Number;
-        local: typeof Schema.Number;
-    }>;
-    newEvents: Schema.Array$<typeof MutationEvent.EncodedWithMeta>;
-    /** Trim rollback tail up to this event (inclusive). */
-    trimRollbackUntil: Schema.optional<Schema.Struct<{
-        global: typeof Schema.Number;
-        local: typeof Schema.Number;
-    }>>;
+    /** Events which need to be rolled back */
+    rollbackEvents: Schema.Array$<typeof LiveStoreEvent.EncodedWithMeta>;
+    /** Events which need to be applied after the rollback (already rebased by the upstream node) */
+    newEvents: Schema.Array$<typeof LiveStoreEvent.EncodedWithMeta>;
 }>;
+/**
+ * This payload propagates a rebase from the upstream node
+ */
 export declare class PayloadUpstreamRebase extends PayloadUpstreamRebase_base {
 }
 declare const PayloadUpstreamAdvance_base: Schema.TaggedStruct<"upstream-advance", {
-    newEvents: Schema.Array$<typeof MutationEvent.EncodedWithMeta>;
-    /** Trim rollback tail up to this event (inclusive). */
-    trimRollbackUntil: Schema.optional<Schema.Struct<{
-        global: typeof Schema.Number;
-        local: typeof Schema.Number;
-    }>>;
+    newEvents: Schema.Array$<typeof LiveStoreEvent.EncodedWithMeta>;
 }>;
 export declare class PayloadUpstreamAdvance extends PayloadUpstreamAdvance_base {
 }
 declare const PayloadLocalPush_base: Schema.TaggedStruct<"local-push", {
-    newEvents: Schema.Array$<typeof MutationEvent.EncodedWithMeta>;
+    newEvents: Schema.Array$<typeof LiveStoreEvent.EncodedWithMeta>;
 }>;
 export declare class PayloadLocalPush extends PayloadLocalPush_base {
 }
 declare const Payload_base: Schema.Union<[typeof PayloadUpstreamRebase, typeof PayloadUpstreamAdvance, typeof PayloadLocalPush]>;
 export declare class Payload extends Payload_base {
 }
-export declare const PayloadUpstream: Schema.Union<[typeof PayloadUpstreamRebase, typeof PayloadUpstreamAdvance]>;
-export type PayloadUpstream = typeof PayloadUpstream.Type;
-export type UpdateResultAdvance = {
-    _tag: 'advance';
-    newSyncState: SyncState;
-    previousSyncState: SyncState;
-    /** Events which weren't pending before the update */
-    newEvents: ReadonlyArray<MutationEvent.EncodedWithMeta>;
-};
-export type UpdateResultRebase = {
-    _tag: 'rebase';
-    newSyncState: SyncState;
-    previousSyncState: SyncState;
-    /** Events which weren't pending before the update */
-    newEvents: ReadonlyArray<MutationEvent.EncodedWithMeta>;
-    eventsToRollback: ReadonlyArray<MutationEvent.EncodedWithMeta>;
-};
-export type UpdateResultReject = {
-    _tag: 'reject';
-    previousSyncState: SyncState;
+declare const PayloadUpstream_base: Schema.Union<[typeof PayloadUpstreamRebase, typeof PayloadUpstreamAdvance]>;
+export declare class PayloadUpstream extends PayloadUpstream_base {
+}
+declare const MergeContext_base: Schema.Class<MergeContext, {
+    payload: typeof Payload;
+    syncState: typeof SyncState;
+}, Schema.Struct.Encoded<{
+    payload: typeof Payload;
+    syncState: typeof SyncState;
+}>, never, {
+    readonly payload: {
+        readonly _tag: "upstream-rebase";
+        readonly rollbackEvents: readonly LiveStoreEvent.EncodedWithMeta[];
+        readonly newEvents: readonly LiveStoreEvent.EncodedWithMeta[];
+    } | {
+        readonly _tag: "upstream-advance";
+        readonly newEvents: readonly LiveStoreEvent.EncodedWithMeta[];
+    } | {
+        readonly _tag: "local-push";
+        readonly newEvents: readonly LiveStoreEvent.EncodedWithMeta[];
+    };
+} & {
+    readonly syncState: SyncState;
+}, {}, {}>;
+/** Only used for debugging purposes */
+export declare class MergeContext extends MergeContext_base {
+    toJSON: () => any;
+}
+declare const MergeResultAdvance_base: Schema.Class<MergeResultAdvance, {
+    _tag: Schema.Literal<["advance"]>;
+    newSyncState: typeof SyncState;
+    newEvents: Schema.Array$<typeof LiveStoreEvent.EncodedWithMeta>;
+    /** Events which were previously pending but are now confirmed */
+    confirmedEvents: Schema.Array$<typeof LiveStoreEvent.EncodedWithMeta>;
+    mergeContext: typeof MergeContext;
+}, Schema.Struct.Encoded<{
+    _tag: Schema.Literal<["advance"]>;
+    newSyncState: typeof SyncState;
+    newEvents: Schema.Array$<typeof LiveStoreEvent.EncodedWithMeta>;
+    /** Events which were previously pending but are now confirmed */
+    confirmedEvents: Schema.Array$<typeof LiveStoreEvent.EncodedWithMeta>;
+    mergeContext: typeof MergeContext;
+}>, never, {
+    readonly _tag: "advance";
+} & {
+    readonly newEvents: readonly LiveStoreEvent.EncodedWithMeta[];
+} & {
+    readonly newSyncState: SyncState;
+} & {
+    readonly mergeContext: MergeContext;
+} & {
+    readonly confirmedEvents: readonly LiveStoreEvent.EncodedWithMeta[];
+}, {}, {}>;
+export declare class MergeResultAdvance extends MergeResultAdvance_base {
+    toJSON: () => any;
+}
+declare const MergeResultRebase_base: Schema.Class<MergeResultRebase, {
+    _tag: Schema.Literal<["rebase"]>;
+    newSyncState: typeof SyncState;
+    newEvents: Schema.Array$<typeof LiveStoreEvent.EncodedWithMeta>;
+    /** Events which need to be rolled back */
+    rollbackEvents: Schema.Array$<typeof LiveStoreEvent.EncodedWithMeta>;
+    mergeContext: typeof MergeContext;
+}, Schema.Struct.Encoded<{
+    _tag: Schema.Literal<["rebase"]>;
+    newSyncState: typeof SyncState;
+    newEvents: Schema.Array$<typeof LiveStoreEvent.EncodedWithMeta>;
+    /** Events which need to be rolled back */
+    rollbackEvents: Schema.Array$<typeof LiveStoreEvent.EncodedWithMeta>;
+    mergeContext: typeof MergeContext;
+}>, never, {
+    readonly _tag: "rebase";
+} & {
+    readonly rollbackEvents: readonly LiveStoreEvent.EncodedWithMeta[];
+} & {
+    readonly newEvents: readonly LiveStoreEvent.EncodedWithMeta[];
+} & {
+    readonly newSyncState: SyncState;
+} & {
+    readonly mergeContext: MergeContext;
+}, {}, {}>;
+export declare class MergeResultRebase extends MergeResultRebase_base {
+    toJSON: () => any;
+}
+declare const MergeResultReject_base: Schema.Class<MergeResultReject, {
+    _tag: Schema.Literal<["reject"]>;
+    /** The minimum id that the new events must have */
+    expectedMinimumId: Schema.Struct<{
+        global: Schema.BrandSchema<number & import("effect/Brand").Brand<"GlobalEventId">, number, never>;
+        client: Schema.BrandSchema<number & import("effect/Brand").Brand<"ClientEventId">, number, never>;
+    }>;
+    mergeContext: typeof MergeContext;
+}, Schema.Struct.Encoded<{
+    _tag: Schema.Literal<["reject"]>;
     /** The minimum id that the new events must have */
-    expectedMinimumId: EventId.EventId;
-};
-export type UpdateResult = UpdateResultAdvance | UpdateResultRebase | UpdateResultReject;
-export declare const updateSyncState: ({ syncState, payload, isLocalEvent, isEqualEvent, ignoreLocalEvents, }: {
+    expectedMinimumId: Schema.Struct<{
+        global: Schema.BrandSchema<number & import("effect/Brand").Brand<"GlobalEventId">, number, never>;
+        client: Schema.BrandSchema<number & import("effect/Brand").Brand<"ClientEventId">, number, never>;
+    }>;
+    mergeContext: typeof MergeContext;
+}>, never, {
+    readonly _tag: "reject";
+} & {
+    readonly mergeContext: MergeContext;
+} & {
+    readonly expectedMinimumId: {
+        readonly global: number & import("effect/Brand").Brand<"GlobalEventId">;
+        readonly client: number & import("effect/Brand").Brand<"ClientEventId">;
+    };
+}, {}, {}>;
+export declare class MergeResultReject extends MergeResultReject_base {
+    toJSON: () => any;
+}
+declare const MergeResultUnexpectedError_base: Schema.Class<MergeResultUnexpectedError, {
+    _tag: Schema.Literal<["unexpected-error"]>;
+    cause: typeof UnexpectedError;
+}, Schema.Struct.Encoded<{
+    _tag: Schema.Literal<["unexpected-error"]>;
+    cause: typeof UnexpectedError;
+}>, never, {
+    readonly _tag: "unexpected-error";
+} & {
+    readonly cause: UnexpectedError;
+}, {}, {}>;
+export declare class MergeResultUnexpectedError extends MergeResultUnexpectedError_base {
+}
+declare const MergeResult_base: Schema.Union<[typeof MergeResultAdvance, typeof MergeResultRebase, typeof MergeResultReject, typeof MergeResultUnexpectedError]>;
+export declare class MergeResult extends MergeResult_base {
+}
+export declare const merge: ({ syncState, payload, isClientEvent, isEqualEvent, ignoreClientEvents, }: {
     syncState: SyncState;
     payload: typeof Payload.Type;
-    isLocalEvent: (event: MutationEvent.EncodedWithMeta) => boolean;
-    isEqualEvent: (a: MutationEvent.EncodedWithMeta, b: MutationEvent.EncodedWithMeta) => boolean;
-    /** This is used in the leader which should ignore local events when receiving an upstream-advance payload */
-    ignoreLocalEvents?: boolean;
-}) => UpdateResult;
+    isClientEvent: (event: LiveStoreEvent.EncodedWithMeta) => boolean;
+    isEqualEvent: (a: LiveStoreEvent.EncodedWithMeta, b: LiveStoreEvent.EncodedWithMeta) => boolean;
+    /** This is used in the leader which should ignore client events when receiving an upstream-advance payload */
+    ignoreClientEvents?: boolean;
+}) => typeof MergeResult.Type;
+/**
+ * Gets the index relative to `existingEvents` where the divergence point is
+ * by comparing each event in `existingEvents` to the corresponding event in `incomingEvents`
+ */
+export declare const findDivergencePoint: ({ existingEvents, incomingEvents, isEqualEvent, isClientEvent, ignoreClientEvents, }: {
+    existingEvents: ReadonlyArray<LiveStoreEvent.EncodedWithMeta>;
+    incomingEvents: ReadonlyArray<LiveStoreEvent.EncodedWithMeta>;
+    isEqualEvent: (a: LiveStoreEvent.EncodedWithMeta, b: LiveStoreEvent.EncodedWithMeta) => boolean;
+    isClientEvent: (event: LiveStoreEvent.EncodedWithMeta) => boolean;
+    ignoreClientEvents: boolean;
+}) => number;
 export {};
 //# sourceMappingURL=syncstate.d.ts.map

package/dist/sync/syncstate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"syncstate.d.ts","sourceRoot":"","sources":["../../src/sync/syncstate.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,MAAM,EAAE,MAAM,yBAAyB,CAAA;AAE/D,OAAO,KAAK,OAAO,MAAM,sBAAsB,CAAA;AAC/C,OAAO,KAAK,aAAa,MAAM,4BAA4B,CAAA;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,WAAW,SAAS;IACxB,OAAO,EAAE,aAAa,CAAC,aAAa,CAAC,eAAe,CAAC,CAAA;IACrD,YAAY,EAAE,aAAa,CAAC,aAAa,CAAC,eAAe,CAAC,CAAA;IAC1D,YAAY,EAAE,OAAO,CAAC,OAAO,CAAA;IAC7B,SAAS,EAAE,OAAO,CAAC,OAAO,CAAA;CAC3B;AAED,eAAO,MAAM,SAAS;;;;;;;;;;;EAKgB,CAAA;;IAGpC,8GAA8G;;;;;;IAG9G,uDAAuD;;;;;;AAJzD,qBAAa,qBAAsB,SAAQ,0BAMzC;CAAG;;;IAIH,uDAAuD;;;;;;AAFzD,qBAAa,sBAAuB,SAAQ,2BAI1C;CAAG;;;;AAEL,qBAAa,gBAAiB,SAAQ,qBAEpC;CAAG;;AAEL,qBAAa,OAAQ,SAAQ,YAA6E;CAAG;AAE7G,eAAO,MAAM,eAAe,6EAA8D,CAAA;AAE1F,MAAM,MAAM,eAAe,GAAG,OAAO,eAAe,CAAC,IAAI,CAAA;AAEzD,MAAM,MAAM,mBAAmB,GAAG;IAChC,IAAI,EAAE,SAAS,CAAA;IACf,YAAY,EAAE,SAAS,CAAA;IACvB,iBAAiB,EAAE,SAAS,CAAA;IAC5B,qDAAqD;IACrD,SAAS,EAAE,aAAa,CAAC,aAAa,CAAC,eAAe,CAAC,CAAA;CACxD,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,QAAQ,CAAA;IACd,YAAY,EAAE,SAAS,CAAA;IACvB,iBAAiB,EAAE,SAAS,CAAA;IAC5B,qDAAqD;IACrD,SAAS,EAAE,aAAa,CAAC,aAAa,CAAC,eAAe,CAAC,CAAA;IACvD,gBAAgB,EAAE,aAAa,CAAC,aAAa,CAAC,eAAe,CAAC,CAAA;CAC/D,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,QAAQ,CAAA;IACd,iBAAiB,EAAE,SAAS,CAAA;IAC5B,mDAAmD;IACnD,iBAAiB,EAAE,OAAO,CAAC,OAAO,CAAA;CACnC,CAAA;AAED,MAAM,MAAM,YAAY,GAAG,mBAAmB,GAAG,kBAAkB,GAAG,kBAAkB,CAAA;AAExF,eAAO,MAAM,eAAe,2EAMzB;IACD,SAAS,EAAE,SAAS,CAAA;IACpB,OAAO,EAAE,OAAO,OAAO,CAAC,IAAI,CAAA;IAC5B,YAAY,EAAE,CAAC,KAAK,EAAE,aAAa,CAAC,eAAe,KAAK,OAAO,CAAA;IAC/D,YAAY,EAAE,CAAC,CAAC,EAAE,aAAa,CAAC,eAAe,EAAE,CAAC,EAAE,aAAa,CAAC,eAAe,KAAK,OAAO,CAAA;IAC7F,6GAA6G;IAC7G,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAC5B,KAAG,YA+MH,CAAA"}
+{"version":3,"file":"syncstate.d.ts","sourceRoot":"","sources":["../../src/sync/syncstate.ts"],"names":[],"mappings":"AACA,OAAO,EAAwB,MAAM,EAAE,MAAM,yBAAyB,CAAA;AAEtE,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAErD,OAAO,KAAK,cAAc,MAAM,6BAA6B,CAAA;;;IAyC3D,kFAAkF;;;;;IAElF,qEAAqE;;;;;;;IAFrE,kFAAkF;;;;;IAElF,qEAAqE;;;;;;;;;;;;;;;;;;AAzCvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,qBAAa,SAAU,SAAQ,cAM7B;IACA,MAAM,QAAO,GAAG,CAId;CACH;;IAMC,0CAA0C;;IAE1C,gGAAgG;;;AANlG;;GAEG;AACH,qBAAa,qBAAsB,SAAQ,0BAKzC;CAAG;;;;AAEL,qBAAa,sBAAuB,SAAQ,2BAE1C;CAAG;;;;AAEL,qBAAa,gBAAiB,SAAQ,qBAEpC;CAAG;;AAEL,qBAAa,OAAQ,SAAQ,YAA6E;CAAG;;AAE7G,qBAAa,eAAgB,SAAQ,oBAA2D;CAAG;;;;;;;;;;;;;;;;;;;;;;AAEnG,uCAAuC;AACvC,qBAAa,YAAa,SAAQ,iBAGhC;IACA,MAAM,QAAO,GAAG,CAqBf;CACF;;;;;IAMC,iEAAiE;;;;;;;IAAjE,iEAAiE;;;;;;;;;;;;;;AAJnE,qBAAa,kBAAmB,SAAQ,uBAOtC;IACA,MAAM,QAAO,GAAG,CAQf;CACF;;;;;IAMC,0CAA0C;;;;;;;IAA1C,0CAA0C;;;;;;;;;;;;;;AAJ5C,qBAAa,iBAAkB,SAAQ,sBAOrC;IACA,MAAM,QAAO,GAAG,CAQf;CACF;;;IAIC,mDAAmD;;;;;;;;IAAnD,mDAAmD;;;;;;;;;;;;;;;;AAFrD,qBAAa,iBAAkB,SAAQ,sBAKrC;IACA,MAAM,QAAO,GAAG,CAMf;CACF;;;;;;;;;;;;AAED,qBAAa,0BAA2B,SAAQ,+BAG9C;CAAG;;AAEL,qBAAa,WAAY,SAAQ,gBAKhC;CAAG;AAoBJ,eAAO,MAAM,KAAK,GAAI,0EAMnB;IACD,SAAS,EAAE,SAAS,CAAA;IACpB,OAAO,EAAE,OAAO,OAAO,CAAC,IAAI,CAAA;IAC5B,aAAa,EAAE,CAAC,KAAK,EAAE,cAAc,CAAC,eAAe,KAAK,OAAO,CAAA;IACjE,YAAY,EAAE,CAAC,CAAC,EAAE,cAAc,CAAC,eAAe,EAAE,CAAC,EAAE,cAAc,CAAC,eAAe,KAAK,OAAO,CAAA;IAC/F,8GAA8G;IAC9G,kBAAkB,CAAC,EAAE,OAAO,CAAA;CAC7B,KAAG,OAAO,WAAW,CAAC,IA0MtB,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,mBAAmB,GAAI,sFAMjC;IACD,cAAc,EAAE,aAAa,CAAC,cAAc,CAAC,eAAe,CAAC,CAAA;IAC7D,cAAc,EAAE,aAAa,CAAC,cAAc,CAAC,eAAe,CAAC,CAAA;IAC7D,YAAY,EAAE,CAAC,CAAC,EAAE,cAAc,CAAC,eAAe,EAAE,CAAC,EAAE,cAAc,CAAC,eAAe,KAAK,OAAO,CAAA;IAC/F,aAAa,EAAE,CAAC,KAAK,EAAE,cAAc,CAAC,eAAe,KAAK,OAAO,CAAA;IACjE,kBAAkB,EAAE,OAAO,CAAA;CAC5B,KAAG,MAuBH,CAAA"}