@opendaw/studio-core 0.0.39 → 0.0.41

package/dist/yjs/YMapper.d.ts

@@ -0,0 +1,9 @@
+import { Address, Box } from "@opendaw/lib-box";
+import * as Y from "yjs";
+export declare namespace YMapper {
+    const createBoxMap: (box: Box) => Y.Map<unknown>;
+    const applyFromBoxMap: (box: Box, source: Y.Map<unknown>) => void;
+    const pathToAddress: ([uuidAsString, _, ...fieldKeysFromPath]: ReadonlyArray<string | number>, leafKey: string) => Address;
+    const findMap: (map: Y.Map<unknown>, fieldKeys: ReadonlyArray<string | number>) => Y.Map<unknown>;
+}
+//# sourceMappingURL=YMapper.d.ts.map

package/dist/yjs/YMapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"YMapper.d.ts","sourceRoot":"","sources":["../../src/yjs/YMapper.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,OAAO,EAEP,GAAG,EAON,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAGxB,yBAAiB,OAAO,CAAC;IACd,MAAM,YAAY,GAAI,KAAK,GAAG,KAAG,CAAC,CAAC,GAAG,CAAC,OAAO,CAKpD,CAAA;IAEM,MAAM,eAAe,GAAI,KAAK,GAAG,EAAE,QAAQ,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,KAAG,IAgBlE,CAAA;IAEM,MAAM,aAAa,GAAI,yCAAyC,aAAa,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,SAAS,MAAM,KAAG,OAMxH,CAAA;IAEM,MAAM,OAAO,GAAI,KAAK,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,WAAW,aAAa,CAAC,MAAM,GAAG,MAAM,CAAC,KAAG,CAAC,CAAC,GAAG,CAAC,OAAO,CACS,CAAA;CAYlH"}

package/dist/yjs/YMapper.js

@@ -0,0 +1,45 @@
+import { Address } from "@opendaw/lib-box";
+import * as Y from "yjs";
+import { asDefined, asInstanceOf, assert, isDefined, UUID } from "@opendaw/lib-std";
+export var YMapper;
+(function (YMapper) {
+    YMapper.createBoxMap = (box) => {
+        const map = new Y.Map();
+        map.set("name", box.name);
+        map.set("fields", createDeepMap(box.record()));
+        return map;
+    };
+    YMapper.applyFromBoxMap = (box, source) => {
+        const writeBranch = (vertex, map) => {
+            vertex.fields().forEach(field => {
+                const value = map.get(String(field.fieldKey));
+                field.accept({
+                    visitArrayField: (field) => writeBranch(field, asInstanceOf(value, Y.Map)),
+                    visitObjectField: (field) => writeBranch(field, asInstanceOf(value, Y.Map)),
+                    // those will panic if the type is a mismatch
+                    visitPointerField: (field) => field.fromJSON(value),
+                    visitPrimitiveField: (field) => field.fromJSON(value)
+                });
+            });
+        };
+        writeBranch(box, source);
+    };
+    YMapper.pathToAddress = ([uuidAsString, _, ...fieldKeysFromPath], leafKey) => {
+        assert(isDefined(uuidAsString), "Invalid path");
+        const fieldKeys = new Int16Array(fieldKeysFromPath.length + 1);
+        fieldKeysFromPath.forEach((key, index) => fieldKeys[index] = Number(key));
+        fieldKeys[fieldKeysFromPath.length] = Number(leafKey);
+        return new Address(UUID.parse(String(uuidAsString)), fieldKeys);
+    };
+    YMapper.findMap = (map, fieldKeys) => fieldKeys.reduce((map, key) => asDefined(map.get(String(key)), "Could not findMap"), map);
+    const createDeepMap = (struct) => Object.entries(struct)
+        .reduce((map, [key, field]) => {
+        field.accept({
+            visitPrimitiveField: (field) => map.set(key, field.toJSON() ?? null),
+            visitPointerField: (field) => map.set(key, field.toJSON() ?? null),
+            visitArrayField: (field) => map.set(key, createDeepMap(field.record())),
+            visitObjectField: (field) => map.set(key, createDeepMap(field.record()))
+        });
+        return map;
+    }, new Y.Map());
+})(YMapper || (YMapper = {}));

