@automerge/automerge-repo 0.0.1

package/.eslintrc

@@ -0,0 +1,28 @@
+{
+  "env": {
+    "browser": true,
+    "es2021": true
+  },
+  "extends": [
+    "eslint:recommended",
+    "plugin:@typescript-eslint/eslint-recommended",
+    "plugin:@typescript-eslint/recommended"
+  ],
+  "ignorePatterns": ["dist/**"],
+  "parser": "@typescript-eslint/parser",
+  "plugins": ["@typescript-eslint", "mocha"],
+  "parserOptions": {
+    "project": "./tsconfig.json",
+    "ecmaVersion": "latest",
+    "sourceType": "module"
+  },
+  "rules": {
+    "semi": ["error", "never"],
+    "import/extensions": 0,
+    "lines-between-class-members": 0,
+    "@typescript-eslint/no-floating-promises": "error",
+    "@typescript-eslint/no-empty-function": ["warn", { "allow": ["methods"]}],
+    "no-param-reassign": 0,
+    "no-use-before-define": 0
+  }
+}

package/.mocharc.json

@@ -0,0 +1,5 @@
+{
+  "extension": ["ts"],
+  "spec": "test/*.test.ts",
+  "loader": "ts-node/esm"
+}

package/README.md

@@ -0,0 +1,298 @@
+# Automerge Repo
+
+This is a wrapper for the [Automerge](https://github.com/automerge/automerge) CRDT library which
+provides facilities to support working with many documents at once, as well as pluggable networking
+and storage.
+
+This is the core library. It handles dispatch of events and provides shared functionality such as
+deciding which peers to connect to or when to write data out to storage.
+
+Other packages in this monorepo include:
+
+- [@automerge/automerge-repo-demo-counter](/packages/@automerge/automerge-repo-demo-counter/): A React-based demonstration
+  application.
+- [@automerge/automerge-repo-react-hooks](/packages/@automerge/automerge-repo-react-hooks/): Example hooks for use with
+  React.
+- [@automerge/automerge-repo-sync-server](/packages/@automerge/automerge-repo-sync-server/): A small synchronization
+  server that facilitates asynchronous communication between peers
+
+#### Storage adapters
+
+- [automerge-repo-storage-localforage](/packages/automerge-repo-storage-localforage/): A storage
+  adapter to persist data in a browser
+- [automerge-repo-storage-nodefs](/packages/automerge-repo-storage-nodefs/): A storage adapter to
+  write changes to the filesystem
+
+#### Network adapters
+
+- [automerge-repo-network-websocket](/packages/automerge-repo-network-websocket/): Network adapters
+  for both sides of a client/server configuration over websocket
+- [automerge-repo-network-localfirstrelay](/packages/automerge-repo-network-localfirstrelay/): A
+  network client that uses [@localfirst/relay](https://github.com/local-first-web/relay) to relay
+  traffic between peers
+- [automerge-repo-network-messagechannel](/packages/automerge-repo-network-messagechannel/): A
+  network adapter that uses the [MessageChannel
+  API](https://developer.mozilla.org/en-US/docs/Web/API/MessageChannel) to communicate between tabs
+- [automerge-repo-network-broadcastchannel](/packages/automerge-repo-network-broadcastchannel/):
+  Likely only useful for experimentation, but allows simple (inefficient) tab-to-tab data
+  synchronization
+
+## Usage
+
+This library provides two main components: the `Repo` itself, and the `DocHandle`s it contains.
+
+A `Repo` exposes these methods:
+
+- `create<T>()`  
+  Creates a new, empty `Automerge.Doc` and returns a `DocHandle` for it.
+- `find<T>(docId: DocumentId)`  
+  Looks up a given document either on the local machine or (if necessary) over any configured
+  networks.
+- `delete(docId: DocumentId)`  
+  Deletes the local copy of a document from the local cache and local storage. _This does not currently delete the document from any other peers_.
+- `.on("document", ({handle: DocHandle}) => void)`  
+  Registers a callback to be fired each time a new document is loaded or created.
+- `.on("delete-document", ({handle: DocHandle}) => void)`  
+  Registers a callback to be fired each time a new document is loaded or created.
+
+A `DocHandle` is a wrapper around an `Automerge.Doc`. Its primary function is to dispatch changes to
+the document.
+
+- `handle.change((doc: T) => void)`  
+  Calls the provided callback with an instrumented mutable object
+  representing the document. Any changes made to the document will be recorded and distributed to
+  other nodes.
+- `handle.value()`  
+  Returns a `Promise<Doc<T>>` that will contain the current value of the document.
+  it waits until the document has finished loading and/or synchronizing over the network before
+  returning a value.
+
+When required, you can also access the underlying document directly, but only after the handle is ready:
+
+```ts
+if (handle.ready()) {
+  doc = handle.doc
+} else {
+  handle.value().then(d => {
+    doc = d
+  })
+}
+```
+
+A `DocHandle` also emits these events:
+
+- `change({handle: DocHandle, doc: Doc<T>})`  
+  Called any time changes are created or received on the document. Request the `value()` from the
+  handle.
+- `patch({handle: DocHandle, before: Doc, after: Doc, patches: Patch[]})`  
+  Useful for manual increment maintenance of a video, most notably for text editors.
+- `delete`  
+  Called when the document is deleted locally.
+
+## Creating a repo
+
+The repo needs to be configured with storage and network adapters. If you give it neither, it will
+still work, but you won't be able to find any data and data created won't outlast the process.
+
+Multiple network adapters (even of the same type) can be added to a repo, even after it is created.
+
+A repo currently only supports a single storage adapter, and it must be provided at creation.
+
+Here is an example of creating a repo with a localforage storage adapter and a broadcast channel
+network adapter:
+
+```ts
+const repo = new Repo({
+  network: [new BroadcastChannelNetworkAdapter()],
+  storage: new LocalForageStorageAdapter(),
+  sharePolicy: async (peerId: PeerId, documentId: DocumentId) => true // this is the default
+})
+```
+
+### Share Policy
+The share policy is used to determine which document in your repo should be _automatically_ shared with other peers. **The default setting is to share all documents with all peers.**
+
+> **Warning**
+> If your local repo has deleted a document, a connecting peer with the default share policy will still share that document with you.
+
+You can override this by providing a custom share policy. The function should return a promise resolving to a boolean value indicating whether the document should be shared with the peer.
+
+The share policy will not stop a document being _requested_ by another peer by its `DocumentId`.
+
+```ts
+## Starting the demo app
+
+```bash
+yarn
+yarn dev
+```
+
+## Quickstart
+
+The following instructions will get you a working React app running in a browser.
+
+```bash
+yarn create vite
+# Project name: hello-automerge-repo
+# Select a framework: React
+# Select a variant: TypeScript
+
+cd hello-automerge-repo
+yarn
+yarn add @automerge/automerge automerge-repo automerge-repo-react-hooks automerge-repo-network-broadcastchannel automerge-repo-storage-localforage vite-plugin-wasm vite-plugin-top-level-await
+```
+
+Edit the `vite.config.ts`. (This is all need to work around packaging hiccups due to WASM. We look
+forward to the day that we can delete this step entirely.)
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite"
+import react from "@vitejs/plugin-react"
+import wasm from "vite-plugin-wasm"
+import topLevelAwait from "vite-plugin-top-level-await"
+
+export default defineConfig({
+  plugins: [wasm(), topLevelAwait(), react()],
+
+  worker: {
+    format: "es",
+    plugins: [wasm(), topLevelAwait()],
+  },
+
+  optimizeDeps: {
+    // This is necessary because otherwise `vite dev` includes two separate
+    // versions of the JS wrapper. This causes problems because the JS
+    // wrapper has a module level variable to track JS side heap
+    // allocations, and initializing this twice causes horrible breakage
+    exclude: [
+      "@automerge/automerge-wasm",
+      "@automerge/automerge-wasm/bundler/bindgen_bg.wasm",
+      "@syntect/wasm",
+    ],
+  },
+
+  server: {
+    fs: {
+      strict: false,
+    },
+  },
+})
+```
+
+Now set up the repo in `src/main.tsx` by importing the bits, creating the repo, and passing down a
+RepoContext. We also create a document and store its `documentId` in localStorage.
+
+```tsx
+// src/main.tsx
+import React from "react"
+import ReactDOM from "react-dom/client"
+import App from "./App.js"
+import { Repo } from "@automerge/automerge-repo"
+import { BroadcastChannelNetworkAdapter } from "@automerge/automerge-repo-network-broadcastchannel"
+import { LocalForageStorageAdapter } from "@automerge/automerge-repo-storage-localforage"
+import { RepoContext } from "@automerge/automerge-repo-react-hooks"
+
+const repo = new Repo({
+  network: [new BroadcastChannelNetworkAdapter()],
+  storage: new LocalForageStorageAdapter(),
+})
+
+let rootDocId = localStorage.rootDocId
+if (!rootDocId) {
+  const handle = repo.create()
+  localStorage.rootDocId = rootDocId = handle.documentId
+}
+
+ReactDOM.createRoot(document.getElementById("root") as HTMLElement).render(
+  <RepoContext.Provider value={repo}>
+    <React.StrictMode>
+      <App documentId={rootDocId} />
+    </React.StrictMode>
+  </RepoContext.Provider>
+)
+```
+
+Now update `App.tsx` to load the document from the Repo based on the documentId passed in. Then, use
+the document to render a button that increments the count.
+
+```tsx
+// App.tsx
+import { useDocument } from "@automerge/automerge-repo-react-hooks"
+import { DocumentId } from "@automerge/automerge-repo"
+
+interface Doc {
+  count: number
+}
+
+export default function App(props: { documentId: DocumentId }) {
+  const [doc, changeDoc] = useDocument<Doc>(props.documentId)
+
+  return (
+    <button
+      onClick={() => {
+        changeDoc((d: any) => {
+          d.count = (d.count || 0) + 1
+        })
+      }}
+    >
+      count is: {doc?.count ?? 0}
+    </button>
+  )
+}
+```
+
+You should now have a working React application using Automerge. Try running it with `yarn dev`, and
+open it in two browser windows. You should see the count increment in both windows.
+
+![](/images/hello-automerge-repo.gif)
+
+This application is also available as a package in this repo in
+[automerge-repo-demo-counter](/packages/automerge-repo-demo-counter). You can run it with `yarn
+dev:demo`.
+
+### Adding a sync server
+
+First, get a sync-server running locally, following the instructions for the
+[automerge-repo-sync-server](/packages/automerge-repo-sync-server/) package.
+
+Next, update your application to synchronize with it:
+
+Install the websocket network adapter:
+
+```bash
+yarn add automerge-repo-network-websocket
+```
+
+Now import it and add it to your list of network adapters:
+
+```ts
+// main.tsx
+import { BrowserWebSocketClientAdapter } from "@automerge/automerge-repo-network-websocket" // <-- add this line
+
+// ...
+
+const repo = new Repo({
+  network: [
+    new BroadcastChannelNetworkAdapter(),
+    new BrowserWebSocketClientAdapter("ws://localhost:3030"), // <-- add this line
+  ],
+  storage: new LocalForageStorageAdapter(),
+})
+
+// ...
+```
+
+And you're finished! You can test that your sync server is opening the same document in two
+different browsers (e.g. Chrome and Firefox). (Note that with our current trivial implementation
+you'll need to manually copy the `rootDocId` value between the browsers.)
+
+## Acknowledgements
+
+Originally authored by Peter van Hardenberg.
+
+With gratitude for contributions by:
+ - Herb Caudill
+ - Jeremy Rose
+ - Alex Currie-Clark
+ - Dylan Mackenzie

package/TODO.md

@@ -0,0 +1,54 @@
+## TODO
+
+cursor sharing (multi channel?)
+repo should be a class
+
+---
+
+peer authentication
+E2E encryption
+write more tests
+file-handle based storage
+
+// TODO:
+// efficient sharing of sets of documents
+
+# Future Work and Known Issues
+
+There are a number of problems with the current design which I will briefly enumerate here:
+
+- NetworkSubsystem
+- peer candidate selection -> do we trust this peer? (see Network.js peer-candidate)
+- handle disconnections -> try another protocol
+- syncstates aren't persisted... but neither are client-ids. should they be?
+
+- StorageSubsystem
+- customizable save intervals / manual-only saving
+- separate backends for incremental vs. full document saves
+- S3/redis store for a node storage peer
+
+- Repo Design Problems
+- sending cursors / ephemeral data
+- we should decide what to sync with a peer based on the peer, not just the docId
+- no way of discovering documents as a batch or requesting synchronization for multiple documents.
+
+- SyncProtocol work
+- multi-document syncprotocol
+- non-peer-specific broadcast SyncMessages
+- syncing large repos without having to do expensive loads into memory
+- how to decide what documents to sync with a peer
+- one-way sync support -> i want to receive but not send changes
+- peer-oriented instead of document-oriented sync
+- encrypt contents but not structure, allowing syncing with a semi-trusted peer instead of all the peers
+  - change.hash & change.deps but with a consistently salted hash?
+- RLE encode block of changes
+
+- Synchronizer & network needs improved handling of disconnection & reconnection of peers
+- TODO: preserving syncState in localStorage would be a good optimization
+  StorageSubsystem:
+  // TODO: can we do incremental save that takes advantage of the last binary?
+  /\* TODO: we probably want to be able to distinguish between
+- incremental & compacted writes due to cost & frequency -> give the option for two storage engines
+- we probably also want to have compaction callbacks. count / timeout / manual calls...
+  \*/
+- figure out a compaction callback system (and an option for explicit saves only)

package/dist/DocCollection.d.ts

@@ -0,0 +1,44 @@
+import EventEmitter from "eventemitter3";
+import { DocHandle } from "./DocHandle.js";
+import { type DocumentId } from "./types.js";
+import { type SharePolicy } from "./Repo.js";
+/**
+ * A DocCollection is a collection of DocHandles. It supports creating new documents and finding
+ * documents by ID.
+ * */
+export declare class DocCollection extends EventEmitter<DocCollectionEvents> {
+    #private;
+    /** By default, we share generously with all peers. */
+    sharePolicy: SharePolicy;
+    constructor();
+    /** Returns all the handles we have cached. */
+    get handles(): Record<DocumentId, DocHandle<any>>;
+    /**
+     * Creates a new document and returns a handle to it. The initial value of the document is
+     * an empty object `{}`. Its documentId is generated by the system. we emit a `document` event
+     * to advertise interest in the document.
+     */
+    create<T>(): DocHandle<T>;
+    /**
+     * Retrieves a document by id. It gets data from the local system, but also emits a `document`
+     * event to advertise interest in the document.
+     */
+    find<T>(
+    /** The documentId of the handle to retrieve */
+    documentId: DocumentId): DocHandle<T>;
+    delete(
+    /** The documentId of the handle to delete */
+    documentId: DocumentId): void;
+}
+interface DocCollectionEvents {
+    document: (arg: DocumentPayload) => void;
+    "delete-document": (arg: DeleteDocumentPayload) => void;
+}
+interface DocumentPayload {
+    handle: DocHandle<any>;
+}
+interface DeleteDocumentPayload {
+    documentId: DocumentId;
+}
+export {};
+//# sourceMappingURL=DocCollection.d.ts.map

package/dist/DocCollection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DocCollection.d.ts","sourceRoot":"","sources":["../src/DocCollection.ts"],"names":[],"mappings":"AAAA,OAAO,YAAY,MAAM,eAAe,CAAA;AAExC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,YAAY,CAAA;AAC5C,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,WAAW,CAAA;AAE5C;;;KAGK;AACL,qBAAa,aAAc,SAAQ,YAAY,CAAC,mBAAmB,CAAC;;IAGlE,sDAAsD;IACtD,WAAW,EAAE,WAAW,CAAmB;;IAuB3C,8CAA8C;IAC9C,IAAI,OAAO,uCAEV;IAED;;;;OAIG;IACH,MAAM,CAAC,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC;IAyBzB;;;OAGG;IACH,IAAI,CAAC,CAAC;IACJ,+CAA+C;IAC/C,UAAU,EAAE,UAAU,GACrB,SAAS,CAAC,CAAC,CAAC;IAmBf,MAAM;IACJ,6CAA6C;IAC7C,UAAU,EAAE,UAAU;CAQzB;AAGD,UAAU,mBAAmB;IAC3B,QAAQ,EAAE,CAAC,GAAG,EAAE,eAAe,KAAK,IAAI,CAAA;IACxC,iBAAiB,EAAE,CAAC,GAAG,EAAE,qBAAqB,KAAK,IAAI,CAAA;CACxD;AAED,UAAU,eAAe;IACvB,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,CAAA;CACvB;AAED,UAAU,qBAAqB;IAC7B,UAAU,EAAE,UAAU,CAAA;CACvB"}

package/dist/DocCollection.js

@@ -0,0 +1,85 @@
+import EventEmitter from "eventemitter3";
+import { v4 as uuid } from "uuid";
+import { DocHandle } from "./DocHandle.js";
+/**
+ * A DocCollection is a collection of DocHandles. It supports creating new documents and finding
+ * documents by ID.
+ * */
+export class DocCollection extends EventEmitter {
+    #handleCache = {};
+    /** By default, we share generously with all peers. */
+    sharePolicy = async () => true;
+    constructor() {
+        super();
+    }
+    /** Returns an existing handle if we have it; creates one otherwise. */
+    #getHandle(
+    /** The documentId of the handle to look up or create */
+    documentId, 
+    /** If we know we're creating a new document, specify this so we can have access to it immediately */
+    isNew) {
+        // If we have the handle cached, return it
+        if (this.#handleCache[documentId])
+            return this.#handleCache[documentId];
+        // If not, create a new handle, cache it, and return it
+        const handle = new DocHandle(documentId, { isNew });
+        this.#handleCache[documentId] = handle;
+        return handle;
+    }
+    /** Returns all the handles we have cached. */
+    get handles() {
+        return this.#handleCache;
+    }
+    /**
+     * Creates a new document and returns a handle to it. The initial value of the document is
+     * an empty object `{}`. Its documentId is generated by the system. we emit a `document` event
+     * to advertise interest in the document.
+     */
+    create() {
+        // TODO:
+        // either
+        // - pass an initial value and do something like this to ensure that you get a valid initial value
+        // const myInitialValue = {
+        //   tasks: [],
+        //   filter: "all",
+        //
+        // const guaranteeInitialValue = (doc: any) => {
+        // if (!doc.tasks) doc.tasks = []
+        // if (!doc.filter) doc.filter = "all"
+        //   return { ...myInitialValue, ...doc }
+        // }
+        // or
+        // - pass a "reify" function that takes a `<any>` and returns `<T>`
+        const documentId = uuid();
+        const handle = this.#getHandle(documentId, true);
+        this.emit("document", { handle });
+        return handle;
+    }
+    /**
+     * Retrieves a document by id. It gets data from the local system, but also emits a `document`
+     * event to advertise interest in the document.
+     */
+    find(
+    /** The documentId of the handle to retrieve */
+    documentId) {
+        // TODO: we want a way to make sure we don't yield intermediate document states during initial synchronization
+        // If we already have a handle, return it
+        if (this.#handleCache[documentId])
+            return this.#handleCache[documentId];
+        // Otherwise, create a new handle
+        const handle = this.#getHandle(documentId, false);
+        // we don't directly initialize a value here because the StorageSubsystem and Synchronizers go
+        // and get the data asynchronously and block on read instead of on create
+        // emit a document event to advertise interest in this document
+        this.emit("document", { handle });
+        return handle;
+    }
+    delete(
+    /** The documentId of the handle to delete */
+    documentId) {
+        const handle = this.#getHandle(documentId, false);
+        handle.delete();
+        delete this.#handleCache[documentId];
+        this.emit("delete-document", { documentId });
+    }
+}

package/dist/DocHandle.d.ts

@@ -0,0 +1,78 @@
+import * as A from "@automerge/automerge";
+import EventEmitter from "eventemitter3";
+import type { ChannelId, DocumentId, PeerId } from "./types.js";
+/** DocHandle is a wrapper around a single Automerge document that lets us listen for changes. */
+export declare class DocHandle<T>//
+ extends EventEmitter<DocHandleEvents<T>> {
+    #private;
+    documentId: DocumentId;
+    constructor(documentId: DocumentId, { isNew, timeoutDelay }?: DocHandleOptions);
+    get doc(): A.unstable.Doc<T>;
+    isReady: () => boolean;
+    isReadyOrRequesting: () => boolean;
+    isDeleted: () => boolean;
+    /**
+     * Returns the current document, waiting for the handle to be ready if necessary.
+     */
+    value(awaitStates?: HandleState[]): Promise<A.unstable.Doc<T>>;
+    loadAttemptedValue(): Promise<A.unstable.Doc<T>>;
+    /** `load` is called by the repo when the document is found in storage */
+    load(binary: Uint8Array): void;
+    /** `update` is called by the repo when we receive changes from the network */
+    update(callback: (doc: A.Doc<T>) => A.Doc<T>): void;
+    /** `change` is called by the repo when the document is changed locally  */
+    change(callback: A.ChangeFn<T>, options?: A.ChangeOptions<T>): void;
+    changeAt(heads: A.Heads, callback: A.ChangeFn<T>, options?: A.ChangeOptions<T>): void;
+    /** `request` is called by the repo when the document is not found in storage */
+    request(): void;
+    /** `delete` is called by the repo when the document is deleted */
+    delete(): void;
+}
+interface DocHandleOptions {
+    isNew?: boolean;
+    timeoutDelay?: number;
+}
+export interface DocHandleMessagePayload {
+    destinationId: PeerId;
+    channelId: ChannelId;
+    data: Uint8Array;
+}
+export interface DocHandleChangePayload<T> {
+    handle: DocHandle<T>;
+    doc: A.Doc<T>;
+}
+export interface DocHandleDeletePayload<T> {
+    handle: DocHandle<T>;
+}
+export interface DocHandlePatchPayload<T> {
+    handle: DocHandle<T>;
+    patches: A.Patch[];
+    before: A.Doc<T>;
+    after: A.Doc<T>;
+}
+export interface DocHandleEvents<T> {
+    change: (payload: DocHandleChangePayload<T>) => void;
+    patch: (payload: DocHandlePatchPayload<T>) => void;
+    delete: (payload: DocHandleDeletePayload<T>) => void;
+}
+export declare const HandleState: {
+    readonly IDLE: "idle";
+    readonly LOADING: "loading";
+    readonly REQUESTING: "requesting";
+    readonly READY: "ready";
+    readonly ERROR: "error";
+    readonly DELETED: "deleted";
+};
+export type HandleState = (typeof HandleState)[keyof typeof HandleState];
+export declare const Event: {
+    readonly CREATE: "CREATE";
+    readonly LOAD: "LOAD";
+    readonly FIND: "FIND";
+    readonly REQUEST: "REQUEST";
+    readonly REQUEST_COMPLETE: "REQUEST_COMPLETE";
+    readonly UPDATE: "UPDATE";
+    readonly TIMEOUT: "TIMEOUT";
+    readonly DELETE: "DELETE";
+};
+export {};
+//# sourceMappingURL=DocHandle.d.ts.map

package/dist/DocHandle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DocHandle.d.ts","sourceRoot":"","sources":["../src/DocHandle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,sBAAsB,CAAA;AAEzC,OAAO,YAAY,MAAM,eAAe,CAAA;AAgBxC,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAG/D,iGAAiG;AACjG,qBAAa,SAAS,CAAC,CAAC,CAAE,EAAE;AAC1B,SAAQ,YAAY,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;;IAQ/B,UAAU,EAAE,UAAU;gBAAtB,UAAU,EAAE,UAAU,EAC7B,EAAE,KAAa,EAAE,YAAqB,EAAE,GAAE,gBAAqB;IAkHjE,IAAI,GAAG,sBAQN;IAwBD,OAAO,gBAA8B;IACrC,mBAAmB,gBACkC;IACrD,SAAS,gBAAgC;IAEzC;;OAEG;IACG,KAAK,CAAC,WAAW,GAAE,WAAW,EAAY;IAc1C,kBAAkB;IAIxB,yEAAyE;IACzE,IAAI,CAAC,MAAM,EAAE,UAAU;IAMvB,8EAA8E;IAC9E,MAAM,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAI5C,2EAA2E;IAC3E,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,OAAO,GAAE,CAAC,CAAC,aAAa,CAAC,CAAC,CAAM;IAehE,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE,QAAQ,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,OAAO,GAAE,CAAC,CAAC,aAAa,CAAC,CAAC,CAAM;IAelF,gFAAgF;IAChF,OAAO;IAIP,kEAAkE;IAClE,MAAM;CAGP;AAID,UAAU,gBAAgB;IACxB,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,uBAAuB;IACtC,aAAa,EAAE,MAAM,CAAA;IACrB,SAAS,EAAE,SAAS,CAAA;IACpB,IAAI,EAAE,UAAU,CAAA;CACjB;AAED,MAAM,WAAW,sBAAsB,CAAC,CAAC;IACvC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,CAAA;IACpB,GAAG,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAA;CACd;AAED,MAAM,WAAW,sBAAsB,CAAC,CAAC;IACvC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,CAAA;CACrB;AAED,MAAM,WAAW,qBAAqB,CAAC,CAAC;IACtC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,CAAA;IACpB,OAAO,EAAE,CAAC,CAAC,KAAK,EAAE,CAAA;IAClB,MAAM,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAA;IAChB,KAAK,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAA;CAChB;AAED,MAAM,WAAW,eAAe,CAAC,CAAC;IAChC,MAAM,EAAE,CAAC,OAAO,EAAE,sBAAsB,CAAC,CAAC,CAAC,KAAK,IAAI,CAAA;IACpD,KAAK,EAAE,CAAC,OAAO,EAAE,qBAAqB,CAAC,CAAC,CAAC,KAAK,IAAI,CAAA;IAClD,MAAM,EAAE,CAAC,OAAO,EAAE,sBAAsB,CAAC,CAAC,CAAC,KAAK,IAAI,CAAA;CACrD;AAMD,eAAO,MAAM,WAAW;;;;;;;CAOd,CAAA;AACV,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,OAAO,WAAW,CAAC,CAAA;AAkBxE,eAAO,MAAM,KAAK;;;;;;;;;CASR,CAAA"}