@automerge/automerge-repo 1.0.7 → 1.0.9

package/src/helpers/throttle.ts

@@ -0,0 +1,43 @@
+/** Throttle
+ * Returns a function with a built in throttle timer that runs after `delay` ms.
+ *
+ * This function differs from a conventional `throttle` in that it ensures the final
+ * call will also execute and delays sending the first one until `delay` ms to allow
+ * additional work to accumulate.
+ *
+ * Here's a diagram:
+ *
+ * calls +----++++++-----++----
+ * dlay  ^--v ^--v^--v   ^--v
+ * execs ---+----+---+------+--
+ *
+ * The goal in this design is to create batches of changes without flooding
+ * communication or storage systems while still feeling responsive.
+ * (By default we communicate at 10hz / every 100ms.)
+ *
+ * Note that the args go inside the parameter and you should be careful not to
+ * recreate the function on each usage. (In React, see useMemo().)
+ *
+ *
+ * Example usage:
+ * const callback = debounce((ev) => { doSomethingExpensiveOrOccasional() }, 100)
+ * target.addEventListener('frequent-event', callback);
+ *
+ */
+
+export const throttle = <F extends (...args: Parameters<F>) => ReturnType<F>>(
+  fn: F,
+  delay: number
+) => {
+  let lastCall = Date.now()
+  let wait
+  let timeout: ReturnType<typeof setTimeout>
+  return function (...args: Parameters<F>) {
+    wait = lastCall + delay - Date.now()
+    clearTimeout(timeout)
+    timeout = setTimeout(() => {
+      fn.apply(null, args)
+      lastCall = Date.now()
+    }, wait)
+  }
+}

package/src/index.ts