package/dist/yjs/YService.d.ts

@@ -0,0 +1,7 @@
+import { Option } from "@opendaw/lib-std";
+import { ProjectEnv } from "../project/ProjectEnv";
+import { Project } from "../project/Project";
+export declare namespace YService {
+    const getOrCreateRoom: (optProject: Option<Project>, env: ProjectEnv, roomName: string) => Promise<Project>;
+}
+//# sourceMappingURL=YService.d.ts.map

package/dist/yjs/YService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"YService.d.ts","sourceRoot":"","sources":["../../src/yjs/YService.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,MAAM,EAAmC,MAAM,kBAAkB,CAAA;AAQjF,OAAO,EAAC,UAAU,EAAC,MAAM,uBAAuB,CAAA;AAChD,OAAO,EAAC,OAAO,EAAC,MAAM,oBAAoB,CAAA;AAI1C,yBAAiB,QAAQ,CAAC;IAKf,MAAM,eAAe,GAAU,YAAY,MAAM,CAAC,OAAO,CAAC,EAC3B,KAAK,UAAU,EACf,UAAU,MAAM,KAAG,OAAO,CAAC,OAAO,CAiDvE,CAAA;CACJ"}

package/dist/yjs/YService.js

@@ -0,0 +1,69 @@
+import { Errors, Option, panic, RuntimeNotifier, TimeSpan } from "@opendaw/lib-std";
+import { BoxGraph } from "@opendaw/lib-box";
+import { Promises } from "@opendaw/lib-runtime";
+import { BoxIO } from "@opendaw/studio-boxes";
+import { ProjectDecoder } from "@opendaw/studio-adapters";
+import { YSync } from "./YSync";
+import * as Y from "yjs";
+import { WebsocketProvider } from "y-websocket";
+import { Project } from "../project/Project";
+// https://inspector.yjs.dev/
+export var YService;
+(function (YService) {
+    const { VITE_VJS_USE_LOCAL_SERVER, VITE_VJS_LOCAL_SERVER_URL, VITE_VJS_ONLINE_SERVER_URL } = import.meta.env;
+    const isDev = VITE_VJS_USE_LOCAL_SERVER === "true";
+    const serverUrl = isDev ? VITE_VJS_LOCAL_SERVER_URL : VITE_VJS_ONLINE_SERVER_URL;
+    YService.getOrCreateRoom = async (optProject, env, roomName) => {
+        if (roomName === "signaling") {
+            return panic("Invalid room name: signaling");
+        }
+        const doc = new Y.Doc();
+        const provider = new WebsocketProvider(serverUrl, roomName, doc);
+        console.debug("clientID:", doc.clientID);
+        console.debug("Provider url:", provider.url);
+        if (!provider.synced) {
+            const { resolve, promise } = Promise.withResolvers();
+            const onSync = (isSynced) => {
+                if (isSynced) {
+                    provider.off("sync", onSync);
+                    resolve();
+                }
+            };
+            provider.on("sync", onSync);
+            await Promises.timeout(promise, TimeSpan.seconds(10), "Timeout 'synced'");
+        }
+        const boxesMap = doc.getMap("boxes");
+        if (boxesMap.size === 0) {
+            const project = optProject.match({
+                none: () => Project.new(env),
+                some: project => project.copy()
+            });
+            const sync = await YSync.populate({ boxGraph: project.boxGraph, doc, conflict: () => project.invalid() });
+            project.own(sync);
+            project.editing.disable();
+            return project;
+        }
+        else {
+            if (optProject.nonEmpty()) {
+                const approved = await RuntimeNotifier.approve({
+                    headline: "Room Already Exists",
+                    message: "Do you want to join it?",
+                    approveText: "Join",
+                    cancelText: "Cancel"
+                });
+                if (!approved) {
+                    return Promise.reject(Errors.AbortError);
+                }
+            }
+            const boxGraph = new BoxGraph(Option.wrap(BoxIO.create));
+            const sync = await YSync.join({ boxGraph, doc, conflict: () => project.invalid() });
+            const project = Project.skeleton(env, {
+                boxGraph,
+                mandatoryBoxes: ProjectDecoder.findMandatoryBoxes(boxGraph)
+            });
+            project.own(sync);
+            project.editing.disable();
+            return project;
+        }
+    };
+})(YService || (YService = {}));

package/dist/yjs/YSync.d.ts

@@ -0,0 +1,17 @@
+import { Provider, Terminable } from "@opendaw/lib-std";
+import { BoxGraph } from "@opendaw/lib-box";
+import * as Y from "yjs";
+export type Construct<T> = {
+    boxGraph: BoxGraph<T>;
+    doc: Y.Doc;
+    conflict?: Provider<boolean>;
+};
+export declare class YSync<T> implements Terminable {
+    #private;
+    static isEmpty(doc: Y.Doc): boolean;
+    static populate<T>({ boxGraph, doc }: Construct<T>): Promise<YSync<T>>;
+    static join<T>({ boxGraph, doc }: Construct<T>): Promise<YSync<T>>;
+    constructor({ boxGraph, doc, conflict }: Construct<T>);
+    terminate(): void;
+}
+//# sourceMappingURL=YSync.d.ts.map

package/dist/yjs/YSync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"YSync.d.ts","sourceRoot":"","sources":["../../src/yjs/YSync.ts"],"names":[],"mappings":"AAAA,OAAO,EASH,QAAQ,EAER,UAAU,EAGb,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAa,QAAQ,EAA2D,MAAM,kBAAkB,CAAA;AAE/G,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAIxB,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI;IACvB,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC;IACtB,GAAG,EAAE,CAAC,CAAC,GAAG,CAAA;IACV,QAAQ,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAA;CAC/B,CAAA;AAED,qBAAa,KAAK,CAAC,CAAC,CAAE,YAAW,UAAU;;IACvC,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC,GAAG,GAAG,OAAO;WAItB,QAAQ,CAAC,CAAC,EAAE,EAAC,QAAQ,EAAE,GAAG,EAAC,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;WAa7D,IAAI,CAAC,CAAC,EAAE,EAAC,QAAQ,EAAE,GAAG,EAAC,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;gBA4B1D,EAAC,QAAQ,EAAE,GAAG,EAAE,QAAQ,EAAC,EAAE,SAAS,CAAC,CAAC,CAAC;IASnD,SAAS,IAAI,IAAI;CAkJpB"}

package/dist/yjs/YSync.js