@@ -26,16 +26,16 @@
  * ```
  */
 
-export { Repo } from "./Repo.js"
 export { DocHandle } from "./DocHandle.js"
-export { NetworkAdapter } from "./network/NetworkAdapter.js"
-export { StorageAdapter } from "./storage/StorageAdapter.js"
 export {
   isValidAutomergeUrl,
   parseAutomergeUrl,
   stringifyAutomergeUrl,
 } from "./DocUrl.js"
+export { Repo } from "./Repo.js"
+export { NetworkAdapter } from "./network/NetworkAdapter.js"
 export { isValidRepoMessage } from "./network/messages.js"
+export { StorageAdapter } from "./storage/StorageAdapter.js"
 
 /** @hidden **/
 export * as cbor from "./helpers/cbor.js"

package/src/network/NetworkSubsystem.ts

@@ -4,8 +4,8 @@ import { PeerId, SessionId } from "../types.js"
 import { NetworkAdapter, PeerDisconnectedPayload } from "./NetworkAdapter.js"
 import {
   EphemeralMessage,
-  RepoMessage,
   MessageContents,
+  RepoMessage,
   isEphemeralMessage,
   isValidRepoMessage,
 } from "./messages.js"

package/src/storage/StorageSubsystem.ts

@@ -1,10 +1,10 @@
 import * as A from "@automerge/automerge/next"
-import { StorageAdapter, StorageKey } from "./StorageAdapter.js"
-import * as sha256 from "fast-sha256"
-import { type DocumentId } from "../types.js"
-import { mergeArrays } from "../helpers/mergeArrays.js"
 import debug from "debug"
+import * as sha256 from "fast-sha256"
 import { headsAreSame } from "../helpers/headsAreSame.js"
+import { mergeArrays } from "../helpers/mergeArrays.js"
+import { type DocumentId } from "../types.js"
+import { StorageAdapter, StorageKey } from "./StorageAdapter.js"
 
 // Metadata about a chunk of data loaded from storage. This is stored on the
 // StorageSubsystem so when we are compacting we know what chunks we can safely delete

package/src/synchronizer/CollectionSynchronizer.ts

@@ -1,12 +1,12 @@
+import debug from "debug"
 import { DocHandle } from "../DocHandle.js"
 import { stringifyAutomergeUrl } from "../DocUrl.js"
 import { Repo } from "../Repo.js"
+import { RepoMessage } from "../network/messages.js"
 import { DocumentId, PeerId } from "../types.js"
 import { DocSynchronizer } from "./DocSynchronizer.js"
 import { Synchronizer } from "./Synchronizer.js"
 
-import debug from "debug"
-import { RepoMessage } from "../network/messages.js"
 const log = debug("automerge-repo:collectionsync")
 
 /** A CollectionSynchronizer is responsible for synchronizing a DocCollection with peers. */

package/src/synchronizer/DocSynchronizer.ts

@@ -11,14 +11,15 @@ import {
 import {
   DocumentUnavailableMessage,
   EphemeralMessage,
-  RepoMessage,
   MessageContents,
+  RepoMessage,
   RequestMessage,
   SyncMessage,
   isRequestMessage,
 } from "../network/messages.js"
 import { PeerId } from "../types.js"
 import { Synchronizer } from "./Synchronizer.js"
+import { throttle } from "../helpers/throttle.js"
 
 type PeerDocumentStatus = "unknown" | "has" | "unavailable" | "wants"
 
@@ -28,8 +29,7 @@ type PeerDocumentStatus = "unknown" | "has" | "unavailable" | "wants"
  */
 export class DocSynchronizer extends Synchronizer {
   #log: debug.Debugger
-  #conciseLog: debug.Debugger
-  #opsLog: debug.Debugger
+  syncDebounceRate = 100
 
   /** Active peers */
   #peers: PeerId[] = []
@@ -46,11 +46,12 @@ export class DocSynchronizer extends Synchronizer {
   constructor(private handle: DocHandle<unknown>) {
     super()
     const docId = handle.documentId.slice(0, 5)
-    this.#conciseLog = debug(`automerge-repo:concise:docsync:${docId}`) // Only logs one line per receive/send
     this.#log = debug(`automerge-repo:docsync:${docId}`)
-    this.#opsLog = debug(`automerge-repo:ops:docsync:${docId}`) // Log list of ops of each message
 
-    handle.on("change", () => this.#syncWithPeers())
+    handle.on(
+      "change",
+      throttle(() => this.#syncWithPeers(), this.syncDebounceRate)
+    )
 
     handle.on("ephemeral-message-outbound", payload =>
       this.#broadcastToPeers(payload)
@@ -168,7 +169,9 @@ export class DocSynchronizer extends Synchronizer {
   }
 
   beginSync(peerIds: PeerId[]) {
-    const newPeers = new Set(peerIds.filter(peerId => !this.#peers.includes(peerId)))
+    const newPeers = new Set(
+      peerIds.filter(peerId => !this.#peers.includes(peerId))
+    )
     this.#log(`beginSync: ${peerIds.join(", ")}`)
 
     // HACK: if we have a sync state already, we round-trip it through the encoding system to make

package/src/synchronizer/Synchronizer.ts

@@ -1,5 +1,5 @@
 import { EventEmitter } from "eventemitter3"
-import { RepoMessage, MessageContents } from "../network/messages.js"
+import { MessageContents, RepoMessage } from "../network/messages.js"
 
 export abstract class Synchronizer extends EventEmitter<SynchronizerEvents> {
   abstract receiveMessage(message: RepoMessage): void

package/test/CollectionSynchronizer.test.ts

@@ -1,5 +1,5 @@
 import assert from "assert"
-import { describe, it, beforeEach } from "vitest"
+import { beforeEach, describe, it } from "vitest"
 import { PeerId, Repo } from "../src/index.js"
 import { CollectionSynchronizer } from "../src/synchronizer/CollectionSynchronizer.js"
 

package/test/DocHandle.test.ts

@@ -1,6 +1,6 @@
 import * as A from "@automerge/automerge/next"
-import { decode } from "cbor-x"
 import assert from "assert"
+import { decode } from "cbor-x"
 import { describe, it } from "vitest"
 import { generateAutomergeUrl, parseAutomergeUrl } from "../src/DocUrl.js"
 import { eventPromise } from "../src/helpers/eventPromise.js"

package/test/DocSynchronizer.test.ts

@@ -2,7 +2,6 @@ import assert from "assert"
 import { describe, it } from "vitest"
 import { DocHandle } from "../src/DocHandle.js"
 import { generateAutomergeUrl, parseAutomergeUrl } from "../src/DocUrl.js"
-import { generateAutomergeUrl, parseAutomergeUrl } from "../src/DocUrl.js"
 import { eventPromise } from "../src/helpers/eventPromise.js"
 import {
   DocumentUnavailableMessage,
@@ -11,9 +10,6 @@ import {
 import { DocSynchronizer } from "../src/synchronizer/DocSynchronizer.js"
 import { PeerId } from "../src/types.js"
 import { TestDoc } from "./types.js"
-import { DocSynchronizer } from "../src/synchronizer/DocSynchronizer.js"
-import { PeerId } from "../src/types.js"
-import { TestDoc } from "./types.js"
 
 const alice = "alice" as PeerId
 const bob = "bob" as PeerId

package/test/Repo.test.ts

@@ -25,10 +25,10 @@ import { getRandomItem } from "./helpers/getRandomItem.js"
 import { TestDoc } from "./types.js"
 
 describe("Repo", () => {
-  describe("single repo", () => {
-    const setup = (networkReady = true) => {
+  describe("local only", () => {
+    const setup = ({ startReady = true } = {}) => {
       const storageAdapter = new DummyStorageAdapter()
-      const networkAdapter = new DummyNetworkAdapter(networkReady)
+      const networkAdapter = new DummyNetworkAdapter({ startReady })
 
       const repo = new Repo({
         storage: storageAdapter,
@@ -182,7 +182,7 @@ describe("Repo", () => {
     })
 
     it("doesn't mark a document as unavailable until network adapters are ready", async () => {
-      const { repo, networkAdapter } = setup(false)
+      const { repo, networkAdapter } = setup({ startReady: false })
       const url = generateAutomergeUrl()
       const handle = repo.find<TestDoc>(url)
 
@@ -238,7 +238,7 @@ describe("Repo", () => {
 
       assert.equal(handle.isReady(), true)
 
-      await pause()
+      await pause(150)
 
       const repo2 = new Repo({
         storage: storageAdapter,
@@ -377,25 +377,28 @@ describe("Repo", () => {
     })
   })
 
-  describe("sync", async () => {
-    const charlieExcludedDocuments: DocumentId[] = []
-    const bobExcludedDocuments: DocumentId[] = []
+  describe("with peers (linear network)", async () => {
+    const setup = async ({ connectAlice = true } = {}) => {
+      const charlieExcludedDocuments: DocumentId[] = []
+      const bobExcludedDocuments: DocumentId[] = []
 
-    const sharePolicy: SharePolicy = async (peerId, documentId) => {
-      if (documentId === undefined) return false
+      const sharePolicy: SharePolicy = async (peerId, documentId) => {
+        if (documentId === undefined) return false
 
-      // make sure that charlie never gets excluded documents
-      if (charlieExcludedDocuments.includes(documentId) && peerId === "charlie")
-        return false
+        // make sure that charlie never gets excluded documents
+        if (
+          charlieExcludedDocuments.includes(documentId) &&
+          peerId === "charlie"
+        )
+          return false
 
-      // make sure that bob never gets excluded documents
-      if (bobExcludedDocuments.includes(documentId) && peerId === "bob")
-        return false
+        // make sure that bob never gets excluded documents
+        if (bobExcludedDocuments.includes(documentId) && peerId === "bob")
+          return false
 
-      return true
-    }
+        return true
+      }
 
-    const setupLinearNetwork = (connectAlice = true) => {
       // Set up three repos; connect Alice to Bob, and Bob to Charlie
 
       const abChannel = new MessageChannel()
@@ -431,81 +434,16 @@ describe("Repo", () => {
         bcChannel.port1.close()
       }
 
-      function doConnectAlice() {
+      function connectAliceToBob() {
         aliceRepo.networkSubsystem.addNetworkAdapter(
           new MessageChannelNetworkAdapter(ab)
         )
-        //bobRepo.networkSubsystem.addNetworkAdapter(new MessageChannelNetworkAdapter(bobToAlice))
       }
 
       if (connectAlice) {
-        doConnectAlice()
-      }
-
-      return {
-        teardown,
-        aliceRepo,
-        bobRepo,
-        charlieRepo,
-        connectAliceToBob: doConnectAlice,
-      }
-    }
-
-    const setupMeshNetwork = () => {
-      // Set up three repos; connect Alice to Bob, Bob to Charlie, and Alice to Charlie
-
-      const abChannel = new MessageChannel()
-      const bcChannel = new MessageChannel()
-      const acChannel = new MessageChannel()
-
-      const { port1: ab, port2: ba } = abChannel
-      const { port1: bc, port2: cb } = bcChannel
-      const { port1: ac, port2: ca } = acChannel
-
-      const aliceRepo = new Repo({
-        network: [
-          new MessageChannelNetworkAdapter(ab),
-          new MessageChannelNetworkAdapter(ac),
-        ],
-        peerId: "alice" as PeerId,
-        sharePolicy,
-      })
-
-      const bobRepo = new Repo({
-        network: [
-          new MessageChannelNetworkAdapter(ba),
-          new MessageChannelNetworkAdapter(bc),
-        ],
-        peerId: "bob" as PeerId,
-        sharePolicy,
-      })
-
-      const charlieRepo = new Repo({
-        network: [
-          new MessageChannelNetworkAdapter(ca),
-          new MessageChannelNetworkAdapter(cb),
-        ],
-        peerId: "charlie" as PeerId,
-      })
-
-      const teardown = () => {
-        abChannel.port1.close()
-        bcChannel.port1.close()
-        acChannel.port1.close()
+        connectAliceToBob()
       }
 
-      return {
-        teardown,
-        aliceRepo,
-        bobRepo,
-        charlieRepo,
-      }
-    }
-
-    const setup = async (connectAlice = true) => {
-      const { teardown, aliceRepo, bobRepo, charlieRepo, connectAliceToBob } =
-        setupLinearNetwork(connectAlice)
-
       const aliceHandle = aliceRepo.create<TestDoc>()
       aliceHandle.change(d => {
         d.foo = "bar"
@@ -607,17 +545,19 @@ describe("Repo", () => {
     })
 
     it("doesn't find a document which doesn't exist anywhere on the network", async () => {
-      const { charlieRepo } = await setup()
+      const { charlieRepo, teardown } = await setup()
       const url = generateAutomergeUrl()
       const handle = charlieRepo.find<TestDoc>(url)
       assert.equal(handle.isReady(), false)
 
       const doc = await handle.doc()
       assert.equal(doc, undefined)
+
+      teardown()
     })
 
     it("fires an 'unavailable' event when a document is not available on the network", async () => {
-      const { charlieRepo } = await setup()
+      const { charlieRepo, teardown } = await setup()
       const url = generateAutomergeUrl()
       const handle = charlieRepo.find<TestDoc>(url)
       assert.equal(handle.isReady(), false)
@@ -631,6 +571,8 @@ describe("Repo", () => {
       const handle2 = charlieRepo.find<TestDoc>(url)
       assert.equal(handle2.isReady(), false)
       await eventPromise(handle2, "unavailable")
+
+      teardown()
     })
 
     it("a previously unavailable document syncs over the network if a peer with it connects", async () => {
@@ -640,7 +582,7 @@ describe("Repo", () => {
         aliceRepo,
         teardown,
         connectAliceToBob,
-      } = await setup(false)
+      } = await setup({ connectAlice: false })
 
       const url = stringifyAutomergeUrl({ documentId: notForCharlie })
       const handle = charlieRepo.find<TestDoc>(url)
@@ -690,7 +632,7 @@ describe("Repo", () => {
       const a = new Repo({
         network: [new MessageChannelNetworkAdapter(ab)],
         peerId: "a" as PeerId,
-        sharePolicy: async () => true
+        sharePolicy: async () => true,
       })
 
       const handle = a.find(url)
@@ -710,7 +652,6 @@ describe("Repo", () => {
       // The empty repo should be notified of the new peer, send it a request
       // and eventually resolve the handle to "READY"
       await handle.whenReady()
-
     })
 
     it("a deleted document from charlieRepo can be refetched", async () => {
@@ -736,13 +677,14 @@ describe("Repo", () => {
     })
 
     it("can emit an 'unavailable' event when it's not found on the network", async () => {
-      const { charlieRepo } = setupMeshNetwork()
+      const { charlieRepo, teardown } = await setup()
 
       const url = generateAutomergeUrl()
       const handle = charlieRepo.find<TestDoc>(url)
       assert.equal(handle.isReady(), false)
 
       await eventPromise(handle, "unavailable")
+      teardown()
     })
 
     it("syncs a bunch of changes", async () => {
@@ -772,7 +714,6 @@ describe("Repo", () => {
           d.foo = Math.random().toString()
         })
       }
-      await pause(500)
 
       teardown()
     })
@@ -790,8 +731,6 @@ describe("Repo", () => {
         stringifyAutomergeUrl({ documentId: notForCharlie })
       )
 
-      await pause(50)
-
       const charliePromise = new Promise<void>((resolve, reject) => {
         charlieRepo.networkSubsystem.on("message", message => {
           if (
@@ -813,49 +752,98 @@ describe("Repo", () => {
       await charliePromise
       teardown()
     })
+  })
 
-    it("can broadcast a message without entering into an infinite loop", async () => {
-      const { aliceRepo, bobRepo, charlieRepo } = setupMeshNetwork()
+  describe("with peers (mesh network)", () => {
+    const setup = async () => {
+      // Set up three repos; connect Alice to Bob, Bob to Charlie, and Alice to Charlie
+
+      const abChannel = new MessageChannel()
+      const bcChannel = new MessageChannel()
+      const acChannel = new MessageChannel()
+
+      const { port1: ab, port2: ba } = abChannel
+      const { port1: bc, port2: cb } = bcChannel
+      const { port1: ac, port2: ca } = acChannel
+
+      const aliceRepo = new Repo({
+        network: [
+          new MessageChannelNetworkAdapter(ab),
+          new MessageChannelNetworkAdapter(ac),
+        ],
+        peerId: "alice" as PeerId,
+      })
 
-      const message = { presence: "alex" }
+      const bobRepo = new Repo({
+        network: [
+          new MessageChannelNetworkAdapter(ba),
+          new MessageChannelNetworkAdapter(bc),
+        ],
+        peerId: "bob" as PeerId,
+      })
+
+      const charlieRepo = new Repo({
+        network: [
+          new MessageChannelNetworkAdapter(ca),
+          new MessageChannelNetworkAdapter(cb),
+        ],
+        peerId: "charlie" as PeerId,
+      })
+
+      const teardown = () => {
+        abChannel.port1.close()
+        bcChannel.port1.close()
+        acChannel.port1.close()
+      }
+
+      await Promise.all([
+        eventPromise(aliceRepo.networkSubsystem, "peer"),
+        eventPromise(bobRepo.networkSubsystem, "peer"),
+        eventPromise(charlieRepo.networkSubsystem, "peer"),
+      ])
+
+      return {
+        teardown,
+        aliceRepo,
+        bobRepo,
+        charlieRepo,
+      }
+    }
+
+    it("can broadcast a message without entering into an infinite loop", async () => {
+      const { aliceRepo, bobRepo, charlieRepo, teardown } = await setup()
 
       const aliceHandle = aliceRepo.create<TestDoc>()
 
       const bobHandle = bobRepo.find(aliceHandle.url)
       const charlieHandle = charlieRepo.find(aliceHandle.url)
 
-      const aliceDoesntGetIt = new Promise<void>((resolve, reject) => {
-        setTimeout(() => {
-          resolve()
-        }, 100)
-
-        aliceHandle.on("ephemeral-message", () => {
-          reject(new Error("alice got the message"))
-        })
+      // Alice should not receive her own ephemeral message
+      aliceHandle.on("ephemeral-message", () => {
+        throw new Error("Alice should not receive her own ephemeral message")
       })
 
+      // Bob and Charlie should receive Alice's ephemeral message
       const bobGotIt = eventPromise(bobHandle, "ephemeral-message")
       const charlieGotIt = eventPromise(charlieHandle, "ephemeral-message")
 
-      // let things get in sync and peers meet one another
+      // let peers meet and sync up
       await pause(50)
+
+      // Alice sends an ephemeral message
+      const message = { foo: "bar" }
       aliceHandle.broadcast(message)
 
-      const [bob, charlie] = await Promise.all([
-        bobGotIt,
-        charlieGotIt,
-        aliceDoesntGetIt,
-      ])
+      const [bob, charlie] = await Promise.all([bobGotIt, charlieGotIt])
 
       assert.deepStrictEqual(bob.message, message)
       assert.deepStrictEqual(charlie.message, message)
+
+      teardown()
     })
 
     it("notifies peers when a document is cloned", async () => {
-      const { bobRepo, charlieRepo } = setupMeshNetwork()
-
-      // pause to let the network set up
-      await pause(50)
+      const { bobRepo, charlieRepo, teardown } = await setup()
 
       const handle = bobRepo.create<TestDoc>()
       handle.change(d => {
@@ -869,13 +857,12 @@ describe("Repo", () => {
       const charlieHandle = charlieRepo.find(handle2.url)
       await charlieHandle.doc()
       assert.deepStrictEqual(charlieHandle.docSync(), { foo: "bar" })
+
+      teardown()
     })
 
     it("notifies peers when a document is merged", async () => {
-      const { bobRepo, charlieRepo } = setupMeshNetwork()
-
-      // pause to let the network set up
-      await pause(50)
+      const { bobRepo, charlieRepo, teardown } = await setup()
 
       const handle = bobRepo.create<TestDoc>()
       handle.change(d => {
@@ -897,19 +884,23 @@ describe("Repo", () => {
       handle.merge(handle2)
 
       // wait for the network to do it's thang
-      await pause(50)
+      await pause(350)
 
       await charlieHandle.doc()
       assert.deepStrictEqual(charlieHandle.docSync(), { foo: "baz" })
+
+      teardown()
     })
   })
 })
 
+const warn = console.warn
+const NO_OP = () => {}
+
 const disableConsoleWarn = () => {
-  console["_warn"] = console.warn
-  console.warn = () => {}
+  console.warn = NO_OP
 }
 
 const reenableConsoleWarn = () => {
-  console.warn = console["_warn"]
+  console.warn = warn
 }

package/test/helpers/DummyNetworkAdapter.ts

@@ -1,16 +1,21 @@
 import { NetworkAdapter } from "../../src/index.js"
 
 export class DummyNetworkAdapter extends NetworkAdapter {
-  #startReady = true
-  constructor(startReady: boolean) {
+  #startReady: boolean
+
+  constructor({ startReady = true }: Options = {}) {
     super()
     this.#startReady = startReady
   }
-  send() { }
+  send() {}
   connect(_: string) {
     if (this.#startReady) {
       this.emit("ready", { network: this })
     }
   }
-  disconnect() { }
+  disconnect() {}
+}
+
+type Options = {
+  startReady?: boolean
 }

package/test/helpers/DummyStorageAdapter.ts

@@ -11,10 +11,12 @@ export class DummyStorageAdapter implements StorageAdapter {
     return key.split(".")
   }
 
-  async loadRange(keyPrefix: StorageKey): Promise<{data: Uint8Array, key: StorageKey}[]> {
+  async loadRange(
+    keyPrefix: StorageKey
+  ): Promise<{ data: Uint8Array; key: StorageKey }[]> {
     const range = Object.entries(this.#data)
       .filter(([key, _]) => key.startsWith(this.#keyToString(keyPrefix)))
-      .map(([key, data]) => ({key: this.#stringToKey(key), data}))
+      .map(([key, data]) => ({ key: this.#stringToKey(key), data }))
     return Promise.resolve(range)
   }
 

package/dist/EphemeralData.d.ts

@@ -1,20 +0,0 @@
-import { DocumentId, PeerId } from "./index.js";
-import { EphemeralMessage, MessageContents } from "./network/messages.js";
-/** A randomly generated string created when the {@link Repo} starts up */
-export type SessionId = string & {
-    __SessionId: false;
-};
-export interface EphemeralDataPayload {
-    documentId: DocumentId;
-    peerId: PeerId;
-    data: {
-        peerId: PeerId;
-        documentId: DocumentId;
-        data: unknown;
-    };
-}
-export type EphemeralDataMessageEvents = {
-    message: (event: MessageContents<EphemeralMessage>) => void;
-    data: (event: EphemeralDataPayload) => void;
-};
-//# sourceMappingURL=EphemeralData.d.ts.map

package/dist/EphemeralData.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"EphemeralData.d.ts","sourceRoot":"","sources":["../src/EphemeralData.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAC/C,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAGzE,0EAA0E;AAC1E,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG;IAAE,WAAW,EAAE,KAAK,CAAA;CAAE,CAAA;AAEvD,MAAM,WAAW,oBAAoB;IACnC,UAAU,EAAE,UAAU,CAAA;IACtB,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,UAAU,CAAC;QAAC,IAAI,EAAE,OAAO,CAAA;KAAE,CAAA;CAChE;AAED,MAAM,MAAM,0BAA0B,GAAG;IACvC,OAAO,EAAE,CAAC,KAAK,EAAE,eAAe,CAAC,gBAAgB,CAAC,KAAK,IAAI,CAAA;IAC3D,IAAI,EAAE,CAAC,KAAK,EAAE,oBAAoB,KAAK,IAAI,CAAA;CAC5C,CAAA"}