@@ -0,0 +1,195 @@
+import { asDefined, assert, EmptyExec, isInstanceOf, isUndefined, Option, panic, Terminable, Terminator, UUID } from "@opendaw/lib-std";
+import { YMapper } from "./YMapper";
+import * as Y from "yjs";
+export class YSync {
+    static isEmpty(doc) {
+        return doc.getMap("boxes").size === 0;
+    }
+    static async populate({ boxGraph, doc }) {
+        console.debug("populate");
+        const boxesMap = doc.getMap("boxes");
+        assert(boxesMap.size === 0, "BoxesMap must be empty");
+        const sync = new YSync({ boxGraph, doc });
+        doc.transact(() => boxGraph.boxes().forEach(box => {
+            const key = UUID.toString(box.address.uuid);
+            const map = YMapper.createBoxMap(box);
+            boxesMap.set(key, map);
+        }), "populate");
+        return sync;
+    }
+    static async join({ boxGraph, doc }) {
+        console.debug("join");
+        assert(boxGraph.boxes().length === 0, "BoxGraph must be empty");
+        const sync = new YSync({ boxGraph, doc });
+        boxGraph.beginTransaction();
+        const boxesMap = doc.getMap("boxes");
+        boxesMap.forEach((value, key) => {
+            const boxMap = value;
+            const uuid = UUID.parse(key);
+            const name = boxMap.get("name");
+            const fields = boxMap.get("fields");
+            boxGraph.createBox(name, uuid, box => YMapper.applyFromBoxMap(box, fields));
+        });
+        boxGraph.endTransaction();
+        boxGraph.verifyPointers();
+        return sync;
+    }
+    #terminator = new Terminator();
+    #boxGraph;
+    #doc;
+    #conflict;
+    #boxesMap;
+    #updates;
+    #ignoreUpdates = false;
+    constructor({ boxGraph, doc, conflict }) {
+        this.#boxGraph = boxGraph;
+        this.#doc = doc;
+        this.#conflict = Option.wrap(conflict);
+        this.#boxesMap = doc.getMap("boxes");
+        this.#updates = [];
+        this.#terminator.ownAll(this.#setupYjs(), this.#setupOpenDAW());
+    }
+    terminate() { this.#terminator.terminate(); }
+    #setupYjs() {
+        const eventHandler = (events, transaction) => {
+            console.debug("got updates", transaction.origin);
+            if (transaction.local) {
+                console.debug("Skip local update");
+                return;
+            }
+            this.#boxGraph.beginTransaction();
+            events.forEach(event => {
+                const path = event.path;
+                const keys = event.changes.keys;
+                keys.entries().forEach(([key, change]) => {
+                    if (change.action === "add") {
+                        assert(path.length === 0, "'Add' cannot have a path");
+                        const map = this.#boxesMap.get(key);
+                        const name = map.get("name");
+                        const fields = map.get("fields");
+                        const uuid = UUID.parse(key);
+                        this.#boxGraph.createBox(name, uuid, box => YMapper.applyFromBoxMap(box, fields));
+                    }
+                    else if (change.action === "update") {
+                        if (path.length === 0) {
+                            return;
+                        }
+                        assert(path.length >= 2, "Invalid path: must have at least 2 elements (uuid, 'fields').");
+                        this.#updateValue(path, key);
+                    }
+                    else if (change.action === "delete") {
+                        assert(path.length === 0, "'Delete' cannot have a path");
+                        const box = this.#boxGraph.findBox(UUID.parse(key))
+                            .unwrap("Could not find box to delete");
+                        // It is possible that Yjs have swallowed the pointer updates since were are 'inside' the box.
+                        box.outgoingEdges().forEach(([pointer]) => pointer.defer());
+                        box.incomingEdges().forEach(pointer => pointer.defer());
+                        this.#boxGraph.unstageBox(box);
+                    }
+                });
+            });
+            this.#ignoreUpdates = true;
+            this.#boxGraph.endTransaction();
+            this.#boxGraph.verifyPointers();
+            this.#ignoreUpdates = false;
+            const highLevelConflict = this.#conflict.mapOr(check => check(), false);
+            if (highLevelConflict) {
+                this.#rollbackTransaction(events);
+            }
+        };
+        this.#boxesMap.observeDeep(eventHandler);
+        return { terminate: () => { this.#boxesMap.unobserveDeep(eventHandler); } };
+    }
+    #updateValue(path, key) {
+        const [uuidAsString, fieldsKey, ...fieldKeys] = path;
+        const targetMap = YMapper.findMap(this.#boxesMap
+            .get(String(uuidAsString))
+            .get(String(fieldsKey)), fieldKeys);
+        const vertexOption = this.#boxGraph.findVertex(YMapper.pathToAddress(path, key));
+        const vertex = vertexOption.unwrap("Could not find field");
+        assert(vertex.isField(), "Vertex must be either Primitive or Pointer");
+        vertex.accept({
+            visitField: (_) => panic("Vertex must be either Primitive or Pointer"),
+            visitArrayField: (_) => panic("Vertex must be either Primitive or Pointer"),
+            visitObjectField: (_) => panic("Vertex must be either Primitive or Pointer"),
+            visitPointerField: (field) => field.fromJSON(targetMap.get(key)),
+            visitPrimitiveField: (field) => field.fromJSON(targetMap.get(key))
+        });
+    }
+    #rollbackTransaction(events) {
+        console.debug("rollbackTransaction", events.length);
+        for (let i = events.length - 1; i >= 0; i--) {
+            const event = events[i];
+            const target = event.target;
+            if (!isInstanceOf(target, Y.Map)) {
+                return panic("Only Y.Map events are supported");
+            }
+            Array.from(event.changes.keys.entries())
+                .reverse()
+                .forEach(([key, change]) => {
+                if (change.action === "add") {
+                    target.delete(key);
+                }
+                else if (change.action === "update") {
+                    if (isUndefined(change.oldValue)) {
+                        target.delete(key);
+                    }
+                    else {
+                        target.set(key, change.oldValue);
+                    }
+                }
+                else if (change.action === "delete") {
+                    target.set(key, change.oldValue);
+                }
+            });
+        }
+    }
+    #setupOpenDAW() {
+        return Terminable.many(this.#boxGraph.subscribeTransaction({
+            onBeginTransaction: EmptyExec,
+            onEndTransaction: () => {
+                if (this.#ignoreUpdates) {
+                    this.#updates.length = 0;
+                    return;
+                }
+                this.#doc.transact(() => this.#updates.forEach(update => {
+                    /**
+                     * TRANSFER CHANGES FROM OPENDAW TO LIVEBLOCKS
+                     */
+                    if (update.type === "new") {
+                        const uuid = update.uuid;
+                        const key = UUID.toString(uuid);
+                        const box = this.#boxGraph.findBox(uuid).unwrap();
+                        this.#boxesMap.set(key, YMapper.createBoxMap(box));
+                    }
+                    else if (update.type === "primitive") {
+                        const key = UUID.toString(update.address.uuid);
+                        const boxObject = asDefined(this.#boxesMap.get(key), "Could not find box");
+                        const { address: { fieldKeys }, newValue } = update;
+                        let field = boxObject.get("fields");
+                        for (let i = 0; i < fieldKeys.length - 1; i++) {
+                            field = asDefined(field.get(String(fieldKeys[i])), `No field at '${fieldKeys[i]}'`);
+                        }
+                        field.set(String(fieldKeys[fieldKeys.length - 1]), newValue);
+                    }
+                    else if (update.type === "pointer") {
+                        const key = UUID.toString(update.address.uuid);
+                        const boxObject = asDefined(this.#boxesMap.get(key), "Could not find box");
+                        const { address: { fieldKeys }, newAddress } = update;
+                        let field = boxObject.get("fields");
+                        for (let i = 0; i < fieldKeys.length - 1; i++) {
+                            field = asDefined(field.get(String(fieldKeys[i])), `No field at '${fieldKeys[i]}'`);
+                        }
+                        field.set(String(fieldKeys[fieldKeys.length - 1]), newAddress.mapOr(address => address.toString(), null));
+                    }
+                    else if (update.type === "delete") {
+                        this.#boxesMap.delete(UUID.toString(update.uuid));
+                    }
+                }), "openDAW");
+                this.#updates.length = 0;
+            }
+        }), this.#boxGraph.subscribeToAllUpdatesImmediate({
+            onUpdate: (update) => this.#updates.push(update)
+        }));
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opendaw/studio-core",
-  "version": "0.0.39",
+  "version": "0.0.41",
   "license": "LGPL-3.0-or-later",
   "publishConfig": {
     "access": "public"
@@ -28,26 +28,26 @@
   "dependencies": {
     "@liveblocks/client": "^3.7.1",
     "@liveblocks/yjs": "^3.7.1",
-    "@opendaw/lib-box": "^0.0.30",
-    "@opendaw/lib-dawproject": "^0.0.16",
-    "@opendaw/lib-dom": "^0.0.30",
-    "@opendaw/lib-dsp": "^0.0.30",
-    "@opendaw/lib-fusion": "^0.0.30",
-    "@opendaw/lib-runtime": "^0.0.30",
-    "@opendaw/lib-std": "^0.0.30",
-    "@opendaw/studio-adapters": "^0.0.31",
-    "@opendaw/studio-boxes": "^0.0.30",
-    "@opendaw/studio-enums": "^0.0.21",
+    "@opendaw/lib-box": "^0.0.32",
+    "@opendaw/lib-dawproject": "^0.0.18",
+    "@opendaw/lib-dom": "^0.0.32",
+    "@opendaw/lib-dsp": "^0.0.32",
+    "@opendaw/lib-fusion": "^0.0.32",
+    "@opendaw/lib-runtime": "^0.0.32",
+    "@opendaw/lib-std": "^0.0.32",
+    "@opendaw/studio-adapters": "^0.0.33",
+    "@opendaw/studio-boxes": "^0.0.32",
+    "@opendaw/studio-enums": "^0.0.23",
     "dropbox": "^10.34.0",
-    "y-webrtc": "^10.3.0",
+    "y-websocket": "^1.4.5",
     "yjs": "^13.6.27"
   },
   "devDependencies": {
     "@opendaw/eslint-config": "^0.0.19",
-    "@opendaw/studio-core-processors": "^0.0.31",
-    "@opendaw/studio-core-workers": "^0.0.26",
-    "@opendaw/studio-forge-boxes": "^0.0.30",
+    "@opendaw/studio-core-processors": "^0.0.33",
+    "@opendaw/studio-core-workers": "^0.0.28",
+    "@opendaw/studio-forge-boxes": "^0.0.32",
     "@opendaw/typescript-config": "^0.0.20"
   },
-  "gitHead": "2fff74bbce57bd2c3c634b1cb735cccdaff2ab15"
+  "gitHead": "705da8c69733c18fbae25c63f87cba8a367b8b38"
 }

package/dist/samples/P2PSampleProvider.d.ts

@@ -1,13 +0,0 @@
-import { Progress, UUID } from "@opendaw/lib-std";
-import { AudioData, SampleMetaData } from "@opendaw/studio-adapters";
-import * as Y from "yjs";
-import { WebrtcProvider } from "y-webrtc";
-import { SampleProvider } from "./SampleProvider";
-export declare class P2PSampleProvider implements SampleProvider {
-    #private;
-    static create(doc: Y.Doc, provider: WebrtcProvider): P2PSampleProvider;
-    constructor(doc: Y.Doc, provider: WebrtcProvider);
-    fetch(uuid: UUID.Bytes, progress: Progress.Handler): Promise<[AudioData, SampleMetaData]>;
-    share(uuidAsString: string, audioData: AudioData, peaks: ArrayBuffer, metadata: SampleMetaData): Promise<void>;
-}
-//# sourceMappingURL=P2PSampleProvider.d.ts.map

package/dist/samples/P2PSampleProvider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"P2PSampleProvider.d.ts","sourceRoot":"","sources":["../../src/samples/P2PSampleProvider.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8C,QAAQ,EAAE,IAAI,EAAC,MAAM,kBAAkB,CAAA;AAC5F,OAAO,EAAC,SAAS,EAAE,cAAc,EAAC,MAAM,0BAA0B,CAAA;AAClE,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAC,cAAc,EAAC,MAAM,UAAU,CAAA;AACvC,OAAO,EAAC,cAAc,EAAC,MAAM,kBAAkB,CAAA;AAkC/C,qBAAa,iBAAkB,YAAW,cAAc;;IACpD,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,GAAG,EAAE,QAAQ,EAAE,cAAc,GAAG,iBAAiB;gBAc1D,GAAG,EAAE,CAAC,CAAC,GAAG,EAAE,QAAQ,EAAE,cAAc;IAY1C,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,EAAE,QAAQ,EAAE,QAAQ,CAAC,OAAO,GAAG,OAAO,CAAC,CAAC,SAAS,EAAE,cAAc,CAAC,CAAC;IAmDzF,KAAK,CAAC,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;CAkSvH"}