mobx-keystone-loro 1.0.0

package/dist/mobx-keystone-loro.esm.mjs

@@ -0,0 +1,957 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { LoroMap, LoroMovableList, LoroText, isContainer } from "loro-crdt";
+import { createAtom, computed, remove, action } from "mobx";
+import { createContext, types, getSnapshotModelType, Model, tProp, frozen, getParentToChildPath, modelAction, model, modelSnapshotOutWithMetadata, toFrozenSnapshot, resolvePath, runUnprotected, isModel, isDataModel, modelIdKey, isFrozenSnapshot, getSnapshotModelId, fromSnapshot, frozenKey, DeepChangeType, onGlobalDeepChange, getSnapshot, onDeepChange, onSnapshot, isTreeNode } from "mobx-keystone";
+let nanoid = (size = 21) => crypto.getRandomValues(new Uint8Array(size)).reduce((id, byte) => {
+  byte &= 63;
+  if (byte < 36) {
+    id += byte.toString(36);
+  } else if (byte < 62) {
+    id += (byte - 26).toString(36).toUpperCase();
+  } else if (byte > 62) {
+    id += "-";
+  } else {
+    id += "_";
+  }
+  return id;
+}, "");
+const atomMap = /* @__PURE__ */ new WeakMap();
+function getOrCreateLoroCollectionAtom(collection) {
+  let atom = atomMap.get(collection);
+  if (!atom) {
+    atom = createAtom(`loroCollectionAtom`);
+    atomMap.set(collection, atom);
+  }
+  return atom;
+}
+class MobxKeystoneLoroError extends Error {
+  constructor(msg) {
+    super(msg);
+    Object.setPrototypeOf(this, MobxKeystoneLoroError.prototype);
+  }
+}
+function failure(message) {
+  throw new MobxKeystoneLoroError(message);
+}
+const loroBindingContext = createContext(void 0);
+function resolveLoroPath(loroObject, path) {
+  let currentLoroObject = loroObject;
+  path.forEach((pathPart, i) => {
+    if (currentLoroObject instanceof LoroMap) {
+      getOrCreateLoroCollectionAtom(currentLoroObject).reportObserved();
+      const key = String(pathPart);
+      currentLoroObject = currentLoroObject.get(key);
+    } else if (currentLoroObject instanceof LoroMovableList) {
+      getOrCreateLoroCollectionAtom(currentLoroObject).reportObserved();
+      const key = Number(pathPart);
+      currentLoroObject = currentLoroObject.get(key);
+    } else {
+      throw failure(
+        `LoroMap or LoroMovableList was expected at path ${JSON.stringify(
+          path.slice(0, i)
+        )} in order to resolve path ${JSON.stringify(path)}, but got ${currentLoroObject} instead`
+      );
+    }
+  });
+  return currentLoroObject;
+}
+var __defProp2 = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp2(target, key, result);
+  return result;
+};
+const loroTextModelId = "mobx-keystone-loro/LoroTextModel";
+let LoroTextModel = class extends Model({
+  /**
+   * The current delta representing the rich text content.
+   * Uses Quill delta format.
+   */
+  deltaList: tProp(types.frozen(types.unchecked()), () => frozen([]))
+}) {
+  constructor() {
+    super(...arguments);
+    /**
+     * Atom that gets changed when the associated Loro text changes.
+     */
+    __publicField(this, "loroTextChangedAtom", createAtom("loroTextChangedAtom"));
+  }
+  /**
+   * Creates a LoroTextModel with initial text content.
+   */
+  static withText(text) {
+    return new LoroTextModel({
+      deltaList: frozen([{ insert: text }])
+    });
+  }
+  /**
+   * Creates a LoroTextModel with initial delta.
+   */
+  static withDelta(delta) {
+    return new LoroTextModel({
+      deltaList: frozen(delta)
+    });
+  }
+  get loroText() {
+    const ctx = loroBindingContext.get(this);
+    if ((ctx == null ? void 0 : ctx.boundObject) == null) {
+      return void 0;
+    }
+    try {
+      const path = getParentToChildPath(ctx.boundObject, this);
+      if (!path) {
+        return void 0;
+      }
+      if (path.length === 0) {
+        const loroObject2 = ctx.loroObject;
+        if (loroObject2 instanceof LoroText) {
+          getOrCreateLoroCollectionAtom(loroObject2).reportObserved();
+          return loroObject2;
+        }
+        return void 0;
+      }
+      const loroObject = resolveLoroPath(ctx.loroObject, path);
+      if (loroObject instanceof LoroText) {
+        getOrCreateLoroCollectionAtom(loroObject).reportObserved();
+        return loroObject;
+      }
+    } catch {
+    }
+    return void 0;
+  }
+  get text() {
+    this.loroTextChangedAtom.reportObserved();
+    return this.deltaToText(this.deltaList.data);
+  }
+  get currentDelta() {
+    this.loroTextChangedAtom.reportObserved();
+    const loroText = this.loroText;
+    if (loroText) {
+      try {
+        return loroText.toDelta();
+      } catch {
+      }
+    }
+    return this.deltaList.data;
+  }
+  /**
+   * Converts delta to plain text.
+   */
+  deltaToText(delta) {
+    let result = "";
+    for (const op of delta) {
+      if ("insert" in op && typeof op.insert === "string") {
+        result += op.insert;
+      }
+    }
+    return result;
+  }
+  setDelta(delta) {
+    this.deltaList = frozen(delta);
+  }
+  insertText(index, text) {
+    const loroText = this.loroText;
+    if (loroText) {
+      loroText.insert(index, text);
+    } else {
+      const currentText = this.text;
+      const newText = currentText.slice(0, index) + text + currentText.slice(index);
+      this.deltaList = frozen([{ insert: newText }]);
+    }
+  }
+  deleteText(index, length) {
+    const loroText = this.loroText;
+    if (loroText) {
+      loroText.delete(index, length);
+    } else {
+      const currentText = this.text;
+      const newText = currentText.slice(0, index) + currentText.slice(index + length);
+      this.deltaList = frozen([{ insert: newText }]);
+    }
+  }
+  _updateDeltaFromLoro(delta) {
+    this.deltaList = frozen(delta);
+  }
+};
+__decorateClass([
+  computed
+], LoroTextModel.prototype, "loroText", 1);
+__decorateClass([
+  computed
+], LoroTextModel.prototype, "text", 1);
+__decorateClass([
+  computed
+], LoroTextModel.prototype, "currentDelta", 1);
+__decorateClass([
+  modelAction
+], LoroTextModel.prototype, "setDelta", 1);
+__decorateClass([
+  modelAction
+], LoroTextModel.prototype, "insertText", 1);
+__decorateClass([
+  modelAction
+], LoroTextModel.prototype, "deleteText", 1);
+__decorateClass([
+  modelAction
+], LoroTextModel.prototype, "_updateDeltaFromLoro", 1);
+LoroTextModel = __decorateClass([
+  model(loroTextModelId)
+], LoroTextModel);
+const loroTextModelType = types.model(LoroTextModel);
+function isLoroTextModelSnapshot(value) {
+  return getSnapshotModelType(value) === loroTextModelId;
+}
+function convertLoroDataToJson(value) {
+  if (value === null) {
+    return null;
+  }
+  if (typeof value !== "object") {
+    if (value === void 0) {
+      throw new Error("undefined values are not supported by Loro");
+    }
+    return value;
+  }
+  if (isContainer(value)) {
+    if (value instanceof LoroMap) {
+      const result2 = {};
+      for (const [k, v] of value.entries()) {
+        result2[k] = convertLoroDataToJson(v);
+      }
+      return result2;
+    }
+    if (value instanceof LoroMovableList) {
+      const result2 = [];
+      for (let i = 0; i < value.length; i++) {
+        result2.push(convertLoroDataToJson(value.get(i)));
+      }
+      return result2;
+    }
+    if (value instanceof LoroText) {
+      const deltas = value.toDelta();
+      return modelSnapshotOutWithMetadata(LoroTextModel, {
+        deltaList: toFrozenSnapshot(deltas)
+      });
+    }
+    throw failure(`unsupported bindable Loro container type`);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => convertLoroDataToJson(item));
+  }
+  const result = {};
+  for (const [k, v] of Object.entries(value)) {
+    result[k] = convertLoroDataToJson(v);
+  }
+  return result;
+}
+function applyLoroEventToMobx(event, loroDoc, boundObject, rootPath, reconciliationMap, newlyInsertedContainers) {
+  if (newlyInsertedContainers.has(event.target)) {
+    return;
+  }
+  const eventPath = loroDoc.getPathToContainer(event.target);
+  if (!eventPath) {
+    return;
+  }
+  const relativePath = resolveEventPath(eventPath, rootPath);
+  if (relativePath === void 0) {
+    return;
+  }
+  const { value: target } = resolvePath(boundObject, relativePath);
+  if (!target) {
+    throw failure(`cannot resolve path ${JSON.stringify(relativePath)}`);
+  }
+  runUnprotected(() => {
+    const diff = event.diff;
+    if (diff.type === "map") {
+      applyMapEventToMobx(diff, loroDoc, event.target, target, reconciliationMap);
+    } else if (diff.type === "list") {
+      applyListEventToMobx(
+        diff,
+        loroDoc,
+        event.target,
+        target,
+        reconciliationMap,
+        newlyInsertedContainers
+      );
+    } else if (diff.type === "text") {
+      applyTextEventToMobx(loroDoc, event.target, target);
+    }
+  });
+}
+function processDeletedValue(val, reconciliationMap) {
+  if (isModel(val) || isDataModel(val)) {
+    const id = modelIdKey in val ? val[modelIdKey] : void 0;
+    if (id) {
+      reconciliationMap.set(id, val);
+    }
+  }
+}
+function reviveValue(jsonValue, reconciliationMap) {
+  if (jsonValue === null || typeof jsonValue !== "object") {
+    return jsonValue;
+  }
+  if (isFrozenSnapshot(jsonValue)) {
+    return frozen(jsonValue.data);
+  }
+  if (reconciliationMap) {
+    const modelId = getSnapshotModelId(jsonValue);
+    if (modelId) {
+      const existing = reconciliationMap.get(modelId);
+      if (existing) {
+        reconciliationMap.delete(modelId);
+        return existing;
+      }
+    }
+  }
+  return fromSnapshot(jsonValue);
+}
+function applyMapEventToMobx(diff, loroDoc, containerTarget, target, reconciliationMap) {
+  const container = loroDoc.getContainerById(containerTarget);
+  if (!container || !(container instanceof LoroMap)) {
+    throw failure(`${containerTarget} was not a Loro map`);
+  }
+  for (const key of Object.keys(diff.updated)) {
+    const loroValue = container.get(key);
+    if (loroValue === void 0) {
+      if (key in target) {
+        processDeletedValue(target[key], reconciliationMap);
+        if (isModel(target)) {
+          remove(target.$, key);
+        } else {
+          remove(target, key);
+        }
+      }
+    } else {
+      if (key in target) {
+        processDeletedValue(target[key], reconciliationMap);
+      }
+      const jsonValue = convertLoroDataToJson(loroValue);
+      target[key] = reviveValue(jsonValue, reconciliationMap);
+    }
+  }
+}
+function applyListEventToMobx(diff, loroDoc, containerTarget, target, reconciliationMap, newlyInsertedContainers) {
+  const container = loroDoc.getContainerById(containerTarget);
+  if (!container || !(container instanceof LoroMovableList)) {
+    throw failure(`${containerTarget} was not a Loro movable list`);
+  }
+  let currentIndex = 0;
+  for (const change of diff.diff) {
+    if (change.retain) {
+      currentIndex += change.retain;
+    }
+    if (change.delete) {
+      const deletedItems = target.slice(currentIndex, currentIndex + change.delete);
+      deletedItems.forEach((item) => {
+        processDeletedValue(item, reconciliationMap);
+      });
+      target.splice(currentIndex, change.delete);
+    }
+    if (change.insert) {
+      const insertedItems = change.insert;
+      const values = insertedItems.map((loroValue) => {
+        if (isContainer(loroValue)) {
+          newlyInsertedContainers.add(loroValue.id);
+          collectNestedContainerIds(loroValue, newlyInsertedContainers);
+        }
+        const jsonValue = convertLoroDataToJson(loroValue);
+        return reviveValue(jsonValue, reconciliationMap);
+      });
+      target.splice(currentIndex, 0, ...values);
+      currentIndex += values.length;
+    }
+  }
+}
+function applyTextEventToMobx(loroDoc, containerTarget, target) {
+  const container = loroDoc.getContainerById(containerTarget);
+  if (!container || !(container instanceof LoroText)) {
+    throw failure(`${containerTarget} was not a Loro text container`);
+  }
+  if (!("deltaList" in target)) {
+    throw failure("target does not have a deltaList property - expected LoroTextModel");
+  }
+  target.deltaList = frozen(container.toDelta());
+}
+function collectNestedContainerIds(container, containerIds) {
+  if (!isContainer(container)) {
+    return;
+  }
+  containerIds.add(container.id);
+  if (container instanceof LoroMap) {
+    for (const key of Object.keys(container.toJSON())) {
+      const value = container.get(key);
+      collectNestedContainerIds(value, containerIds);
+    }
+  }
+  if (container instanceof LoroMovableList) {
+    for (let i = 0; i < container.length; i++) {
+      collectNestedContainerIds(container.get(i), containerIds);
+    }
+  }
+}
+function resolveEventPath(eventPath, rootPath) {
+  if (eventPath.length < rootPath.length) {
+    return void 0;
+  }
+  for (let i = 0; i < rootPath.length; i++) {
+    if (eventPath[i] !== rootPath[i]) {
+      return void 0;
+    }
+  }
+  return eventPath.slice(rootPath.length);
+}
+function isBindableLoroContainer(value) {
+  return value instanceof LoroMap || value instanceof LoroMovableList || value instanceof LoroText;
+}
+const loroContainerToSnapshot = /* @__PURE__ */ new WeakMap();
+function setLoroContainerSnapshot(container, snapshot) {
+  loroContainerToSnapshot.set(container, snapshot);
+}
+function isLoroContainerUpToDate(container, snapshot) {
+  return loroContainerToSnapshot.get(container) === snapshot;
+}
+function isPlainPrimitive(v) {
+  const t = typeof v;
+  return t === "string" || t === "number" || t === "boolean" || v === null || v === void 0;
+}
+function isPlainArray(v) {
+  return Array.isArray(v);
+}
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function extractTextDeltaFromSnapshot(delta) {
+  if (isFrozenSnapshot(delta)) {
+    const data = delta.data;
+    if (Array.isArray(data)) {
+      return data;
+    }
+  }
+  if (Array.isArray(delta)) {
+    return delta;
+  }
+  return [];
+}
+function applyDeltaToLoroText(text, deltas) {
+  let position = 0;
+  const markOperations = [];
+  for (const delta of deltas) {
+    if (delta.insert !== void 0) {
+      const content = delta.insert;
+      text.insert(position, content);
+      if (delta.attributes && Object.keys(delta.attributes).length > 0) {
+        markOperations.push({
+          start: position,
+          end: position + content.length,
+          attributes: delta.attributes
+        });
+      }
+      position += content.length;
+    } else if (delta.retain) {
+      position += delta.retain;
+    } else if (delta.delete) {
+      text.delete(position, delta.delete);
+    }
+  }
+  for (const op of markOperations) {
+    for (const [key, value] of Object.entries(op.attributes)) {
+      text.mark({ start: op.start, end: op.end }, key, value);
+    }
+  }
+}
+function convertJsonToLoroData(v) {
+  if (isPlainPrimitive(v)) {
+    return v;
+  }
+  if (isPlainArray(v)) {
+    const list = new LoroMovableList();
+    applyJsonArrayToLoroMovableList(list, v);
+    return list;
+  }
+  if (isPlainObject(v)) {
+    if (v[frozenKey] === true) {
+      return v;
+    }
+    if (isLoroTextModelSnapshot(v)) {
+      const text = new LoroText();
+      const deltas = extractTextDeltaFromSnapshot(v.deltaList);
+      if (deltas.length > 0) {
+        applyDeltaToLoroText(text, deltas);
+      }
+      return text;
+    }
+    const map = new LoroMap();
+    applyJsonObjectToLoroMap(map, v);
+    return map;
+  }
+  throw new Error(`unsupported value type: ${v}`);
+}
+const applyJsonArrayToLoroMovableList = (dest, source, options = {}) => {
+  const { mode = "add" } = options;
+  if (mode === "add") {
+    for (const item of source) {
+      const converted = convertJsonToLoroData(item);
+      if (isBindableLoroContainer(converted)) {
+        dest.pushContainer(converted);
+      } else {
+        dest.push(converted);
+      }
+    }
+    return;
+  }
+  if (isLoroContainerUpToDate(dest, source)) {
+    return;
+  }
+  const destLen = dest.length;
+  const srcLen = source.length;
+  if (destLen > srcLen) {
+    dest.delete(srcLen, destLen - srcLen);
+  }
+  const minLen = Math.min(destLen, srcLen);
+  for (let i = 0; i < minLen; i++) {
+    const srcItem = source[i];
+    const destItem = dest.get(i);
+    if (isPlainObject(srcItem) && destItem instanceof LoroMap) {
+      applyJsonObjectToLoroMap(destItem, srcItem, options);
+      continue;
+    }
+    if (isPlainArray(srcItem) && destItem instanceof LoroMovableList) {
+      applyJsonArrayToLoroMovableList(destItem, srcItem, options);
+      continue;
+    }
+    if (isPlainPrimitive(srcItem) && destItem === srcItem) {
+      continue;
+    }
+    dest.delete(i, 1);
+    const converted = convertJsonToLoroData(srcItem);
+    if (isBindableLoroContainer(converted)) {
+      dest.insertContainer(i, converted);
+    } else {
+      dest.insert(i, converted);
+    }
+  }
+  for (let i = destLen; i < srcLen; i++) {
+    const converted = convertJsonToLoroData(source[i]);
+    if (isBindableLoroContainer(converted)) {
+      dest.pushContainer(converted);
+    } else {
+      dest.push(converted);
+    }
+  }
+  setLoroContainerSnapshot(dest, source);
+};
+const applyJsonObjectToLoroMap = (dest, source, options = {}) => {
+  const { mode = "add" } = options;
+  if (mode === "add") {
+    for (const k of Object.keys(source)) {
+      const v = source[k];
+      if (v !== void 0) {
+        const converted = convertJsonToLoroData(v);
+        if (isBindableLoroContainer(converted)) {
+          dest.setContainer(k, converted);
+        } else {
+          dest.set(k, converted);
+        }
+      }
+    }
+    return;
+  }
+  if (isLoroContainerUpToDate(dest, source)) {
+    return;
+  }
+  const sourceKeysWithValues = new Set(Object.keys(source).filter((k) => source[k] !== void 0));
+  for (const key of dest.keys()) {
+    if (!sourceKeysWithValues.has(key)) {
+      dest.delete(key);
+    }
+  }
+  for (const k of Object.keys(source)) {
+    const v = source[k];
+    if (v === void 0) {
+      continue;
+    }
+    const existing = dest.get(k);
+    if (isPlainObject(v) && existing instanceof LoroMap) {
+      applyJsonObjectToLoroMap(existing, v, options);
+      continue;
+    }
+    if (isPlainArray(v) && existing instanceof LoroMovableList) {
+      applyJsonArrayToLoroMovableList(existing, v, options);
+      continue;
+    }
+    if (isPlainPrimitive(v) && existing === v) {
+      continue;
+    }
+    const converted = convertJsonToLoroData(v);
+    if (isBindableLoroContainer(converted)) {
+      dest.setContainer(k, converted);
+    } else {
+      dest.set(k, converted);
+    }
+  }
+  setLoroContainerSnapshot(dest, source);
+};
+function convertValue(v) {
+  if (v === null || v === void 0 || typeof v !== "object") {
+    return v;
+  }
+  if (Array.isArray(v) && v.length === 0) {
+    return new LoroMovableList();
+  }
+  if (isLoroTextModelSnapshot(v)) {
+    return v;
+  }
+  return convertJsonToLoroData(v);
+}
+function insertIntoList(list, index, value) {
+  if (value instanceof LoroMap || value instanceof LoroMovableList || value instanceof LoroText) {
+    list.insertContainer(index, value);
+  } else if (isLoroTextModelSnapshot(value)) {
+    const attachedText = list.insertContainer(index, new LoroText());
+    const deltas = extractTextDeltaFromSnapshot(value.deltaList);
+    if (deltas.length > 0) {
+      applyDeltaToLoroText(attachedText, deltas);
+    }
+  } else {
+    list.insert(index, value);
+  }
+}
+function setInMap(map, key, value) {
+  if (value === void 0) {
+    map.delete(key);
+  } else if (value instanceof LoroMap || value instanceof LoroMovableList || value instanceof LoroText) {
+    map.setContainer(key, value);
+  } else if (isLoroTextModelSnapshot(value)) {
+    const attachedText = map.setContainer(key, new LoroText());
+    const deltas = extractTextDeltaFromSnapshot(value.deltaList);
+    if (deltas.length > 0) {
+      applyDeltaToLoroText(attachedText, deltas);
+    }
+  } else {
+    map.set(key, value);
+  }
+}
+function applyMobxChangeToLoroObject(change, loroObject) {
+  const loroContainer = resolveLoroPath(loroObject, change.path);
+  if (!loroContainer) {
+    throw failure(
+      `cannot apply change to missing Loro container at path: ${JSON.stringify(change.path)}`
+    );
+  }
+  switch (change.type) {
+    case "ArrayMove": {
+      if (!(loroContainer instanceof LoroMovableList)) {
+        throw failure(`ArrayMove change requires a LoroMovableList container`);
+      }
+      loroContainer.move(change.fromIndex, change.toIndex);
+      break;
+    }
+    case DeepChangeType.ArraySplice: {
+      if (!(loroContainer instanceof LoroMovableList)) {
+        throw failure(`ArraySplice change requires a LoroMovableList container`);
+      }
+      if (change.removedValues.length > 0) {
+        loroContainer.delete(change.index, change.removedValues.length);
+      }
+      if (change.addedValues.length > 0) {
+        const valuesToInsert = change.addedValues.map(convertValue);
+        for (let i = 0; i < valuesToInsert.length; i++) {
+          insertIntoList(loroContainer, change.index + i, valuesToInsert[i]);
+        }
+      }
+      break;
+    }
+    case DeepChangeType.ArrayUpdate: {
+      if (!(loroContainer instanceof LoroMovableList)) {
+        throw failure(`ArrayUpdate change requires a LoroMovableList container`);
+      }
+      const converted = convertValue(change.newValue);
+      if (converted instanceof LoroMap || converted instanceof LoroMovableList || converted instanceof LoroText) {
+        loroContainer.setContainer(change.index, converted);
+      } else if (isLoroTextModelSnapshot(converted)) {
+        const attachedText = loroContainer.setContainer(change.index, new LoroText());
+        const deltas = extractTextDeltaFromSnapshot(converted.deltaList);
+        if (deltas.length > 0) {
+          applyDeltaToLoroText(attachedText, deltas);
+        }
+      } else {
+        loroContainer.set(change.index, converted);
+      }
+      break;
+    }
+    case DeepChangeType.ObjectAdd:
+    case DeepChangeType.ObjectUpdate: {
+      if (loroContainer instanceof LoroText) {
+        if (change.key === "deltaList") {
+          const deltas = extractTextDeltaFromSnapshot(change.newValue);
+          if (loroContainer.length > 0) {
+            loroContainer.delete(0, loroContainer.length);
+          }
+          if (deltas.length > 0) {
+            applyDeltaToLoroText(loroContainer, deltas);
+          }
+        }
+      } else if (loroContainer instanceof LoroMap) {
+        const converted = convertValue(change.newValue);
+        setInMap(loroContainer, change.key, converted);
+      } else {
+        throw failure(`ObjectAdd/ObjectUpdate change requires a LoroMap or LoroText container`);
+      }
+      break;
+    }
+    case DeepChangeType.ObjectRemove: {
+      if (loroContainer instanceof LoroText) ;
+      else if (loroContainer instanceof LoroMap) {
+        loroContainer.delete(change.key);
+      } else {
+        throw failure(`ObjectRemove change requires a LoroMap or LoroText container`);
+      }
+      break;
+    }
+    default: {
+      const _exhaustiveCheck = change;
+      throw failure(`unsupported change type: ${_exhaustiveCheck.type}`);
+    }
+  }
+}
+let activeMoveContext;
+function moveWithinArray(array, fromIndex, toIndex) {
+  if (fromIndex < 0 || fromIndex >= array.length) {
+    throw new Error(`fromIndex ${fromIndex} is out of bounds (array length: ${array.length})`);
+  }
+  if (toIndex < 0 || toIndex > array.length) {
+    throw new Error(`toIndex ${toIndex} is out of bounds (array length: ${array.length})`);
+  }
+  if (fromIndex === toIndex) {
+    return;
+  }
+  activeMoveContext = {
+    array,
+    fromIndex,
+    toIndex,
+    path: void 0,
+    receivedFirstSplice: false
+  };
+  try {
+    const [item] = array.splice(fromIndex, 1);
+    const adjustedTarget = toIndex > fromIndex ? toIndex - 1 : toIndex;
+    array.splice(adjustedTarget, 0, item);
+  } finally {
+    activeMoveContext = void 0;
+  }
+}
+function processChangeForMove(change) {
+  const ctx = activeMoveContext;
+  if (!ctx.receivedFirstSplice) {
+    ctx.path = change.path;
+    ctx.receivedFirstSplice = true;
+    return void 0;
+  }
+  const adjustedToIndex = ctx.toIndex > ctx.fromIndex ? ctx.toIndex - 1 : ctx.toIndex;
+  return {
+    type: "ArrayMove",
+    path: ctx.path,
+    fromIndex: ctx.fromIndex,
+    toIndex: adjustedToIndex
+  };
+}
+function isInMoveContextForArray(array) {
+  return activeMoveContext !== void 0 && activeMoveContext.array === array;
+}
+function captureChangeSnapshots(change) {
+  if (change.type === DeepChangeType.ArraySplice && change.addedValues.length > 0) {
+    const snapshots = change.addedValues.map((v) => isTreeNode(v) ? getSnapshot(v) : v);
+    return { ...change, addedValues: snapshots };
+  } else if (change.type === DeepChangeType.ArrayUpdate) {
+    const snapshot = isTreeNode(change.newValue) ? getSnapshot(change.newValue) : change.newValue;
+    return { ...change, newValue: snapshot };
+  } else if (change.type === DeepChangeType.ObjectAdd || change.type === DeepChangeType.ObjectUpdate) {
+    const snapshot = isTreeNode(change.newValue) ? getSnapshot(change.newValue) : change.newValue;
+    return { ...change, newValue: snapshot };
+  }
+  return change;
+}
+function bindLoroToMobxKeystone({
+  loroDoc,
+  loroObject,
+  mobxKeystoneType
+}) {
+  var _a;
+  const loroOrigin = `bindLoroToMobxKeystoneTransactionOrigin-${nanoid()}`;
+  let applyingLoroChangesToMobxKeystone = 0;
+  const bindingContext = {
+    loroDoc,
+    loroObject,
+    mobxKeystoneType,
+    loroOrigin,
+    boundObject: void 0,
+    // not yet created
+    get isApplyingLoroChangesToMobxKeystone() {
+      return applyingLoroChangesToMobxKeystone > 0;
+    }
+  };
+  const loroJson = convertLoroDataToJson(loroObject);
+  let boundObject;
+  let hasInitChanges = false;
+  const createBoundObject = () => {
+    const disposeGlobalListener = onGlobalDeepChange((_target, change) => {
+      if (change.isInit) {
+        hasInitChanges = true;
+      }
+    });
+    try {
+      const result = loroBindingContext.apply(
+        () => fromSnapshot(mobxKeystoneType, loroJson),
+        bindingContext
+      );
+      loroBindingContext.set(result, { ...bindingContext, boundObject: result });
+      return result;
+    } finally {
+      disposeGlobalListener();
+    }
+  };
+  boundObject = createBoundObject();
+  const rootLoroPath = (_a = loroDoc.getPathToContainer(loroObject.id)) != null ? _a : [];
+  const loroSubscribeCb = action((eventBatch) => {
+    if (eventBatch.origin === loroOrigin) {
+      return;
+    }
+    const newlyInsertedContainers = /* @__PURE__ */ new Set();
+    const reconciliationMap = /* @__PURE__ */ new Map();
+    const initChanges = [];
+    const disposeGlobalListener = onGlobalDeepChange((target, change) => {
+      if (change.isInit) {
+        initChanges.push({ target, change: captureChangeSnapshots(change) });
+      }
+    });
+    applyingLoroChangesToMobxKeystone++;
+    try {
+      try {
+        for (const event of eventBatch.events) {
+          applyLoroEventToMobx(
+            event,
+            loroDoc,
+            boundObject,
+            rootLoroPath,
+            reconciliationMap,
+            newlyInsertedContainers
+          );
+        }
+      } finally {
+        disposeGlobalListener();
+      }
+      if (initChanges.length > 0) {
+        loroDoc.setNextCommitOrigin(loroOrigin);
+        for (const { target, change } of initChanges) {
+          const pathToTarget = getParentToChildPath(boundObject, target);
+          if (pathToTarget !== void 0) {
+            const changeWithCorrectPath = {
+              ...change,
+              path: [...pathToTarget, ...change.path]
+            };
+            applyMobxChangeToLoroObject(changeWithCorrectPath, loroObject);
+          }
+        }
+        loroDoc.commit();
+      }
+      if (loroObject instanceof LoroMap || loroObject instanceof LoroMovableList) {
+        setLoroContainerSnapshot(loroObject, getSnapshot(boundObject));
+      }
+    } finally {
+      applyingLoroChangesToMobxKeystone--;
+    }
+  });
+  const loroUnsubscribe = loroDoc.subscribe(loroSubscribeCb);
+  let pendingChanges = [];
+  const disposeOnDeepChange = onDeepChange(boundObject, (change) => {
+    if (bindingContext.isApplyingLoroChangesToMobxKeystone) {
+      return;
+    }
+    if (change.isInit) {
+      return;
+    }
+    if (change.type === DeepChangeType.ArraySplice) {
+      const resolved = resolvePath(boundObject, change.path);
+      if (resolved.resolved && isInMoveContextForArray(resolved.value)) {
+        const moveResult = processChangeForMove(change);
+        if (moveResult === void 0) {
+          return;
+        }
+        pendingChanges.push(moveResult);
+        return;
+      }
+    }
+    pendingChanges.push(captureChangeSnapshots(change));
+  });
+  const disposeOnSnapshot = onSnapshot(boundObject, () => {
+    if (pendingChanges.length === 0) {
+      return;
+    }
+    const changesToApply = pendingChanges;
+    pendingChanges = [];
+    if (bindingContext.isApplyingLoroChangesToMobxKeystone) {
+      return;
+    }
+    loroDoc.setNextCommitOrigin(loroOrigin);
+    for (const change of changesToApply) {
+      applyMobxChangeToLoroObject(change, loroObject);
+    }
+    loroDoc.commit();
+    if (loroObject instanceof LoroMap || loroObject instanceof LoroMovableList) {
+      setLoroContainerSnapshot(loroObject, getSnapshot(boundObject));
+    }
+    getOrCreateLoroCollectionAtom(loroObject).reportChanged();
+  });
+  const finalSnapshot = getSnapshot(boundObject);
+  if (hasInitChanges) {
+    loroDoc.setNextCommitOrigin(loroOrigin);
+    if (loroObject instanceof LoroMap) {
+      applyJsonObjectToLoroMap(loroObject, finalSnapshot, { mode: "merge" });
+    } else if (loroObject instanceof LoroMovableList) {
+      applyJsonArrayToLoroMovableList(loroObject, finalSnapshot, { mode: "merge" });
+    } else if (loroObject instanceof LoroText) {
+      const snapshot = finalSnapshot;
+      if (snapshot.$modelType === loroTextModelId) {
+        if (loroObject.length > 0) {
+          loroObject.delete(0, loroObject.length);
+        }
+        const deltas = extractTextDeltaFromSnapshot(snapshot.deltaList);
+        if (deltas.length > 0) {
+          applyDeltaToLoroText(loroObject, deltas);
+        }
+      }
+    }
+    loroDoc.commit();
+  }
+  if (loroObject instanceof LoroMap || loroObject instanceof LoroMovableList) {
+    setLoroContainerSnapshot(loroObject, finalSnapshot);
+  }
+  const dispose = () => {
+    loroUnsubscribe();
+    disposeOnDeepChange();
+    disposeOnSnapshot();
+  };
+  return {
+    boundObject,
+    dispose,
+    loroOrigin
+  };
+}
+export {
+  LoroTextModel,
+  MobxKeystoneLoroError,
+  applyJsonArrayToLoroMovableList,
+  applyJsonObjectToLoroMap,
+  bindLoroToMobxKeystone,
+  convertJsonToLoroData,
+  isLoroTextModelSnapshot,
+  loroBindingContext,
+  loroTextModelType,
+  moveWithinArray
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"mobx-keystone-loro.esm.mjs","sources":["../node_modules/nanoid/index.browser.js","../src/utils/getOrCreateLoroCollectionAtom.ts","../src/utils/error.ts","../src/binding/loroBindingContext.ts","../src/binding/resolveLoroPath.ts","../src/binding/LoroTextModel.ts","../src/binding/convertLoroDataToJson.ts","../src/binding/applyLoroEventToMobx.ts","../src/utils/isBindableLoroContainer.ts","../src/binding/loroSnapshotTracking.ts","../src/binding/convertJsonToLoroData.ts","../src/binding/applyMobxChangeToLoroObject.ts","../src/binding/moveWithinArray.ts","../src/binding/bindLoroToMobxKeystone.ts"],"sourcesContent":["import { urlAlphabet } from './url-alphabet/index.js'\nlet random = bytes => crypto.getRandomValues(new Uint8Array(bytes))\nlet customRandom = (alphabet, defaultSize, getRandom) => {\n  let mask = (2 << (Math.log(alphabet.length - 1) / Math.LN2)) - 1\n  let step = -~((1.6 * mask * defaultSize) / alphabet.length)\n  return (size = defaultSize) => {\n    let id = ''\n    while (true) {\n      let bytes = getRandom(step)\n      let j = step | 0\n      while (j--) {\n        id += alphabet[bytes[j] & mask] || ''\n        if (id.length === size) return id\n      }\n    }\n  }\n}\nlet customAlphabet = (alphabet, size = 21) =>\n  customRandom(alphabet, size, random)\nlet nanoid = (size = 21) =>\n  crypto.getRandomValues(new Uint8Array(size)).reduce((id, byte) => {\n    byte &= 63\n    if (byte < 36) {\n      id += byte.toString(36)\n    } else if (byte < 62) {\n      id += (byte - 26).toString(36).toUpperCase()\n    } else if (byte > 62) {\n      id += '-'\n    } else {\n      id += '_'\n    }\n    return id\n  }, '')\nexport { nanoid, customAlphabet, customRandom, urlAlphabet, random }\n","import { createAtom, type IAtom } from \"mobx\"\nimport type { BindableLoroContainer } from \"./isBindableLoroContainer\"\n\nconst atomMap = new WeakMap<BindableLoroContainer, IAtom>()\n\n/**\n * Gets or creates a MobX atom for a Loro collection.\n * This is used to track reactivity for computed properties that read from Loro containers.\n */\nexport function getOrCreateLoroCollectionAtom(collection: BindableLoroContainer): IAtom {\n  let atom = atomMap.get(collection)\n  if (!atom) {\n    atom = createAtom(`loroCollectionAtom`)\n    atomMap.set(collection, atom)\n  }\n  return atom\n}\n","export class MobxKeystoneLoroError extends Error {\n  constructor(msg: string) {\n    super(msg)\n\n    // Set the prototype explicitly for better instanceof support\n    Object.setPrototypeOf(this, MobxKeystoneLoroError.prototype)\n  }\n}\n\nexport function failure(message: string): never {\n  throw new MobxKeystoneLoroError(message)\n}\n","import type { LoroDoc } from \"loro-crdt\"\nimport { type AnyType, createContext } from \"mobx-keystone\"\nimport type { BindableLoroContainer } from \"../utils/isBindableLoroContainer\"\n\n/**\n * Context for the Loro binding, providing access to the Loro document\n * and binding state from within mobx-keystone models.\n */\nexport interface LoroBindingContext {\n  /**\n   * The Loro document being bound.\n   */\n  loroDoc: LoroDoc\n\n  /**\n   * The root Loro object being bound.\n   */\n  loroObject: BindableLoroContainer\n\n  /**\n   * The mobx-keystone model type being used.\n   */\n  mobxKeystoneType: AnyType\n\n  /**\n   * String used as origin for Loro transactions to identify changes\n   * coming from mobx-keystone.\n   */\n  loroOrigin: string\n\n  /**\n   * The bound mobx-keystone object (once created).\n   */\n  boundObject: unknown\n\n  /**\n   * Whether changes are currently being applied from Loro to mobx-keystone.\n   * Used to prevent infinite loops.\n   */\n  isApplyingLoroChangesToMobxKeystone: boolean\n}\n\n/**\n * Context for accessing the Loro binding from within mobx-keystone models.\n */\nexport const loroBindingContext = createContext<LoroBindingContext | undefined>(undefined)\n","import { LoroMap, LoroMovableList } from \"loro-crdt\"\nimport type { Path } from \"mobx-keystone\"\nimport { failure } from \"../utils/error\"\nimport { getOrCreateLoroCollectionAtom } from \"../utils/getOrCreateLoroCollectionAtom\"\nimport type { BindableLoroContainer } from \"../utils/isBindableLoroContainer\"\n\n/**\n * Resolves a path within a Loro object structure.\n * Returns the Loro container at the specified path.\n *\n * @param loroObject The root Loro object\n * @param path Array of keys/indices to traverse\n * @returns The Loro container at the path\n */\nexport function resolveLoroPath(loroObject: BindableLoroContainer, path: Path): unknown {\n  let currentLoroObject: unknown = loroObject\n\n  path.forEach((pathPart, i) => {\n    if (currentLoroObject instanceof LoroMap) {\n      getOrCreateLoroCollectionAtom(currentLoroObject).reportObserved()\n      const key = String(pathPart)\n      currentLoroObject = currentLoroObject.get(key)\n    } else if (currentLoroObject instanceof LoroMovableList) {\n      getOrCreateLoroCollectionAtom(currentLoroObject).reportObserved()\n      const key = Number(pathPart)\n      currentLoroObject = currentLoroObject.get(key)\n    } else {\n      throw failure(\n        `LoroMap or LoroMovableList was expected at path ${JSON.stringify(\n          path.slice(0, i)\n        )} in order to resolve path ${JSON.stringify(path)}, but got ${currentLoroObject} instead`\n      )\n    }\n  })\n\n  return currentLoroObject\n}\n","import { type Delta, LoroText } from \"loro-crdt\"\r\nimport { computed, createAtom } from \"mobx\"\r\nimport {\r\n  frozen,\r\n  getParentToChildPath,\r\n  getSnapshotModelType,\r\n  Model,\r\n  model,\r\n  modelAction,\r\n  type SnapshotOutOf,\r\n  tProp,\r\n  types,\r\n} from \"mobx-keystone\"\r\nimport { getOrCreateLoroCollectionAtom } from \"../utils/getOrCreateLoroCollectionAtom\"\r\nimport { loroBindingContext } from \"./loroBindingContext\"\r\nimport { resolveLoroPath } from \"./resolveLoroPath\"\r\n\r\nexport const loroTextModelId = \"mobx-keystone-loro/LoroTextModel\"\r\n\r\n/**\r\n * Type for the delta stored in the model.\r\n * Uses Quill delta format: array of operations with insert, delete, retain.\r\n */\r\nexport type LoroTextDeltaList = Delta<string>[]\r\n\r\n/**\r\n * A mobx-keystone model representing Loro rich text.\r\n * This model stores the current delta state (Quill format) and syncs with LoroText.\r\n */\r\n@model(loroTextModelId)\r\nexport class LoroTextModel extends Model({\r\n  /**\r\n   * The current delta representing the rich text content.\r\n   * Uses Quill delta format.\r\n   */\r\n  deltaList: tProp(types.frozen(types.unchecked<LoroTextDeltaList>()), () => frozen([])),\r\n}) {\r\n  /**\r\n   * Creates a LoroTextModel with initial text content.\r\n   */\r\n  static withText(text: string): LoroTextModel {\r\n    return new LoroTextModel({\r\n      deltaList: frozen([{ insert: text }]),\r\n    })\r\n  }\r\n\r\n  /**\r\n   * Creates a LoroTextModel with initial delta.\r\n   */\r\n  static withDelta(delta: LoroTextDeltaList): LoroTextModel {\r\n    return new LoroTextModel({\r\n      deltaList: frozen(delta),\r\n    })\r\n  }\r\n\r\n  /**\r\n   * Atom that gets changed when the associated Loro text changes.\r\n   */\r\n  loroTextChangedAtom = createAtom(\"loroTextChangedAtom\")\r\n\r\n  /**\r\n   * The LoroText object represented by this mobx-keystone node, if bound.\r\n   * Returns undefined when the model is not part of a bound object tree.\r\n   */\r\n  @computed\r\n  get loroText(): LoroText | undefined {\r\n    // Check if we have a binding context first - return undefined if not bound\r\n    const ctx = loroBindingContext.get(this)\r\n    if (ctx?.boundObject == null) {\r\n      return undefined\r\n    }\r\n\r\n    try {\r\n      const path = getParentToChildPath(ctx.boundObject, this)\r\n      if (!path) {\r\n        return undefined\r\n      }\r\n\r\n      // If this model IS the bound object, the loroObject is the LoroText\r\n      if (path.length === 0) {\r\n        const loroObject = ctx.loroObject\r\n        if (loroObject instanceof LoroText) {\r\n          getOrCreateLoroCollectionAtom(loroObject).reportObserved()\r\n          return loroObject\r\n        }\r\n        return undefined\r\n      }\r\n\r\n      // Otherwise resolve the path\r\n      const loroObject = resolveLoroPath(ctx.loroObject, path)\r\n\r\n      if (loroObject instanceof LoroText) {\r\n        getOrCreateLoroCollectionAtom(loroObject).reportObserved()\r\n        return loroObject\r\n      }\r\n    } catch {\r\n      // Path resolution failed - return undefined\r\n    }\r\n\r\n    return undefined\r\n  }\r\n\r\n  /**\r\n   * Gets the plain text content.\r\n   * This always uses the stored delta, which is kept in sync with Loro.\r\n   */\r\n  @computed\r\n  get text(): string {\r\n    this.loroTextChangedAtom.reportObserved()\r\n\r\n    // Always compute from delta - it's the source of truth for this model\r\n    // The delta is kept in sync with Loro via patches\r\n    return this.deltaToText(this.deltaList.data)\r\n  }\r\n\r\n  /**\r\n   * Gets the current delta (Quill format).\r\n   */\r\n  @computed\r\n  get currentDelta(): LoroTextDeltaList {\r\n    this.loroTextChangedAtom.reportObserved()\r\n\r\n    // Try to get from bound LoroText first\r\n    const loroText = this.loroText\r\n    if (loroText) {\r\n      try {\r\n        return loroText.toDelta()\r\n      } catch {\r\n        // fall back to stored delta\r\n      }\r\n    }\r\n\r\n    return this.deltaList.data\r\n  }\r\n\r\n  /**\r\n   * Converts delta to plain text.\r\n   */\r\n  private deltaToText(delta: LoroTextDeltaList): string {\r\n    let result = \"\"\r\n    for (const op of delta) {\r\n      if (\"insert\" in op && typeof op.insert === \"string\") {\r\n        result += op.insert\r\n      }\r\n    }\r\n    return result\r\n  }\r\n\r\n  /**\r\n   * Sets the delta.\r\n   */\r\n  @modelAction\r\n  setDelta(delta: LoroTextDeltaList): void {\r\n    this.deltaList = frozen(delta)\r\n  }\r\n\r\n  /**\r\n   * Inserts text at the specified position.\r\n   */\r\n  @modelAction\r\n  insertText(index: number, text: string): void {\r\n    const loroText = this.loroText\r\n    if (loroText) {\r\n      loroText.insert(index, text)\r\n      // The binding will handle syncing back\r\n    } else {\r\n      // Fallback: modify delta directly\r\n      const currentText = this.text\r\n      const newText = currentText.slice(0, index) + text + currentText.slice(index)\r\n      this.deltaList = frozen([{ insert: newText }])\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Deletes text at the specified range.\r\n   */\r\n  @modelAction\r\n  deleteText(index: number, length: number): void {\r\n    const loroText = this.loroText\r\n    if (loroText) {\r\n      loroText.delete(index, length)\r\n      // The binding will handle syncing back\r\n    } else {\r\n      // Fallback: modify delta directly\r\n      const currentText = this.text\r\n      const newText = currentText.slice(0, index) + currentText.slice(index + length)\r\n      this.deltaList = frozen([{ insert: newText }])\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Internal action to update delta from Loro sync.\r\n   * @internal\r\n   */\r\n  @modelAction\r\n  _updateDeltaFromLoro(delta: LoroTextDeltaList): void {\r\n    this.deltaList = frozen(delta)\r\n  }\r\n}\r\n\r\n/**\r\n * Type for LoroTextModel for use with tProp.\r\n */\r\nexport const loroTextModelType = types.model(LoroTextModel)\r\n\r\n/**\r\n * Checks if a snapshot is a LoroTextModel snapshot.\r\n */\r\nexport function isLoroTextModelSnapshot(value: unknown): value is SnapshotOutOf<LoroTextModel> {\r\n  return getSnapshotModelType(value) === loroTextModelId\r\n}\r\n","import { isContainer, LoroMap, LoroMovableList, LoroText } from \"loro-crdt\"\nimport { modelSnapshotOutWithMetadata, toFrozenSnapshot } from \"mobx-keystone\"\nimport type { PlainValue } from \"../plainTypes\"\nimport { failure } from \"../utils/error\"\nimport { type BindableLoroContainer } from \"../utils/isBindableLoroContainer\"\nimport { LoroTextModel } from \"./LoroTextModel\"\n\ntype LoroValue = BindableLoroContainer | PlainValue\n\n/**\n * Converts Loro data to JSON-compatible format for mobx-keystone snapshots.\n *\n * @param value The Loro value to convert\n * @returns JSON-compatible value\n */\nexport function convertLoroDataToJson(value: LoroValue): PlainValue {\n  if (value === null) {\n    return null\n  }\n\n  if (typeof value !== \"object\") {\n    if (value === undefined) {\n      throw new Error(\"undefined values are not supported by Loro\")\n    }\n\n    return value as PlainValue\n  }\n\n  if (isContainer(value)) {\n    if (value instanceof LoroMap) {\n      const result: Record<string, PlainValue> = {}\n      for (const [k, v] of value.entries()) {\n        result[k] = convertLoroDataToJson(v as LoroValue)\n      }\n      return result\n    }\n\n    if (value instanceof LoroMovableList) {\n      const result: PlainValue[] = []\n      for (let i = 0; i < value.length; i++) {\n        result.push(convertLoroDataToJson(value.get(i) as LoroValue))\n      }\n      return result\n    }\n\n    if (value instanceof LoroText) {\n      const deltas = value.toDelta()\n      // Return a LoroTextModel-compatible snapshot\n      return modelSnapshotOutWithMetadata(LoroTextModel, {\n        deltaList: toFrozenSnapshot(deltas),\n      }) as unknown as PlainValue\n    }\n\n    throw failure(`unsupported bindable Loro container type`)\n  }\n\n  // Plain object or array\n  if (Array.isArray(value)) {\n    return value.map((item) => convertLoroDataToJson(item as LoroValue))\n  }\n\n  const result: Record<string, PlainValue> = {}\n  for (const [k, v] of Object.entries(value)) {\n    result[k] = convertLoroDataToJson(v as LoroValue)\n  }\n\n  return result\n}\n","import type { ContainerID, ListDiff, LoroDoc, LoroEvent, MapDiff } from \"loro-crdt\"\nimport { isContainer, LoroMap, LoroMovableList, LoroText } from \"loro-crdt\"\nimport { remove } from \"mobx\"\nimport {\n  Frozen,\n  fromSnapshot,\n  frozen,\n  getSnapshotModelId,\n  isDataModel,\n  isFrozenSnapshot,\n  isModel,\n  modelIdKey,\n  Path,\n  resolvePath,\n  runUnprotected,\n} from \"mobx-keystone\"\nimport type { PlainValue } from \"../plainTypes\"\nimport { failure } from \"../utils/error\"\nimport { convertLoroDataToJson } from \"./convertLoroDataToJson\"\n\n// Represents the map of potential objects to reconcile (ID -> Object)\nexport type ReconciliationMap = Map<string, object>\n\n/**\n * Applies a Loro event directly to the MobX model tree using proper mutations\n * (splice for arrays, property assignment for objects).\n * This is more efficient than converting to patches first.\n */\nexport function applyLoroEventToMobx(\n  event: LoroEvent,\n  loroDoc: LoroDoc,\n  boundObject: object,\n  rootPath: Path,\n  reconciliationMap: ReconciliationMap,\n  newlyInsertedContainers: Set<ContainerID>\n): void {\n  // Skip events for containers that were just inserted as part of another container\n  // Their content is already included in the parent's convertLoroDataToJson call\n  if (newlyInsertedContainers.has(event.target)) {\n    return\n  }\n\n  // Resolve the path relative to the root\n  const eventPath = loroDoc.getPathToContainer(event.target)\n  if (!eventPath) {\n    return\n  }\n\n  // Strip the root path to get relative path\n  const relativePath = resolveEventPath(eventPath, rootPath)\n  if (relativePath === undefined) {\n    return\n  }\n\n  const { value: target } = resolvePath(boundObject, relativePath)\n\n  if (!target) {\n    throw failure(`cannot resolve path ${JSON.stringify(relativePath)}`)\n  }\n\n  // Wrap in runUnprotected since we're modifying the tree from outside a model action\n  runUnprotected(() => {\n    const diff = event.diff\n    if (diff.type === \"map\") {\n      applyMapEventToMobx(diff, loroDoc, event.target, target, reconciliationMap)\n    } else if (diff.type === \"list\") {\n      applyListEventToMobx(\n        diff,\n        loroDoc,\n        event.target,\n        target,\n        reconciliationMap,\n        newlyInsertedContainers\n      )\n    } else if (diff.type === \"text\") {\n      applyTextEventToMobx(loroDoc, event.target, target)\n    }\n  })\n}\n\nfunction processDeletedValue(val: unknown, reconciliationMap: ReconciliationMap) {\n  // Handle both Model and DataModel instances\n  if (isModel(val) || isDataModel(val)) {\n    const id = modelIdKey in val ? val[modelIdKey] : undefined\n    if (id) {\n      reconciliationMap.set(id, val)\n    }\n  }\n}\n\nfunction reviveValue(jsonValue: unknown, reconciliationMap: ReconciliationMap): unknown {\n  // Handle primitives\n  if (jsonValue === null || typeof jsonValue !== \"object\") {\n    return jsonValue\n  }\n\n  // Handle frozen\n  if (isFrozenSnapshot(jsonValue)) {\n    return frozen(jsonValue.data)\n  }\n\n  // If we have a reconciliation map and the value looks like a model with an ID, check if we have it\n  if (reconciliationMap) {\n    const modelId = getSnapshotModelId(jsonValue)\n    if (modelId) {\n      const existing = reconciliationMap.get(modelId)\n      if (existing) {\n        reconciliationMap.delete(modelId)\n        return existing\n      }\n    }\n  }\n\n  return fromSnapshot(jsonValue)\n}\n\nfunction applyMapEventToMobx(\n  diff: MapDiff,\n  loroDoc: LoroDoc,\n  containerTarget: ContainerID,\n  target: Record<string, unknown>,\n  reconciliationMap: ReconciliationMap\n): void {\n  const container = loroDoc.getContainerById(containerTarget)\n\n  if (!container || !(container instanceof LoroMap)) {\n    throw failure(`${containerTarget} was not a Loro map`)\n  }\n\n  // Process additions and updates from diff.updated\n  for (const key of Object.keys(diff.updated)) {\n    const loroValue = container.get(key)\n\n    if (loroValue === undefined) {\n      // Key was deleted (Loro returns undefined for deleted keys)\n      if (key in target) {\n        processDeletedValue(target[key], reconciliationMap)\n        // Use MobX's remove to properly delete the key from the observable object\n        if (isModel(target)) {\n          remove(target.$, key)\n        } else {\n          remove(target, key)\n        }\n      }\n    } else {\n      // Key was added or updated\n      if (key in target) {\n        processDeletedValue(target[key], reconciliationMap)\n      }\n      const jsonValue = convertLoroDataToJson(loroValue as PlainValue)\n      target[key] = reviveValue(jsonValue, reconciliationMap)\n    }\n  }\n}\n\nfunction applyListEventToMobx(\n  diff: ListDiff,\n  loroDoc: LoroDoc,\n  containerTarget: ContainerID,\n  target: unknown[],\n  reconciliationMap: ReconciliationMap,\n  newlyInsertedContainers: Set<ContainerID>\n): void {\n  const container = loroDoc.getContainerById(containerTarget)\n\n  if (!container || !(container instanceof LoroMovableList)) {\n    throw failure(`${containerTarget} was not a Loro movable list`)\n  }\n\n  // Process delta operations in order\n  let currentIndex = 0\n\n  for (const change of diff.diff) {\n    if (change.retain) {\n      currentIndex += change.retain\n    }\n\n    if (change.delete) {\n      // Capture deleted items for reconciliation\n      const deletedItems = target.slice(currentIndex, currentIndex + change.delete)\n      deletedItems.forEach((item) => {\n        processDeletedValue(item, reconciliationMap)\n      })\n\n      // Delete items at current position\n      target.splice(currentIndex, change.delete)\n    }\n\n    if (change.insert) {\n      // Insert items at current position\n      const insertedItems = change.insert\n      const values = insertedItems.map((loroValue) => {\n        // Track container IDs to avoid double-processing their events\n        // When a container with data is inserted, Loro fires events for both\n        // the container insert and the container's content, but the content\n        // is already included in convertLoroDataToJson\n        if (isContainer(loroValue)) {\n          newlyInsertedContainers.add(loroValue.id)\n          // Also recursively track any nested containers\n          collectNestedContainerIds(loroValue, newlyInsertedContainers)\n        }\n        const jsonValue = convertLoroDataToJson(loroValue as PlainValue)\n        return reviveValue(jsonValue, reconciliationMap)\n      })\n\n      target.splice(currentIndex, 0, ...values)\n      currentIndex += values.length\n    }\n  }\n}\n\nfunction applyTextEventToMobx(\n  loroDoc: LoroDoc,\n  containerTarget: ContainerID,\n  target: { deltaList?: Frozen<unknown[]> }\n): void {\n  const container = loroDoc.getContainerById(containerTarget)\n\n  if (!container || !(container instanceof LoroText)) {\n    throw failure(`${containerTarget} was not a Loro text container`)\n  }\n\n  // LoroTextModel has deltaList as a single Frozen<LoroTextDeltaList>, not an array\n  // Replace it with the current delta from the LoroText\n  if (!(\"deltaList\" in target)) {\n    throw failure(\"target does not have a deltaList property - expected LoroTextModel\")\n  }\n  target.deltaList = frozen(container.toDelta())\n}\n\n/**\n * Recursively collects all container IDs from a Loro container.\n * This is used to track containers that have been inserted and should not\n * have their events processed again (since their content was already included\n * in the parent's convertLoroDataToJson call).\n */\nfunction collectNestedContainerIds(container: unknown, containerIds: Set<ContainerID>): void {\n  if (!isContainer(container)) {\n    return\n  }\n\n  // Add this container's ID\n  containerIds.add(container.id)\n\n  // Handle LoroMap - iterate over values\n  if (container instanceof LoroMap) {\n    for (const key of Object.keys(container.toJSON())) {\n      const value = container.get(key)\n      collectNestedContainerIds(value, containerIds)\n    }\n  }\n\n  // Handle LoroMovableList - iterate over items\n  if (container instanceof LoroMovableList) {\n    for (let i = 0; i < container.length; i++) {\n      collectNestedContainerIds(container.get(i), containerIds)\n    }\n  }\n\n  // LoroText doesn't contain nested containers\n}\n\n/**\n * Resolves the path from a Loro event to a mobx-keystone path.\n * The event path is the path from the doc root to the container that emitted the event.\n * We need to strip the path of our root container to get a path relative to our bound object.\n */\nfunction resolveEventPath(eventPath: Path, rootPath: Path): Path | undefined {\n  if (eventPath.length < rootPath.length) {\n    return undefined\n  }\n\n  for (let i = 0; i < rootPath.length; i++) {\n    if (eventPath[i] !== rootPath[i]) {\n      return undefined\n    }\n  }\n\n  return eventPath.slice(rootPath.length) as Path\n}\n","import { LoroMap, LoroMovableList, LoroText } from \"loro-crdt\"\n\n/**\n * A bindable Loro container (Map, MovableList, or Text).\n */\nexport type BindableLoroContainer = LoroMap | LoroMovableList | LoroText\n\n/**\n * Checks if a value is a bindable Loro container.\n */\nexport function isBindableLoroContainer(value: unknown): value is BindableLoroContainer {\n  return value instanceof LoroMap || value instanceof LoroMovableList || value instanceof LoroText\n}\n","import type { LoroMap, LoroMovableList } from \"loro-crdt\"\n\ntype LoroContainer = LoroMap | LoroMovableList\n\n/**\n * WeakMap that tracks which snapshot each Loro container was last synced from.\n * This is used during reconciliation to skip containers that are already up-to-date.\n *\n * The key is the Loro container (LoroMap or LoroMovableList).\n * The value is the snapshot (plain object or array) that was last synced to it.\n */\nexport const loroContainerToSnapshot = new WeakMap<LoroContainer, unknown>()\n\n/**\n * Updates the snapshot tracking for a Loro container.\n * Call this after syncing a snapshot to a Loro container.\n */\nexport function setLoroContainerSnapshot(container: LoroContainer, snapshot: unknown): void {\n  loroContainerToSnapshot.set(container, snapshot)\n}\n\n/**\n * Gets the last synced snapshot for a Loro container.\n * Returns undefined if the container has never been synced.\n */\nexport function getLoroContainerSnapshot(container: LoroContainer): unknown {\n  return loroContainerToSnapshot.get(container)\n}\n\n/**\n * Checks if a Loro container is up-to-date with the given snapshot.\n * Uses reference equality to check if the snapshot is the same.\n */\nexport function isLoroContainerUpToDate(container: LoroContainer, snapshot: unknown): boolean {\n  return loroContainerToSnapshot.get(container) === snapshot\n}\n","import type { Delta } from \"loro-crdt\"\nimport { LoroMap, LoroMovableList, LoroText } from \"loro-crdt\"\nimport { frozenKey, isFrozenSnapshot } from \"mobx-keystone\"\nimport type { PlainArray, PlainObject, PlainPrimitive, PlainValue } from \"../plainTypes\"\nimport {\n  type BindableLoroContainer,\n  isBindableLoroContainer,\n} from \"../utils/isBindableLoroContainer\"\nimport { isLoroTextModelSnapshot } from \"./LoroTextModel\"\nimport { isLoroContainerUpToDate, setLoroContainerSnapshot } from \"./loroSnapshotTracking\"\n\ntype LoroValue = BindableLoroContainer | PlainValue\n\n/**\n * Options for applying JSON data to Loro data structures.\n */\nexport interface ApplyJsonToLoroOptions {\n  /**\n   * The mode to use when applying JSON data to Loro data structures.\n   * - `add`: Creates new Loro containers for objects/arrays (default, backwards compatible)\n   * - `merge`: Recursively merges values, preserving existing container references where possible\n   */\n  mode?: \"add\" | \"merge\"\n}\n\nfunction isPlainPrimitive(v: PlainValue): v is PlainPrimitive {\n  const t = typeof v\n  return t === \"string\" || t === \"number\" || t === \"boolean\" || v === null || v === undefined\n}\n\nfunction isPlainArray(v: PlainValue): v is PlainArray {\n  return Array.isArray(v)\n}\n\nfunction isPlainObject(v: PlainValue): v is PlainObject {\n  return typeof v === \"object\" && v !== null && !Array.isArray(v)\n}\n\n/**\n * Extracts delta array from a LoroTextModel snapshot's delta field.\n * The delta field is a frozen Delta<string>[] (array of delta operations).\n */\nexport function extractTextDeltaFromSnapshot(delta: unknown): Delta<string>[] {\n  // The delta field is frozen, so we need to extract it\n  if (isFrozenSnapshot<Delta<string>[]>(delta)) {\n    const data = delta.data\n    if (Array.isArray(data)) {\n      return data\n    }\n  }\n\n  // Handle plain delta array (not wrapped in frozen)\n  if (Array.isArray(delta)) {\n    return delta as Delta<string>[]\n  }\n\n  return []\n}\n\n/**\n * Applies delta operations to a LoroText using insert/mark APIs.\n * This works on both attached and detached containers.\n *\n * Strategy: Insert all text first, then apply marks. This avoids mark inheritance\n * issues when inserting at the boundary of a marked region.\n */\nexport function applyDeltaToLoroText(text: LoroText, deltas: Delta<string>[]): void {\n  // Phase 1: Insert all text content\n  let position = 0\n  const markOperations: Array<{\n    start: number\n    end: number\n    attributes: Record<string, unknown>\n  }> = []\n\n  for (const delta of deltas) {\n    if (delta.insert !== undefined) {\n      const content = delta.insert\n      text.insert(position, content)\n\n      // Collect mark operations to apply later\n      if (delta.attributes && Object.keys(delta.attributes).length > 0) {\n        markOperations.push({\n          start: position,\n          end: position + content.length,\n          attributes: delta.attributes,\n        })\n      }\n\n      position += content.length\n    } else if (delta.retain) {\n      position += delta.retain\n    } else if (delta.delete) {\n      text.delete(position, delta.delete)\n    }\n  }\n\n  // Phase 2: Apply all marks after text is inserted\n  for (const op of markOperations) {\n    for (const [key, value] of Object.entries(op.attributes)) {\n      text.mark({ start: op.start, end: op.end }, key, value)\n    }\n  }\n}\n\n/**\n * Converts a plain value to a Loro data structure.\n * Objects are converted to LoroMaps, arrays to LoroMovableLists, primitives are untouched.\n * Frozen values are a special case and they are kept as immutable plain values.\n */\nexport function convertJsonToLoroData(v: PlainValue): LoroValue {\n  if (isPlainPrimitive(v)) {\n    return v\n  }\n\n  if (isPlainArray(v)) {\n    const list = new LoroMovableList()\n    applyJsonArrayToLoroMovableList(list, v)\n    return list\n  }\n\n  if (isPlainObject(v)) {\n    if (v[frozenKey] === true) {\n      // frozen value with explicit $frozen marker (shouldn't reach here after above check)\n      return v\n    }\n\n    if (isLoroTextModelSnapshot(v)) {\n      const text = new LoroText()\n      // Extract delta from the snapshot and apply using insert/mark APIs\n      // (applyDelta doesn't work on detached containers, but insert/mark do)\n      const deltas = extractTextDeltaFromSnapshot(v.deltaList)\n      if (deltas.length > 0) {\n        applyDeltaToLoroText(text, deltas)\n      }\n      return text\n    }\n\n    const map = new LoroMap()\n    applyJsonObjectToLoroMap(map, v)\n    return map\n  }\n\n  throw new Error(`unsupported value type: ${v}`)\n}\n\n/**\n * Applies a JSON array to a LoroMovableList, using convertJsonToLoroData to convert the values.\n *\n * @param dest The destination LoroMovableList.\n * @param source The source JSON array.\n * @param options Options for applying the JSON data.\n */\nexport const applyJsonArrayToLoroMovableList = (\n  dest: LoroMovableList,\n  source: PlainArray,\n  options: ApplyJsonToLoroOptions = {}\n) => {\n  const { mode = \"add\" } = options\n\n  if (mode === \"add\") {\n    // Add mode: just push all items to the end\n    for (const item of source) {\n      const converted = convertJsonToLoroData(item)\n      if (isBindableLoroContainer(converted)) {\n        dest.pushContainer(converted)\n      } else {\n        dest.push(converted)\n      }\n    }\n    return\n  }\n\n  // Merge mode: recursively merge values, preserving existing container references\n  // In merge mode, check if the container is already up-to-date with this snapshot\n  if (isLoroContainerUpToDate(dest, source)) {\n    return\n  }\n\n  // Remove extra items from the end\n  const destLen = dest.length\n  const srcLen = source.length\n  if (destLen > srcLen) {\n    dest.delete(srcLen, destLen - srcLen)\n  }\n\n  // Update existing items\n  const minLen = Math.min(destLen, srcLen)\n  for (let i = 0; i < minLen; i++) {\n    const srcItem = source[i]\n    const destItem = dest.get(i)\n\n    // If both are objects, merge recursively\n    if (isPlainObject(srcItem) && destItem instanceof LoroMap) {\n      applyJsonObjectToLoroMap(destItem, srcItem, options)\n      continue\n    }\n\n    // If both are arrays, merge recursively\n    if (isPlainArray(srcItem) && destItem instanceof LoroMovableList) {\n      applyJsonArrayToLoroMovableList(destItem, srcItem, options)\n      continue\n    }\n\n    // Skip if primitive value is unchanged (optimization)\n    if (isPlainPrimitive(srcItem) && destItem === srcItem) {\n      continue\n    }\n\n    // Otherwise, replace the item\n    dest.delete(i, 1)\n    const converted = convertJsonToLoroData(srcItem)\n    if (isBindableLoroContainer(converted)) {\n      dest.insertContainer(i, converted)\n    } else {\n      dest.insert(i, converted)\n    }\n  }\n\n  // Add new items at the end\n  for (let i = destLen; i < srcLen; i++) {\n    const converted = convertJsonToLoroData(source[i])\n    if (isBindableLoroContainer(converted)) {\n      dest.pushContainer(converted)\n    } else {\n      dest.push(converted)\n    }\n  }\n\n  // Update snapshot tracking after successful merge\n  setLoroContainerSnapshot(dest, source)\n}\n\n/**\n * Applies a JSON object to a LoroMap, using convertJsonToLoroData to convert the values.\n *\n * @param dest The destination LoroMap.\n * @param source The source JSON object.\n * @param options Options for applying the JSON data.\n */\nexport const applyJsonObjectToLoroMap = (\n  dest: LoroMap,\n  source: PlainObject,\n  options: ApplyJsonToLoroOptions = {}\n) => {\n  const { mode = \"add\" } = options\n\n  if (mode === \"add\") {\n    // Add mode: just set all values\n    for (const k of Object.keys(source)) {\n      const v = source[k]\n      if (v !== undefined) {\n        const converted = convertJsonToLoroData(v)\n        if (isBindableLoroContainer(converted)) {\n          dest.setContainer(k, converted)\n        } else {\n          dest.set(k, converted)\n        }\n      }\n    }\n    return\n  }\n\n  // Merge mode: recursively merge values, preserving existing container references\n  // In merge mode, check if the container is already up-to-date with this snapshot\n  if (isLoroContainerUpToDate(dest, source)) {\n    return\n  }\n\n  // Delete keys that are not present in source (or have undefined value)\n  const sourceKeysWithValues = new Set(Object.keys(source).filter((k) => source[k] !== undefined))\n  for (const key of dest.keys()) {\n    if (!sourceKeysWithValues.has(key)) {\n      dest.delete(key)\n    }\n  }\n\n  for (const k of Object.keys(source)) {\n    const v = source[k]\n    // Skip undefined values - Loro maps cannot store undefined\n    if (v === undefined) {\n      continue\n    }\n\n    const existing = dest.get(k)\n\n    // If source is an object and dest has a LoroMap, merge recursively\n    if (isPlainObject(v) && existing instanceof LoroMap) {\n      applyJsonObjectToLoroMap(existing, v, options)\n      continue\n    }\n\n    // If source is an array and dest has a LoroMovableList, merge recursively\n    if (isPlainArray(v) && existing instanceof LoroMovableList) {\n      applyJsonArrayToLoroMovableList(existing, v, options)\n      continue\n    }\n\n    // Skip if primitive value is unchanged (optimization)\n    if (isPlainPrimitive(v) && existing === v) {\n      continue\n    }\n\n    // Otherwise, convert and set the value (this creates new containers if needed)\n    const converted = convertJsonToLoroData(v)\n    if (isBindableLoroContainer(converted)) {\n      dest.setContainer(k, converted)\n    } else {\n      dest.set(k, converted)\n    }\n  }\n\n  // Update snapshot tracking after successful merge\n  setLoroContainerSnapshot(dest, source)\n}\n","import { LoroMap, LoroMovableList, LoroText } from \"loro-crdt\"\nimport { DeepChange, DeepChangeType } from \"mobx-keystone\"\nimport type { PlainValue } from \"../plainTypes\"\nimport { failure } from \"../utils/error\"\nimport type { BindableLoroContainer } from \"../utils/isBindableLoroContainer\"\nimport {\n  applyDeltaToLoroText,\n  convertJsonToLoroData,\n  extractTextDeltaFromSnapshot,\n} from \"./convertJsonToLoroData\"\nimport { isLoroTextModelSnapshot } from \"./LoroTextModel\"\nimport type { ArrayMoveChange } from \"./moveWithinArray\"\nimport { resolveLoroPath } from \"./resolveLoroPath\"\n\n/**\n * Converts a snapshot value to a Loro-compatible value.\n * Note: All values passed here are already snapshots (captured at change time).\n */\nfunction convertValue(v: unknown): unknown {\n  // Handle primitives directly\n  if (v === null || v === undefined || typeof v !== \"object\") {\n    return v\n  }\n  // Handle plain arrays - used for empty array init\n  if (Array.isArray(v) && v.length === 0) {\n    return new LoroMovableList()\n  }\n  // Handle LoroTextModel snapshot specially - we need to return it as-is\n  // so the caller can handle creating the LoroText container properly\n  if (isLoroTextModelSnapshot(v)) {\n    return v\n  }\n  // Value is already a snapshot, convert to Loro data\n  return convertJsonToLoroData(v as PlainValue)\n}\n\n/**\n * Inserts a value into a LoroMovableList at the given index.\n */\nfunction insertIntoList(list: LoroMovableList, index: number, value: unknown): void {\n  if (value instanceof LoroMap || value instanceof LoroMovableList || value instanceof LoroText) {\n    list.insertContainer(index, value)\n  } else if (isLoroTextModelSnapshot(value)) {\n    const attachedText = list.insertContainer(index, new LoroText())\n    const deltas = extractTextDeltaFromSnapshot((value as any).deltaList)\n    if (deltas.length > 0) {\n      applyDeltaToLoroText(attachedText, deltas)\n    }\n  } else {\n    list.insert(index, value)\n  }\n}\n\n/**\n * Sets a value in a LoroMap at the given key.\n */\nfunction setInMap(map: LoroMap, key: string, value: unknown): void {\n  if (value === undefined) {\n    map.delete(key)\n  } else if (\n    value instanceof LoroMap ||\n    value instanceof LoroMovableList ||\n    value instanceof LoroText\n  ) {\n    map.setContainer(key, value)\n  } else if (isLoroTextModelSnapshot(value)) {\n    const attachedText = map.setContainer(key, new LoroText())\n    const deltas = extractTextDeltaFromSnapshot((value as any).deltaList)\n    if (deltas.length > 0) {\n      applyDeltaToLoroText(attachedText, deltas)\n    }\n  } else {\n    map.set(key, value)\n  }\n}\n\n/**\n * Applies a MobX DeepChange or an ArrayMoveChange to a Loro object.\n */\nexport function applyMobxChangeToLoroObject(\n  change: DeepChange | ArrayMoveChange,\n  loroObject: BindableLoroContainer\n): void {\n  const loroContainer = resolveLoroPath(loroObject, change.path)\n\n  // If container doesn't exist at this path, throw an error\n  if (!loroContainer) {\n    throw failure(\n      `cannot apply change to missing Loro container at path: ${JSON.stringify(change.path)}`\n    )\n  }\n\n  switch (change.type) {\n    case \"ArrayMove\": {\n      if (!(loroContainer instanceof LoroMovableList)) {\n        throw failure(`ArrayMove change requires a LoroMovableList container`)\n      }\n      loroContainer.move(change.fromIndex, change.toIndex)\n      break\n    }\n\n    case DeepChangeType.ArraySplice: {\n      if (!(loroContainer instanceof LoroMovableList)) {\n        throw failure(`ArraySplice change requires a LoroMovableList container`)\n      }\n      if (change.removedValues.length > 0) {\n        loroContainer.delete(change.index, change.removedValues.length)\n      }\n      if (change.addedValues.length > 0) {\n        const valuesToInsert = change.addedValues.map(convertValue)\n        for (let i = 0; i < valuesToInsert.length; i++) {\n          insertIntoList(loroContainer, change.index + i, valuesToInsert[i])\n        }\n      }\n      break\n    }\n\n    case DeepChangeType.ArrayUpdate: {\n      if (!(loroContainer instanceof LoroMovableList)) {\n        throw failure(`ArrayUpdate change requires a LoroMovableList container`)\n      }\n      const converted = convertValue(change.newValue)\n      if (\n        converted instanceof LoroMap ||\n        converted instanceof LoroMovableList ||\n        converted instanceof LoroText\n      ) {\n        loroContainer.setContainer(change.index, converted)\n      } else if (isLoroTextModelSnapshot(converted)) {\n        const attachedText = loroContainer.setContainer(change.index, new LoroText())\n        const deltas = extractTextDeltaFromSnapshot((converted as any).deltaList)\n        if (deltas.length > 0) {\n          applyDeltaToLoroText(attachedText, deltas)\n        }\n      } else {\n        loroContainer.set(change.index, converted)\n      }\n      break\n    }\n\n    case DeepChangeType.ObjectAdd:\n    case DeepChangeType.ObjectUpdate: {\n      if (loroContainer instanceof LoroText) {\n        // Handle changes to LoroText properties (mainly deltaList)\n        if (change.key === \"deltaList\") {\n          // change.newValue is already a snapshot (captured at change time)\n          const deltas = extractTextDeltaFromSnapshot(change.newValue)\n          if (loroContainer.length > 0) {\n            loroContainer.delete(0, loroContainer.length)\n          }\n          if (deltas.length > 0) {\n            applyDeltaToLoroText(loroContainer, deltas)\n          }\n        }\n        // ignore other property changes on LoroText as they're not synced\n      } else if (loroContainer instanceof LoroMap) {\n        const converted = convertValue(change.newValue)\n        setInMap(loroContainer, change.key, converted)\n      } else {\n        throw failure(`ObjectAdd/ObjectUpdate change requires a LoroMap or LoroText container`)\n      }\n      break\n    }\n\n    case DeepChangeType.ObjectRemove: {\n      if (loroContainer instanceof LoroText) {\n        // ignore removes on LoroText properties\n      } else if (loroContainer instanceof LoroMap) {\n        loroContainer.delete(change.key)\n      } else {\n        throw failure(`ObjectRemove change requires a LoroMap or LoroText container`)\n      }\n      break\n    }\n\n    default: {\n      // Exhaustive check - TypeScript will error if we miss a case\n      const _exhaustiveCheck: never = change\n      throw failure(`unsupported change type: ${(_exhaustiveCheck as any).type}`)\n    }\n  }\n}\n","import { DeepChange } from \"mobx-keystone\"\n\n/**\n * Synthetic change type for array moves.\n */\nexport interface ArrayMoveChange {\n  type: \"ArrayMove\"\n  path: readonly (string | number)[]\n  fromIndex: number\n  toIndex: number\n}\n\n/**\n * Tracks the currently active move operation.\n * When set, the next two splice operations on this array are intercepted.\n */\nlet activeMoveContext:\n  | {\n      array: unknown[]\n      fromIndex: number\n      toIndex: number\n      path: readonly (string | number)[] | undefined // Captured from first splice\n      receivedFirstSplice: boolean\n    }\n  | undefined\n\n/**\n * Moves an item within an array from one index to another.\n *\n * When used on a mobx-keystone array bound to a Loro movable list,\n * this translates to a native Loro move operation for optimal CRDT merging.\n *\n * For unbound arrays, performs a standard splice-based move.\n *\n * @param array The array to move within\n * @param fromIndex The index of the item to move\n * @param toIndex The target index to move the item to\n */\nexport function moveWithinArray<T>(array: T[], fromIndex: number, toIndex: number): void {\n  // Validate indices\n  if (fromIndex < 0 || fromIndex >= array.length) {\n    throw new Error(`fromIndex ${fromIndex} is out of bounds (array length: ${array.length})`)\n  }\n  if (toIndex < 0 || toIndex > array.length) {\n    throw new Error(`toIndex ${toIndex} is out of bounds (array length: ${array.length})`)\n  }\n  if (fromIndex === toIndex) {\n    return // No-op\n  }\n\n  // Set up the move context before mutations\n  activeMoveContext = {\n    array,\n    fromIndex,\n    toIndex,\n    path: undefined,\n    receivedFirstSplice: false,\n  }\n\n  try {\n    // Perform the actual splice operations\n    // This will trigger onDeepChange for each splice\n    const [item] = array.splice(fromIndex, 1)\n    const adjustedTarget = toIndex > fromIndex ? toIndex - 1 : toIndex\n    array.splice(adjustedTarget, 0, item)\n  } finally {\n    activeMoveContext = undefined\n  }\n}\n\n/**\n * Check if a change is part of an active move operation and process it.\n * This is called for ArraySplice changes on the target array.\n *\n * @param change The deep change (must be ArraySplice type)\n * @returns The ArrayMoveChange if the move is complete (second splice),\n *          undefined if intercepted but not complete (first splice)\n */\nexport function processChangeForMove(change: DeepChange): ArrayMoveChange | undefined {\n  // We know we're in a move context and this is an ArraySplice on the target array\n  const ctx = activeMoveContext!\n\n  if (!ctx.receivedFirstSplice) {\n    // First splice - capture the path and mark as received\n    ctx.path = change.path\n    ctx.receivedFirstSplice = true\n    return undefined\n  }\n\n  // Second splice - the move is complete.\n  // Note: We adjust toIndex here for Loro's move() semantics, which expects\n  // the target position after removal. This is intentionally separate from\n  // the adjustment on line 64, which is for the splice operation on the MobX array.\n  // Both adjustments are needed because:\n  // - Line 64: splice() inserts at a position in the already-shortened array\n  // - Here: Loro's move(from, to) also expects `to` as the position after removal\n  const adjustedToIndex = ctx.toIndex > ctx.fromIndex ? ctx.toIndex - 1 : ctx.toIndex\n\n  return {\n    type: \"ArrayMove\",\n    path: ctx.path!,\n    fromIndex: ctx.fromIndex,\n    toIndex: adjustedToIndex,\n  }\n}\n\n/**\n * Check if we're currently in a move context for a specific array.\n */\nexport function isInMoveContextForArray(array: unknown[]): boolean {\n  return activeMoveContext !== undefined && activeMoveContext.array === array\n}\n","import {\n  type ContainerID,\n  type LoroDoc,\n  type LoroEventBatch,\n  LoroMap,\n  LoroMovableList,\n  LoroText,\n} from \"loro-crdt\"\nimport { action } from \"mobx\"\nimport {\n  AnyDataModel,\n  AnyModel,\n  AnyStandardType,\n  DeepChange,\n  DeepChangeType,\n  fromSnapshot,\n  getParentToChildPath,\n  getSnapshot,\n  isTreeNode,\n  ModelClass,\n  onDeepChange,\n  onGlobalDeepChange,\n  onSnapshot,\n  resolvePath,\n  SnapshotOutOf,\n  TypeToData,\n} from \"mobx-keystone\"\nimport { nanoid } from \"nanoid\"\nimport type { PlainArray, PlainObject } from \"../plainTypes\"\nimport { getOrCreateLoroCollectionAtom } from \"../utils/getOrCreateLoroCollectionAtom\"\nimport type { BindableLoroContainer } from \"../utils/isBindableLoroContainer\"\n\nimport { applyLoroEventToMobx, ReconciliationMap } from \"./applyLoroEventToMobx\"\nimport { applyMobxChangeToLoroObject } from \"./applyMobxChangeToLoroObject\"\nimport {\n  applyDeltaToLoroText,\n  applyJsonArrayToLoroMovableList,\n  applyJsonObjectToLoroMap,\n  extractTextDeltaFromSnapshot,\n} from \"./convertJsonToLoroData\"\nimport { convertLoroDataToJson } from \"./convertLoroDataToJson\"\nimport { loroTextModelId } from \"./LoroTextModel\"\nimport { type LoroBindingContext, loroBindingContext } from \"./loroBindingContext\"\nimport { setLoroContainerSnapshot } from \"./loroSnapshotTracking\"\nimport {\n  type ArrayMoveChange,\n  isInMoveContextForArray,\n  processChangeForMove,\n} from \"./moveWithinArray\"\n\n/**\n * Captures snapshots of tree nodes in a DeepChange.\n * This ensures values are captured at change time, not at apply time,\n * preventing issues when values are mutated after being added to a collection.\n */\nfunction captureChangeSnapshots(change: DeepChange): DeepChange {\n  if (change.type === DeepChangeType.ArraySplice && change.addedValues.length > 0) {\n    const snapshots = change.addedValues.map((v) => (isTreeNode(v) ? getSnapshot(v) : v))\n    return { ...change, addedValues: snapshots }\n  } else if (change.type === DeepChangeType.ArrayUpdate) {\n    const snapshot = isTreeNode(change.newValue) ? getSnapshot(change.newValue) : change.newValue\n    return { ...change, newValue: snapshot }\n  } else if (\n    change.type === DeepChangeType.ObjectAdd ||\n    change.type === DeepChangeType.ObjectUpdate\n  ) {\n    const snapshot = isTreeNode(change.newValue) ? getSnapshot(change.newValue) : change.newValue\n    return { ...change, newValue: snapshot }\n  }\n  return change\n}\n\n/**\n * Creates a bidirectional binding between a Loro data structure and a mobx-keystone model.\n */\nexport function bindLoroToMobxKeystone<\n  TType extends AnyStandardType | ModelClass<AnyModel> | ModelClass<AnyDataModel>,\n>({\n  loroDoc,\n  loroObject,\n  mobxKeystoneType,\n}: {\n  /**\n   * The Loro document.\n   */\n  loroDoc: LoroDoc\n  /**\n   * The bound Loro data structure.\n   */\n  loroObject: BindableLoroContainer\n  /**\n   * The mobx-keystone model type.\n   */\n  mobxKeystoneType: TType\n}): {\n  /**\n   * The bound mobx-keystone instance.\n   */\n  boundObject: TypeToData<TType>\n  /**\n   * Disposes the binding.\n   */\n  dispose: () => void\n  /**\n   * The Loro origin string used for binding transactions.\n   */\n  loroOrigin: string\n} {\n  const loroOrigin = `bindLoroToMobxKeystoneTransactionOrigin-${nanoid()}`\n\n  let applyingLoroChangesToMobxKeystone = 0\n\n  const bindingContext: LoroBindingContext = {\n    loroDoc,\n    loroObject,\n    mobxKeystoneType,\n    loroOrigin,\n    boundObject: undefined, // not yet created\n\n    get isApplyingLoroChangesToMobxKeystone() {\n      return applyingLoroChangesToMobxKeystone > 0\n    },\n  }\n\n  const loroJson = convertLoroDataToJson(loroObject) as SnapshotOutOf<TypeToData<TType>>\n\n  let boundObject: TypeToData<TType>\n\n  // Track if any init changes occurred during fromSnapshot\n  // If they did, we need to sync the model snapshot to the CRDT\n  let hasInitChanges = false\n\n  const createBoundObject = () => {\n    // Set up a temporary global listener to detect init changes during fromSnapshot\n    const disposeGlobalListener = onGlobalDeepChange((_target, change) => {\n      if (change.isInit) {\n        hasInitChanges = true\n      }\n    })\n\n    try {\n      const result = loroBindingContext.apply(\n        () => fromSnapshot(mobxKeystoneType, loroJson),\n        bindingContext\n      )\n      loroBindingContext.set(result, { ...bindingContext, boundObject: result })\n      return result\n    } finally {\n      disposeGlobalListener()\n    }\n  }\n\n  boundObject = createBoundObject()\n\n  // Get the path to the root Loro object for path resolution\n  const rootLoroPath = loroDoc.getPathToContainer(loroObject.id) ?? []\n\n  // bind any changes from Loro to mobx-keystone\n  const loroSubscribeCb = action((eventBatch: LoroEventBatch) => {\n    // Skip changes that originated from this binding\n    if (eventBatch.origin === loroOrigin) {\n      return\n    }\n\n    // Track newly inserted containers to avoid double-processing their events\n    const newlyInsertedContainers = new Set<ContainerID>()\n\n    // Create a map to store reconciliation data for this batch\n    const reconciliationMap: ReconciliationMap = new Map()\n\n    // Collect init changes that occur during event application\n    // (e.g., fromSnapshot calls that trigger onInit hooks)\n    // We store both target and change so we can compute the correct path later\n    // Snapshots are captured immediately to preserve values at init time\n    const initChanges: { target: object; change: DeepChange }[] = []\n    const disposeGlobalListener = onGlobalDeepChange((target, change) => {\n      if (change.isInit) {\n        initChanges.push({ target, change: captureChangeSnapshots(change) })\n      }\n    })\n\n    applyingLoroChangesToMobxKeystone++\n    try {\n      try {\n        for (const event of eventBatch.events) {\n          applyLoroEventToMobx(\n            event,\n            loroDoc,\n            boundObject,\n            rootLoroPath,\n            reconciliationMap,\n            newlyInsertedContainers\n          )\n        }\n      } finally {\n        disposeGlobalListener()\n      }\n\n      // Sync back any init-time mutations from fromSnapshot calls\n      // (e.g., onInit hooks that modify the model)\n      // This is needed because init changes during Loro event handling are not\n      // captured by the main onDeepChange (it skips changes when applyingLoroChangesToMobxKeystone > 0)\n      if (initChanges.length > 0) {\n        loroDoc.setNextCommitOrigin(loroOrigin)\n\n        for (const { target, change } of initChanges) {\n          // Compute the path from boundObject to the target\n          const pathToTarget = getParentToChildPath(boundObject, target)\n          if (pathToTarget !== undefined) {\n            // Create a new change with the correct path from the root\n            const changeWithCorrectPath: DeepChange = {\n              ...change,\n              path: [...pathToTarget, ...change.path],\n            }\n            applyMobxChangeToLoroObject(changeWithCorrectPath, loroObject)\n          }\n        }\n\n        loroDoc.commit()\n      }\n\n      // Update snapshot tracking: the Loro container is now in sync with the current MobX snapshot\n      // This enables the merge optimization to skip unchanged subtrees during reconciliation\n      if (loroObject instanceof LoroMap || loroObject instanceof LoroMovableList) {\n        setLoroContainerSnapshot(loroObject, getSnapshot(boundObject))\n      }\n    } finally {\n      applyingLoroChangesToMobxKeystone--\n    }\n  })\n  const loroUnsubscribe = loroDoc.subscribe(loroSubscribeCb)\n\n  // bind any changes from mobx-keystone to Loro\n  // Collect changes during an action and apply them after the action completes\n  let pendingChanges: (DeepChange | ArrayMoveChange)[] = []\n\n  const disposeOnDeepChange = onDeepChange(boundObject, (change) => {\n    // Skip if we're currently applying Loro changes to MobX\n    if (bindingContext.isApplyingLoroChangesToMobxKeystone) {\n      return\n    }\n\n    // Skip init changes - they are handled by the getSnapshot + merge at the end of binding\n    if (change.isInit) {\n      return\n    }\n\n    // Check if this is part of a moveWithinArray operation\n    if (change.type === DeepChangeType.ArraySplice) {\n      const resolved = resolvePath(boundObject, change.path)\n      if (resolved.resolved && isInMoveContextForArray(resolved.value as unknown[])) {\n        const moveResult = processChangeForMove(change)\n\n        if (moveResult === undefined) {\n          // Intercepted but move not complete - skip this change\n          return\n        }\n\n        // Move complete - add the move change instead\n        pendingChanges.push(moveResult)\n        return\n      }\n    }\n\n    // Capture snapshots now before the values can be mutated within the same transaction.\n    // This is necessary because changes are collected and applied after the action completes,\n    // by which time the original values may have been modified.\n    // Example: `obj.items = [a, b]; obj.items.splice(0, 1)` - without early capture,\n    // the ObjectUpdate for `items` would get the post-splice array state.\n    pendingChanges.push(captureChangeSnapshots(change))\n  })\n\n  // Apply collected changes when snapshot changes (i.e., after action completes)\n  // Also notify that the loro container atoms have been updated\n  const disposeOnSnapshot = onSnapshot(boundObject, () => {\n    if (pendingChanges.length === 0) {\n      return\n    }\n\n    const changesToApply = pendingChanges\n    pendingChanges = []\n\n    // Skip if we're currently applying Loro changes to MobX\n    if (bindingContext.isApplyingLoroChangesToMobxKeystone) {\n      return\n    }\n\n    loroDoc.setNextCommitOrigin(loroOrigin)\n\n    // Apply all changes directly to Loro\n    for (const change of changesToApply) {\n      applyMobxChangeToLoroObject(change, loroObject)\n    }\n\n    loroDoc.commit()\n\n    // Update snapshot tracking: the Loro container is now in sync with the current MobX snapshot\n    if (loroObject instanceof LoroMap || loroObject instanceof LoroMovableList) {\n      setLoroContainerSnapshot(loroObject, getSnapshot(boundObject))\n    }\n\n    // Notify MobX that the Loro container has been updated\n    getOrCreateLoroCollectionAtom(loroObject).reportChanged()\n  })\n\n  // Sync the model snapshot to the CRDT if any init changes occurred.\n  // Init changes include: defaults being applied, onInit hooks mutating the model.\n  // This is an optimization: if no init changes occurred, we skip the sync entirely.\n  const finalSnapshot = getSnapshot(boundObject)\n\n  if (hasInitChanges) {\n    loroDoc.setNextCommitOrigin(loroOrigin)\n\n    if (loroObject instanceof LoroMap) {\n      applyJsonObjectToLoroMap(loroObject, finalSnapshot as PlainObject, { mode: \"merge\" })\n    } else if (loroObject instanceof LoroMovableList) {\n      applyJsonArrayToLoroMovableList(loroObject, finalSnapshot as PlainArray, { mode: \"merge\" })\n    } else if (loroObject instanceof LoroText) {\n      // For LoroText, we need to handle LoroTextModel snapshot\n      const snapshot = finalSnapshot as Record<string, unknown>\n      if (snapshot.$modelType === loroTextModelId) {\n        // Clear existing content and apply deltas\n        if (loroObject.length > 0) {\n          loroObject.delete(0, loroObject.length)\n        }\n        const deltas = extractTextDeltaFromSnapshot(snapshot.deltaList)\n        if (deltas.length > 0) {\n          applyDeltaToLoroText(loroObject, deltas)\n        }\n      }\n    }\n\n    loroDoc.commit()\n  }\n\n  // Always update snapshot tracking after binding initialization\n  // This ensures the merge optimization can skip unchanged subtrees in future reconciliations\n  if (loroObject instanceof LoroMap || loroObject instanceof LoroMovableList) {\n    setLoroContainerSnapshot(loroObject, finalSnapshot)\n  }\n\n  const dispose = () => {\n    loroUnsubscribe()\n    disposeOnDeepChange()\n    disposeOnSnapshot()\n  }\n\n  return {\n    boundObject,\n    dispose,\n    loroOrigin,\n  }\n}\n"],"names":["loroObject","result"],"mappings":";;;;;;AAmBA,IAAI,SAAS,CAAC,OAAO,OACnB,OAAO,gBAAgB,IAAI,WAAW,IAAI,CAAC,EAAE,OAAO,CAAC,IAAI,SAAS;AAChE,UAAQ;AACR,MAAI,OAAO,IAAI;AACb,UAAM,KAAK,SAAS,EAAE;AAAA,EACxB,WAAW,OAAO,IAAI;AACpB,WAAO,OAAO,IAAI,SAAS,EAAE,EAAE,YAAW;AAAA,EAC5C,WAAW,OAAO,IAAI;AACpB,UAAM;AAAA,EACR,OAAO;AACL,UAAM;AAAA,EACR;AACA,SAAO;AACT,GAAG,EAAE;AC7BP,MAAM,8BAAc,QAAA;AAMb,SAAS,8BAA8B,YAA0C;AACtF,MAAI,OAAO,QAAQ,IAAI,UAAU;AACjC,MAAI,CAAC,MAAM;AACT,WAAO,WAAW,oBAAoB;AACtC,YAAQ,IAAI,YAAY,IAAI;AAAA,EAC9B;AACA,SAAO;AACT;AChBO,MAAM,8BAA8B,MAAM;AAAA,EAC/C,YAAY,KAAa;AACvB,UAAM,GAAG;AAGT,WAAO,eAAe,MAAM,sBAAsB,SAAS;AAAA,EAC7D;AACF;AAEO,SAAS,QAAQ,SAAwB;AAC9C,QAAM,IAAI,sBAAsB,OAAO;AACzC;ACkCO,MAAM,qBAAqB,cAA8C,MAAS;AC/BlF,SAAS,gBAAgB,YAAmC,MAAqB;AACtF,MAAI,oBAA6B;AAEjC,OAAK,QAAQ,CAAC,UAAU,MAAM;AAC5B,QAAI,6BAA6B,SAAS;AACxC,oCAA8B,iBAAiB,EAAE,eAAA;AACjD,YAAM,MAAM,OAAO,QAAQ;AAC3B,0BAAoB,kBAAkB,IAAI,GAAG;AAAA,IAC/C,WAAW,6BAA6B,iBAAiB;AACvD,oCAA8B,iBAAiB,EAAE,eAAA;AACjD,YAAM,MAAM,OAAO,QAAQ;AAC3B,0BAAoB,kBAAkB,IAAI,GAAG;AAAA,IAC/C,OAAO;AACL,YAAM;AAAA,QACJ,mDAAmD,KAAK;AAAA,UACtD,KAAK,MAAM,GAAG,CAAC;AAAA,QAAA,CAChB,6BAA6B,KAAK,UAAU,IAAI,CAAC,aAAa,iBAAiB;AAAA,MAAA;AAAA,IAEpF;AAAA,EACF,CAAC;AAED,SAAO;AACT;;;;;;;;;;;ACnBO,MAAM,kBAAkB;AAaxB,IAAM,gBAAN,cAA4B,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA,EAKvC,WAAW,MAAM,MAAM,OAAO,MAAM,WAA8B,GAAG,MAAM,OAAO,EAAE,CAAC;AACvF,CAAC,EAAE;AAAA,EANI;AAAA;AA4BL;AAAA;AAAA;AAAA,+CAAsB,WAAW,qBAAqB;AAAA;AAAA;AAAA;AAAA;AAAA,EAlBtD,OAAO,SAAS,MAA6B;AAC3C,WAAO,IAAI,cAAc;AAAA,MACvB,WAAW,OAAO,CAAC,EAAE,QAAQ,KAAA,CAAM,CAAC;AAAA,IAAA,CACrC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA,EAKA,OAAO,UAAU,OAAyC;AACxD,WAAO,IAAI,cAAc;AAAA,MACvB,WAAW,OAAO,KAAK;AAAA,IAAA,CACxB;AAAA,EACH;AAAA,EAYA,IAAI,WAAiC;AAEnC,UAAM,MAAM,mBAAmB,IAAI,IAAI;AACvC,SAAI,2BAAK,gBAAe,MAAM;AAC5B,aAAO;AAAA,IACT;AAEA,QAAI;AACF,YAAM,OAAO,qBAAqB,IAAI,aAAa,IAAI;AACvD,UAAI,CAAC,MAAM;AACT,eAAO;AAAA,MACT;AAGA,UAAI,KAAK,WAAW,GAAG;AACrB,cAAMA,cAAa,IAAI;AACvB,YAAIA,uBAAsB,UAAU;AAClC,wCAA8BA,WAAU,EAAE,eAAA;AAC1C,iBAAOA;AAAAA,QACT;AACA,eAAO;AAAA,MACT;AAGA,YAAM,aAAa,gBAAgB,IAAI,YAAY,IAAI;AAEvD,UAAI,sBAAsB,UAAU;AAClC,sCAA8B,UAAU,EAAE,eAAA;AAC1C,eAAO;AAAA,MACT;AAAA,IACF,QAAQ;AAAA,IAER;AAEA,WAAO;AAAA,EACT;AAAA,EAOA,IAAI,OAAe;AACjB,SAAK,oBAAoB,eAAA;AAIzB,WAAO,KAAK,YAAY,KAAK,UAAU,IAAI;AAAA,EAC7C;AAAA,EAMA,IAAI,eAAkC;AACpC,SAAK,oBAAoB,eAAA;AAGzB,UAAM,WAAW,KAAK;AACtB,QAAI,UAAU;AACZ,UAAI;AACF,eAAO,SAAS,QAAA;AAAA,MAClB,QAAQ;AAAA,MAER;AAAA,IACF;AAEA,WAAO,KAAK,UAAU;AAAA,EACxB;AAAA;AAAA;AAAA;AAAA,EAKQ,YAAY,OAAkC;AACpD,QAAI,SAAS;AACb,eAAW,MAAM,OAAO;AACtB,UAAI,YAAY,MAAM,OAAO,GAAG,WAAW,UAAU;AACnD,kBAAU,GAAG;AAAA,MACf;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAAA,EAMA,SAAS,OAAgC;AACvC,SAAK,YAAY,OAAO,KAAK;AAAA,EAC/B;AAAA,EAMA,WAAW,OAAe,MAAoB;AAC5C,UAAM,WAAW,KAAK;AACtB,QAAI,UAAU;AACZ,eAAS,OAAO,OAAO,IAAI;AAAA,IAE7B,OAAO;AAEL,YAAM,cAAc,KAAK;AACzB,YAAM,UAAU,YAAY,MAAM,GAAG,KAAK,IAAI,OAAO,YAAY,MAAM,KAAK;AAC5E,WAAK,YAAY,OAAO,CAAC,EAAE,QAAQ,QAAA,CAAS,CAAC;AAAA,IAC/C;AAAA,EACF;AAAA,EAMA,WAAW,OAAe,QAAsB;AAC9C,UAAM,WAAW,KAAK;AACtB,QAAI,UAAU;AACZ,eAAS,OAAO,OAAO,MAAM;AAAA,IAE/B,OAAO;AAEL,YAAM,cAAc,KAAK;AACzB,YAAM,UAAU,YAAY,MAAM,GAAG,KAAK,IAAI,YAAY,MAAM,QAAQ,MAAM;AAC9E,WAAK,YAAY,OAAO,CAAC,EAAE,QAAQ,QAAA,CAAS,CAAC;AAAA,IAC/C;AAAA,EACF;AAAA,EAOA,qBAAqB,OAAgC;AACnD,SAAK,YAAY,OAAO,KAAK;AAAA,EAC/B;AACF;AArIM,gBAAA;AAAA,EADH;AAAA,GAlCU,cAmCP,WAAA,YAAA,CAAA;AA0CA,gBAAA;AAAA,EADH;AAAA,GA5EU,cA6EP,WAAA,QAAA,CAAA;AAYA,gBAAA;AAAA,EADH;AAAA,GAxFU,cAyFP,WAAA,gBAAA,CAAA;AAiCJ,gBAAA;AAAA,EADC;AAAA,GAzHU,cA0HX,WAAA,YAAA,CAAA;AAQA,gBAAA;AAAA,EADC;AAAA,GAjIU,cAkIX,WAAA,cAAA,CAAA;AAiBA,gBAAA;AAAA,EADC;AAAA,GAlJU,cAmJX,WAAA,cAAA,CAAA;AAkBA,gBAAA;AAAA,EADC;AAAA,GApKU,cAqKX,WAAA,wBAAA,CAAA;AArKW,gBAAN,gBAAA;AAAA,EADN,MAAM,eAAe;AAAA,GACT,aAAA;AA6KN,MAAM,oBAAoB,MAAM,MAAM,aAAa;AAKnD,SAAS,wBAAwB,OAAuD;AAC7F,SAAO,qBAAqB,KAAK,MAAM;AACzC;ACnMO,SAAS,sBAAsB,OAA8B;AAClE,MAAI,UAAU,MAAM;AAClB,WAAO;AAAA,EACT;AAEA,MAAI,OAAO,UAAU,UAAU;AAC7B,QAAI,UAAU,QAAW;AACvB,YAAM,IAAI,MAAM,4CAA4C;AAAA,IAC9D;AAEA,WAAO;AAAA,EACT;AAEA,MAAI,YAAY,KAAK,GAAG;AACtB,QAAI,iBAAiB,SAAS;AAC5B,YAAMC,UAAqC,CAAA;AAC3C,iBAAW,CAAC,GAAG,CAAC,KAAK,MAAM,WAAW;AACpCA,gBAAO,CAAC,IAAI,sBAAsB,CAAc;AAAA,MAClD;AACA,aAAOA;AAAAA,IACT;AAEA,QAAI,iBAAiB,iBAAiB;AACpC,YAAMA,UAAuB,CAAA;AAC7B,eAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACrCA,gBAAO,KAAK,sBAAsB,MAAM,IAAI,CAAC,CAAc,CAAC;AAAA,MAC9D;AACA,aAAOA;AAAAA,IACT;AAEA,QAAI,iBAAiB,UAAU;AAC7B,YAAM,SAAS,MAAM,QAAA;AAErB,aAAO,6BAA6B,eAAe;AAAA,QACjD,WAAW,iBAAiB,MAAM;AAAA,MAAA,CACnC;AAAA,IACH;AAEA,UAAM,QAAQ,0CAA0C;AAAA,EAC1D;AAGA,MAAI,MAAM,QAAQ,KAAK,GAAG;AACxB,WAAO,MAAM,IAAI,CAAC,SAAS,sBAAsB,IAAiB,CAAC;AAAA,EACrE;AAEA,QAAM,SAAqC,CAAA;AAC3C,aAAW,CAAC,GAAG,CAAC,KAAK,OAAO,QAAQ,KAAK,GAAG;AAC1C,WAAO,CAAC,IAAI,sBAAsB,CAAc;AAAA,EAClD;AAEA,SAAO;AACT;ACvCO,SAAS,qBACd,OACA,SACA,aACA,UACA,mBACA,yBACM;AAGN,MAAI,wBAAwB,IAAI,MAAM,MAAM,GAAG;AAC7C;AAAA,EACF;AAGA,QAAM,YAAY,QAAQ,mBAAmB,MAAM,MAAM;AACzD,MAAI,CAAC,WAAW;AACd;AAAA,EACF;AAGA,QAAM,eAAe,iBAAiB,WAAW,QAAQ;AACzD,MAAI,iBAAiB,QAAW;AAC9B;AAAA,EACF;AAEA,QAAM,EAAE,OAAO,OAAA,IAAW,YAAY,aAAa,YAAY;AAE/D,MAAI,CAAC,QAAQ;AACX,UAAM,QAAQ,uBAAuB,KAAK,UAAU,YAAY,CAAC,EAAE;AAAA,EACrE;AAGA,iBAAe,MAAM;AACnB,UAAM,OAAO,MAAM;AACnB,QAAI,KAAK,SAAS,OAAO;AACvB,0BAAoB,MAAM,SAAS,MAAM,QAAQ,QAAQ,iBAAiB;AAAA,IAC5E,WAAW,KAAK,SAAS,QAAQ;AAC/B;AAAA,QACE;AAAA,QACA;AAAA,QACA,MAAM;AAAA,QACN;AAAA,QACA;AAAA,QACA;AAAA,MAAA;AAAA,IAEJ,WAAW,KAAK,SAAS,QAAQ;AAC/B,2BAAqB,SAAS,MAAM,QAAQ,MAAM;AAAA,IACpD;AAAA,EACF,CAAC;AACH;AAEA,SAAS,oBAAoB,KAAc,mBAAsC;AAE/E,MAAI,QAAQ,GAAG,KAAK,YAAY,GAAG,GAAG;AACpC,UAAM,KAAK,cAAc,MAAM,IAAI,UAAU,IAAI;AACjD,QAAI,IAAI;AACN,wBAAkB,IAAI,IAAI,GAAG;AAAA,IAC/B;AAAA,EACF;AACF;AAEA,SAAS,YAAY,WAAoB,mBAA+C;AAEtF,MAAI,cAAc,QAAQ,OAAO,cAAc,UAAU;AACvD,WAAO;AAAA,EACT;AAGA,MAAI,iBAAiB,SAAS,GAAG;AAC/B,WAAO,OAAO,UAAU,IAAI;AAAA,EAC9B;AAGA,MAAI,mBAAmB;AACrB,UAAM,UAAU,mBAAmB,SAAS;AAC5C,QAAI,SAAS;AACX,YAAM,WAAW,kBAAkB,IAAI,OAAO;AAC9C,UAAI,UAAU;AACZ,0BAAkB,OAAO,OAAO;AAChC,eAAO;AAAA,MACT;AAAA,IACF;AAAA,EACF;AAEA,SAAO,aAAa,SAAS;AAC/B;AAEA,SAAS,oBACP,MACA,SACA,iBACA,QACA,mBACM;AACN,QAAM,YAAY,QAAQ,iBAAiB,eAAe;AAE1D,MAAI,CAAC,aAAa,EAAE,qBAAqB,UAAU;AACjD,UAAM,QAAQ,GAAG,eAAe,qBAAqB;AAAA,EACvD;AAGA,aAAW,OAAO,OAAO,KAAK,KAAK,OAAO,GAAG;AAC3C,UAAM,YAAY,UAAU,IAAI,GAAG;AAEnC,QAAI,cAAc,QAAW;AAE3B,UAAI,OAAO,QAAQ;AACjB,4BAAoB,OAAO,GAAG,GAAG,iBAAiB;AAElD,YAAI,QAAQ,MAAM,GAAG;AACnB,iBAAO,OAAO,GAAG,GAAG;AAAA,QACtB,OAAO;AACL,iBAAO,QAAQ,GAAG;AAAA,QACpB;AAAA,MACF;AAAA,IACF,OAAO;AAEL,UAAI,OAAO,QAAQ;AACjB,4BAAoB,OAAO,GAAG,GAAG,iBAAiB;AAAA,MACpD;AACA,YAAM,YAAY,sBAAsB,SAAuB;AAC/D,aAAO,GAAG,IAAI,YAAY,WAAW,iBAAiB;AAAA,IACxD;AAAA,EACF;AACF;AAEA,SAAS,qBACP,MACA,SACA,iBACA,QACA,mBACA,yBACM;AACN,QAAM,YAAY,QAAQ,iBAAiB,eAAe;AAE1D,MAAI,CAAC,aAAa,EAAE,qBAAqB,kBAAkB;AACzD,UAAM,QAAQ,GAAG,eAAe,8BAA8B;AAAA,EAChE;AAGA,MAAI,eAAe;AAEnB,aAAW,UAAU,KAAK,MAAM;AAC9B,QAAI,OAAO,QAAQ;AACjB,sBAAgB,OAAO;AAAA,IACzB;AAEA,QAAI,OAAO,QAAQ;AAEjB,YAAM,eAAe,OAAO,MAAM,cAAc,eAAe,OAAO,MAAM;AAC5E,mBAAa,QAAQ,CAAC,SAAS;AAC7B,4BAAoB,MAAM,iBAAiB;AAAA,MAC7C,CAAC;AAGD,aAAO,OAAO,cAAc,OAAO,MAAM;AAAA,IAC3C;AAEA,QAAI,OAAO,QAAQ;AAEjB,YAAM,gBAAgB,OAAO;AAC7B,YAAM,SAAS,cAAc,IAAI,CAAC,cAAc;AAK9C,YAAI,YAAY,SAAS,GAAG;AAC1B,kCAAwB,IAAI,UAAU,EAAE;AAExC,oCAA0B,WAAW,uBAAuB;AAAA,QAC9D;AACA,cAAM,YAAY,sBAAsB,SAAuB;AAC/D,eAAO,YAAY,WAAW,iBAAiB;AAAA,MACjD,CAAC;AAED,aAAO,OAAO,cAAc,GAAG,GAAG,MAAM;AACxC,sBAAgB,OAAO;AAAA,IACzB;AAAA,EACF;AACF;AAEA,SAAS,qBACP,SACA,iBACA,QACM;AACN,QAAM,YAAY,QAAQ,iBAAiB,eAAe;AAE1D,MAAI,CAAC,aAAa,EAAE,qBAAqB,WAAW;AAClD,UAAM,QAAQ,GAAG,eAAe,gCAAgC;AAAA,EAClE;AAIA,MAAI,EAAE,eAAe,SAAS;AAC5B,UAAM,QAAQ,oEAAoE;AAAA,EACpF;AACA,SAAO,YAAY,OAAO,UAAU,QAAA,CAAS;AAC/C;AAQA,SAAS,0BAA0B,WAAoB,cAAsC;AAC3F,MAAI,CAAC,YAAY,SAAS,GAAG;AAC3B;AAAA,EACF;AAGA,eAAa,IAAI,UAAU,EAAE;AAG7B,MAAI,qBAAqB,SAAS;AAChC,eAAW,OAAO,OAAO,KAAK,UAAU,OAAA,CAAQ,GAAG;AACjD,YAAM,QAAQ,UAAU,IAAI,GAAG;AAC/B,gCAA0B,OAAO,YAAY;AAAA,IAC/C;AAAA,EACF;AAGA,MAAI,qBAAqB,iBAAiB;AACxC,aAAS,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;AACzC,gCAA0B,UAAU,IAAI,CAAC,GAAG,YAAY;AAAA,IAC1D;AAAA,EACF;AAGF;AAOA,SAAS,iBAAiB,WAAiB,UAAkC;AAC3E,MAAI,UAAU,SAAS,SAAS,QAAQ;AACtC,WAAO;AAAA,EACT;AAEA,WAAS,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;AACxC,QAAI,UAAU,CAAC,MAAM,SAAS,CAAC,GAAG;AAChC,aAAO;AAAA,IACT;AAAA,EACF;AAEA,SAAO,UAAU,MAAM,SAAS,MAAM;AACxC;AC7QO,SAAS,wBAAwB,OAAgD;AACtF,SAAO,iBAAiB,WAAW,iBAAiB,mBAAmB,iBAAiB;AAC1F;ACDO,MAAM,8CAA8B,QAAA;AAMpC,SAAS,yBAAyB,WAA0B,UAAyB;AAC1F,0BAAwB,IAAI,WAAW,QAAQ;AACjD;AAcO,SAAS,wBAAwB,WAA0B,UAA4B;AAC5F,SAAO,wBAAwB,IAAI,SAAS,MAAM;AACpD;ACVA,SAAS,iBAAiB,GAAoC;AAC5D,QAAM,IAAI,OAAO;AACjB,SAAO,MAAM,YAAY,MAAM,YAAY,MAAM,aAAa,MAAM,QAAQ,MAAM;AACpF;AAEA,SAAS,aAAa,GAAgC;AACpD,SAAO,MAAM,QAAQ,CAAC;AACxB;AAEA,SAAS,cAAc,GAAiC;AACtD,SAAO,OAAO,MAAM,YAAY,MAAM,QAAQ,CAAC,MAAM,QAAQ,CAAC;AAChE;AAMO,SAAS,6BAA6B,OAAiC;AAE5E,MAAI,iBAAkC,KAAK,GAAG;AAC5C,UAAM,OAAO,MAAM;AACnB,QAAI,MAAM,QAAQ,IAAI,GAAG;AACvB,aAAO;AAAA,IACT;AAAA,EACF;AAGA,MAAI,MAAM,QAAQ,KAAK,GAAG;AACxB,WAAO;AAAA,EACT;AAEA,SAAO,CAAA;AACT;AASO,SAAS,qBAAqB,MAAgB,QAA+B;AAElF,MAAI,WAAW;AACf,QAAM,iBAID,CAAA;AAEL,aAAW,SAAS,QAAQ;AAC1B,QAAI,MAAM,WAAW,QAAW;AAC9B,YAAM,UAAU,MAAM;AACtB,WAAK,OAAO,UAAU,OAAO;AAG7B,UAAI,MAAM,cAAc,OAAO,KAAK,MAAM,UAAU,EAAE,SAAS,GAAG;AAChE,uBAAe,KAAK;AAAA,UAClB,OAAO;AAAA,UACP,KAAK,WAAW,QAAQ;AAAA,UACxB,YAAY,MAAM;AAAA,QAAA,CACnB;AAAA,MACH;AAEA,kBAAY,QAAQ;AAAA,IACtB,WAAW,MAAM,QAAQ;AACvB,kBAAY,MAAM;AAAA,IACpB,WAAW,MAAM,QAAQ;AACvB,WAAK,OAAO,UAAU,MAAM,MAAM;AAAA,IACpC;AAAA,EACF;AAGA,aAAW,MAAM,gBAAgB;AAC/B,eAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,GAAG,UAAU,GAAG;AACxD,WAAK,KAAK,EAAE,OAAO,GAAG,OAAO,KAAK,GAAG,OAAO,KAAK,KAAK;AAAA,IACxD;AAAA,EACF;AACF;AAOO,SAAS,sBAAsB,GAA0B;AAC9D,MAAI,iBAAiB,CAAC,GAAG;AACvB,WAAO;AAAA,EACT;AAEA,MAAI,aAAa,CAAC,GAAG;AACnB,UAAM,OAAO,IAAI,gBAAA;AACjB,oCAAgC,MAAM,CAAC;AACvC,WAAO;AAAA,EACT;AAEA,MAAI,cAAc,CAAC,GAAG;AACpB,QAAI,EAAE,SAAS,MAAM,MAAM;AAEzB,aAAO;AAAA,IACT;AAEA,QAAI,wBAAwB,CAAC,GAAG;AAC9B,YAAM,OAAO,IAAI,SAAA;AAGjB,YAAM,SAAS,6BAA6B,EAAE,SAAS;AACvD,UAAI,OAAO,SAAS,GAAG;AACrB,6BAAqB,MAAM,MAAM;AAAA,MACnC;AACA,aAAO;AAAA,IACT;AAEA,UAAM,MAAM,IAAI,QAAA;AAChB,6BAAyB,KAAK,CAAC;AAC/B,WAAO;AAAA,EACT;AAEA,QAAM,IAAI,MAAM,2BAA2B,CAAC,EAAE;AAChD;AASO,MAAM,kCAAkC,CAC7C,MACA,QACA,UAAkC,CAAA,MAC/B;AACH,QAAM,EAAE,OAAO,MAAA,IAAU;AAEzB,MAAI,SAAS,OAAO;AAElB,eAAW,QAAQ,QAAQ;AACzB,YAAM,YAAY,sBAAsB,IAAI;AAC5C,UAAI,wBAAwB,SAAS,GAAG;AACtC,aAAK,cAAc,SAAS;AAAA,MAC9B,OAAO;AACL,aAAK,KAAK,SAAS;AAAA,MACrB;AAAA,IACF;AACA;AAAA,EACF;AAIA,MAAI,wBAAwB,MAAM,MAAM,GAAG;AACzC;AAAA,EACF;AAGA,QAAM,UAAU,KAAK;AACrB,QAAM,SAAS,OAAO;AACtB,MAAI,UAAU,QAAQ;AACpB,SAAK,OAAO,QAAQ,UAAU,MAAM;AAAA,EACtC;AAGA,QAAM,SAAS,KAAK,IAAI,SAAS,MAAM;AACvC,WAAS,IAAI,GAAG,IAAI,QAAQ,KAAK;AAC/B,UAAM,UAAU,OAAO,CAAC;AACxB,UAAM,WAAW,KAAK,IAAI,CAAC;AAG3B,QAAI,cAAc,OAAO,KAAK,oBAAoB,SAAS;AACzD,+BAAyB,UAAU,SAAS,OAAO;AACnD;AAAA,IACF;AAGA,QAAI,aAAa,OAAO,KAAK,oBAAoB,iBAAiB;AAChE,sCAAgC,UAAU,SAAS,OAAO;AAC1D;AAAA,IACF;AAGA,QAAI,iBAAiB,OAAO,KAAK,aAAa,SAAS;AACrD;AAAA,IACF;AAGA,SAAK,OAAO,GAAG,CAAC;AAChB,UAAM,YAAY,sBAAsB,OAAO;AAC/C,QAAI,wBAAwB,SAAS,GAAG;AACtC,WAAK,gBAAgB,GAAG,SAAS;AAAA,IACnC,OAAO;AACL,WAAK,OAAO,GAAG,SAAS;AAAA,IAC1B;AAAA,EACF;AAGA,WAAS,IAAI,SAAS,IAAI,QAAQ,KAAK;AACrC,UAAM,YAAY,sBAAsB,OAAO,CAAC,CAAC;AACjD,QAAI,wBAAwB,SAAS,GAAG;AACtC,WAAK,cAAc,SAAS;AAAA,IAC9B,OAAO;AACL,WAAK,KAAK,SAAS;AAAA,IACrB;AAAA,EACF;AAGA,2BAAyB,MAAM,MAAM;AACvC;AASO,MAAM,2BAA2B,CACtC,MACA,QACA,UAAkC,CAAA,MAC/B;AACH,QAAM,EAAE,OAAO,MAAA,IAAU;AAEzB,MAAI,SAAS,OAAO;AAElB,eAAW,KAAK,OAAO,KAAK,MAAM,GAAG;AACnC,YAAM,IAAI,OAAO,CAAC;AAClB,UAAI,MAAM,QAAW;AACnB,cAAM,YAAY,sBAAsB,CAAC;AACzC,YAAI,wBAAwB,SAAS,GAAG;AACtC,eAAK,aAAa,GAAG,SAAS;AAAA,QAChC,OAAO;AACL,eAAK,IAAI,GAAG,SAAS;AAAA,QACvB;AAAA,MACF;AAAA,IACF;AACA;AAAA,EACF;AAIA,MAAI,wBAAwB,MAAM,MAAM,GAAG;AACzC;AAAA,EACF;AAGA,QAAM,uBAAuB,IAAI,IAAI,OAAO,KAAK,MAAM,EAAE,OAAO,CAAC,MAAM,OAAO,CAAC,MAAM,MAAS,CAAC;AAC/F,aAAW,OAAO,KAAK,QAAQ;AAC7B,QAAI,CAAC,qBAAqB,IAAI,GAAG,GAAG;AAClC,WAAK,OAAO,GAAG;AAAA,IACjB;AAAA,EACF;AAEA,aAAW,KAAK,OAAO,KAAK,MAAM,GAAG;AACnC,UAAM,IAAI,OAAO,CAAC;AAElB,QAAI,MAAM,QAAW;AACnB;AAAA,IACF;AAEA,UAAM,WAAW,KAAK,IAAI,CAAC;AAG3B,QAAI,cAAc,CAAC,KAAK,oBAAoB,SAAS;AACnD,+BAAyB,UAAU,GAAG,OAAO;AAC7C;AAAA,IACF;AAGA,QAAI,aAAa,CAAC,KAAK,oBAAoB,iBAAiB;AAC1D,sCAAgC,UAAU,GAAG,OAAO;AACpD;AAAA,IACF;AAGA,QAAI,iBAAiB,CAAC,KAAK,aAAa,GAAG;AACzC;AAAA,IACF;AAGA,UAAM,YAAY,sBAAsB,CAAC;AACzC,QAAI,wBAAwB,SAAS,GAAG;AACtC,WAAK,aAAa,GAAG,SAAS;AAAA,IAChC,OAAO;AACL,WAAK,IAAI,GAAG,SAAS;AAAA,IACvB;AAAA,EACF;AAGA,2BAAyB,MAAM,MAAM;AACvC;ACxSA,SAAS,aAAa,GAAqB;AAEzC,MAAI,MAAM,QAAQ,MAAM,UAAa,OAAO,MAAM,UAAU;AAC1D,WAAO;AAAA,EACT;AAEA,MAAI,MAAM,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG;AACtC,WAAO,IAAI,gBAAA;AAAA,EACb;AAGA,MAAI,wBAAwB,CAAC,GAAG;AAC9B,WAAO;AAAA,EACT;AAEA,SAAO,sBAAsB,CAAe;AAC9C;AAKA,SAAS,eAAe,MAAuB,OAAe,OAAsB;AAClF,MAAI,iBAAiB,WAAW,iBAAiB,mBAAmB,iBAAiB,UAAU;AAC7F,SAAK,gBAAgB,OAAO,KAAK;AAAA,EACnC,WAAW,wBAAwB,KAAK,GAAG;AACzC,UAAM,eAAe,KAAK,gBAAgB,OAAO,IAAI,UAAU;AAC/D,UAAM,SAAS,6BAA8B,MAAc,SAAS;AACpE,QAAI,OAAO,SAAS,GAAG;AACrB,2BAAqB,cAAc,MAAM;AAAA,IAC3C;AAAA,EACF,OAAO;AACL,SAAK,OAAO,OAAO,KAAK;AAAA,EAC1B;AACF;AAKA,SAAS,SAAS,KAAc,KAAa,OAAsB;AACjE,MAAI,UAAU,QAAW;AACvB,QAAI,OAAO,GAAG;AAAA,EAChB,WACE,iBAAiB,WACjB,iBAAiB,mBACjB,iBAAiB,UACjB;AACA,QAAI,aAAa,KAAK,KAAK;AAAA,EAC7B,WAAW,wBAAwB,KAAK,GAAG;AACzC,UAAM,eAAe,IAAI,aAAa,KAAK,IAAI,UAAU;AACzD,UAAM,SAAS,6BAA8B,MAAc,SAAS;AACpE,QAAI,OAAO,SAAS,GAAG;AACrB,2BAAqB,cAAc,MAAM;AAAA,IAC3C;AAAA,EACF,OAAO;AACL,QAAI,IAAI,KAAK,KAAK;AAAA,EACpB;AACF;AAKO,SAAS,4BACd,QACA,YACM;AACN,QAAM,gBAAgB,gBAAgB,YAAY,OAAO,IAAI;AAG7D,MAAI,CAAC,eAAe;AAClB,UAAM;AAAA,MACJ,0DAA0D,KAAK,UAAU,OAAO,IAAI,CAAC;AAAA,IAAA;AAAA,EAEzF;AAEA,UAAQ,OAAO,MAAA;AAAA,IACb,KAAK,aAAa;AAChB,UAAI,EAAE,yBAAyB,kBAAkB;AAC/C,cAAM,QAAQ,uDAAuD;AAAA,MACvE;AACA,oBAAc,KAAK,OAAO,WAAW,OAAO,OAAO;AACnD;AAAA,IACF;AAAA,IAEA,KAAK,eAAe,aAAa;AAC/B,UAAI,EAAE,yBAAyB,kBAAkB;AAC/C,cAAM,QAAQ,yDAAyD;AAAA,MACzE;AACA,UAAI,OAAO,cAAc,SAAS,GAAG;AACnC,sBAAc,OAAO,OAAO,OAAO,OAAO,cAAc,MAAM;AAAA,MAChE;AACA,UAAI,OAAO,YAAY,SAAS,GAAG;AACjC,cAAM,iBAAiB,OAAO,YAAY,IAAI,YAAY;AAC1D,iBAAS,IAAI,GAAG,IAAI,eAAe,QAAQ,KAAK;AAC9C,yBAAe,eAAe,OAAO,QAAQ,GAAG,eAAe,CAAC,CAAC;AAAA,QACnE;AAAA,MACF;AACA;AAAA,IACF;AAAA,IAEA,KAAK,eAAe,aAAa;AAC/B,UAAI,EAAE,yBAAyB,kBAAkB;AAC/C,cAAM,QAAQ,yDAAyD;AAAA,MACzE;AACA,YAAM,YAAY,aAAa,OAAO,QAAQ;AAC9C,UACE,qBAAqB,WACrB,qBAAqB,mBACrB,qBAAqB,UACrB;AACA,sBAAc,aAAa,OAAO,OAAO,SAAS;AAAA,MACpD,WAAW,wBAAwB,SAAS,GAAG;AAC7C,cAAM,eAAe,cAAc,aAAa,OAAO,OAAO,IAAI,UAAU;AAC5E,cAAM,SAAS,6BAA8B,UAAkB,SAAS;AACxE,YAAI,OAAO,SAAS,GAAG;AACrB,+BAAqB,cAAc,MAAM;AAAA,QAC3C;AAAA,MACF,OAAO;AACL,sBAAc,IAAI,OAAO,OAAO,SAAS;AAAA,MAC3C;AACA;AAAA,IACF;AAAA,IAEA,KAAK,eAAe;AAAA,IACpB,KAAK,eAAe,cAAc;AAChC,UAAI,yBAAyB,UAAU;AAErC,YAAI,OAAO,QAAQ,aAAa;AAE9B,gBAAM,SAAS,6BAA6B,OAAO,QAAQ;AAC3D,cAAI,cAAc,SAAS,GAAG;AAC5B,0BAAc,OAAO,GAAG,cAAc,MAAM;AAAA,UAC9C;AACA,cAAI,OAAO,SAAS,GAAG;AACrB,iCAAqB,eAAe,MAAM;AAAA,UAC5C;AAAA,QACF;AAAA,MAEF,WAAW,yBAAyB,SAAS;AAC3C,cAAM,YAAY,aAAa,OAAO,QAAQ;AAC9C,iBAAS,eAAe,OAAO,KAAK,SAAS;AAAA,MAC/C,OAAO;AACL,cAAM,QAAQ,wEAAwE;AAAA,MACxF;AACA;AAAA,IACF;AAAA,IAEA,KAAK,eAAe,cAAc;AAChC,UAAI,yBAAyB,SAAU;AAAA,eAE5B,yBAAyB,SAAS;AAC3C,sBAAc,OAAO,OAAO,GAAG;AAAA,MACjC,OAAO;AACL,cAAM,QAAQ,8DAA8D;AAAA,MAC9E;AACA;AAAA,IACF;AAAA,IAEA,SAAS;AAEP,YAAM,mBAA0B;AAChC,YAAM,QAAQ,4BAA6B,iBAAyB,IAAI,EAAE;AAAA,IAC5E;AAAA,EAAA;AAEJ;ACrKA,IAAI;AAsBG,SAAS,gBAAmB,OAAY,WAAmB,SAAuB;AAEvF,MAAI,YAAY,KAAK,aAAa,MAAM,QAAQ;AAC9C,UAAM,IAAI,MAAM,aAAa,SAAS,oCAAoC,MAAM,MAAM,GAAG;AAAA,EAC3F;AACA,MAAI,UAAU,KAAK,UAAU,MAAM,QAAQ;AACzC,UAAM,IAAI,MAAM,WAAW,OAAO,oCAAoC,MAAM,MAAM,GAAG;AAAA,EACvF;AACA,MAAI,cAAc,SAAS;AACzB;AAAA,EACF;AAGA,sBAAoB;AAAA,IAClB;AAAA,IACA;AAAA,IACA;AAAA,IACA,MAAM;AAAA,IACN,qBAAqB;AAAA,EAAA;AAGvB,MAAI;AAGF,UAAM,CAAC,IAAI,IAAI,MAAM,OAAO,WAAW,CAAC;AACxC,UAAM,iBAAiB,UAAU,YAAY,UAAU,IAAI;AAC3D,UAAM,OAAO,gBAAgB,GAAG,IAAI;AAAA,EACtC,UAAA;AACE,wBAAoB;AAAA,EACtB;AACF;AAUO,SAAS,qBAAqB,QAAiD;AAEpF,QAAM,MAAM;AAEZ,MAAI,CAAC,IAAI,qBAAqB;AAE5B,QAAI,OAAO,OAAO;AAClB,QAAI,sBAAsB;AAC1B,WAAO;AAAA,EACT;AASA,QAAM,kBAAkB,IAAI,UAAU,IAAI,YAAY,IAAI,UAAU,IAAI,IAAI;AAE5E,SAAO;AAAA,IACL,MAAM;AAAA,IACN,MAAM,IAAI;AAAA,IACV,WAAW,IAAI;AAAA,IACf,SAAS;AAAA,EAAA;AAEb;AAKO,SAAS,wBAAwB,OAA2B;AACjE,SAAO,sBAAsB,UAAa,kBAAkB,UAAU;AACxE;ACxDA,SAAS,uBAAuB,QAAgC;AAC9D,MAAI,OAAO,SAAS,eAAe,eAAe,OAAO,YAAY,SAAS,GAAG;AAC/E,UAAM,YAAY,OAAO,YAAY,IAAI,CAAC,MAAO,WAAW,CAAC,IAAI,YAAY,CAAC,IAAI,CAAE;AACpF,WAAO,EAAE,GAAG,QAAQ,aAAa,UAAA;AAAA,EACnC,WAAW,OAAO,SAAS,eAAe,aAAa;AACrD,UAAM,WAAW,WAAW,OAAO,QAAQ,IAAI,YAAY,OAAO,QAAQ,IAAI,OAAO;AACrF,WAAO,EAAE,GAAG,QAAQ,UAAU,SAAA;AAAA,EAChC,WACE,OAAO,SAAS,eAAe,aAC/B,OAAO,SAAS,eAAe,cAC/B;AACA,UAAM,WAAW,WAAW,OAAO,QAAQ,IAAI,YAAY,OAAO,QAAQ,IAAI,OAAO;AACrF,WAAO,EAAE,GAAG,QAAQ,UAAU,SAAA;AAAA,EAChC;AACA,SAAO;AACT;AAKO,SAAS,uBAEd;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,GA0BE;;AACA,QAAM,aAAa,2CAA2C,OAAA,CAAQ;AAEtE,MAAI,oCAAoC;AAExC,QAAM,iBAAqC;AAAA,IACzC;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,aAAa;AAAA;AAAA,IAEb,IAAI,sCAAsC;AACxC,aAAO,oCAAoC;AAAA,IAC7C;AAAA,EAAA;AAGF,QAAM,WAAW,sBAAsB,UAAU;AAEjD,MAAI;AAIJ,MAAI,iBAAiB;AAErB,QAAM,oBAAoB,MAAM;AAE9B,UAAM,wBAAwB,mBAAmB,CAAC,SAAS,WAAW;AACpE,UAAI,OAAO,QAAQ;AACjB,yBAAiB;AAAA,MACnB;AAAA,IACF,CAAC;AAED,QAAI;AACF,YAAM,SAAS,mBAAmB;AAAA,QAChC,MAAM,aAAa,kBAAkB,QAAQ;AAAA,QAC7C;AAAA,MAAA;AAEF,yBAAmB,IAAI,QAAQ,EAAE,GAAG,gBAAgB,aAAa,QAAQ;AACzE,aAAO;AAAA,IACT,UAAA;AACE,4BAAA;AAAA,IACF;AAAA,EACF;AAEA,gBAAc,kBAAA;AAGd,QAAM,gBAAe,aAAQ,mBAAmB,WAAW,EAAE,MAAxC,YAA6C,CAAA;AAGlE,QAAM,kBAAkB,OAAO,CAAC,eAA+B;AAE7D,QAAI,WAAW,WAAW,YAAY;AACpC;AAAA,IACF;AAGA,UAAM,8CAA8B,IAAA;AAGpC,UAAM,wCAA2C,IAAA;AAMjD,UAAM,cAAwD,CAAA;AAC9D,UAAM,wBAAwB,mBAAmB,CAAC,QAAQ,WAAW;AACnE,UAAI,OAAO,QAAQ;AACjB,oBAAY,KAAK,EAAE,QAAQ,QAAQ,uBAAuB,MAAM,GAAG;AAAA,MACrE;AAAA,IACF,CAAC;AAED;AACA,QAAI;AACF,UAAI;AACF,mBAAW,SAAS,WAAW,QAAQ;AACrC;AAAA,YACE;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA,UAAA;AAAA,QAEJ;AAAA,MACF,UAAA;AACE,8BAAA;AAAA,MACF;AAMA,UAAI,YAAY,SAAS,GAAG;AAC1B,gBAAQ,oBAAoB,UAAU;AAEtC,mBAAW,EAAE,QAAQ,OAAA,KAAY,aAAa;AAE5C,gBAAM,eAAe,qBAAqB,aAAa,MAAM;AAC7D,cAAI,iBAAiB,QAAW;AAE9B,kBAAM,wBAAoC;AAAA,cACxC,GAAG;AAAA,cACH,MAAM,CAAC,GAAG,cAAc,GAAG,OAAO,IAAI;AAAA,YAAA;AAExC,wCAA4B,uBAAuB,UAAU;AAAA,UAC/D;AAAA,QACF;AAEA,gBAAQ,OAAA;AAAA,MACV;AAIA,UAAI,sBAAsB,WAAW,sBAAsB,iBAAiB;AAC1E,iCAAyB,YAAY,YAAY,WAAW,CAAC;AAAA,MAC/D;AAAA,IACF,UAAA;AACE;AAAA,IACF;AAAA,EACF,CAAC;AACD,QAAM,kBAAkB,QAAQ,UAAU,eAAe;AAIzD,MAAI,iBAAmD,CAAA;AAEvD,QAAM,sBAAsB,aAAa,aAAa,CAAC,WAAW;AAEhE,QAAI,eAAe,qCAAqC;AACtD;AAAA,IACF;AAGA,QAAI,OAAO,QAAQ;AACjB;AAAA,IACF;AAGA,QAAI,OAAO,SAAS,eAAe,aAAa;AAC9C,YAAM,WAAW,YAAY,aAAa,OAAO,IAAI;AACrD,UAAI,SAAS,YAAY,wBAAwB,SAAS,KAAkB,GAAG;AAC7E,cAAM,aAAa,qBAAqB,MAAM;AAE9C,YAAI,eAAe,QAAW;AAE5B;AAAA,QACF;AAGA,uBAAe,KAAK,UAAU;AAC9B;AAAA,MACF;AAAA,IACF;AAOA,mBAAe,KAAK,uBAAuB,MAAM,CAAC;AAAA,EACpD,CAAC;AAID,QAAM,oBAAoB,WAAW,aAAa,MAAM;AACtD,QAAI,eAAe,WAAW,GAAG;AAC/B;AAAA,IACF;AAEA,UAAM,iBAAiB;AACvB,qBAAiB,CAAA;AAGjB,QAAI,eAAe,qCAAqC;AACtD;AAAA,IACF;AAEA,YAAQ,oBAAoB,UAAU;AAGtC,eAAW,UAAU,gBAAgB;AACnC,kCAA4B,QAAQ,UAAU;AAAA,IAChD;AAEA,YAAQ,OAAA;AAGR,QAAI,sBAAsB,WAAW,sBAAsB,iBAAiB;AAC1E,+BAAyB,YAAY,YAAY,WAAW,CAAC;AAAA,IAC/D;AAGA,kCAA8B,UAAU,EAAE,cAAA;AAAA,EAC5C,CAAC;AAKD,QAAM,gBAAgB,YAAY,WAAW;AAE7C,MAAI,gBAAgB;AAClB,YAAQ,oBAAoB,UAAU;AAEtC,QAAI,sBAAsB,SAAS;AACjC,+BAAyB,YAAY,eAA8B,EAAE,MAAM,SAAS;AAAA,IACtF,WAAW,sBAAsB,iBAAiB;AAChD,sCAAgC,YAAY,eAA6B,EAAE,MAAM,SAAS;AAAA,IAC5F,WAAW,sBAAsB,UAAU;AAEzC,YAAM,WAAW;AACjB,UAAI,SAAS,eAAe,iBAAiB;AAE3C,YAAI,WAAW,SAAS,GAAG;AACzB,qBAAW,OAAO,GAAG,WAAW,MAAM;AAAA,QACxC;AACA,cAAM,SAAS,6BAA6B,SAAS,SAAS;AAC9D,YAAI,OAAO,SAAS,GAAG;AACrB,+BAAqB,YAAY,MAAM;AAAA,QACzC;AAAA,MACF;AAAA,IACF;AAEA,YAAQ,OAAA;AAAA,EACV;AAIA,MAAI,sBAAsB,WAAW,sBAAsB,iBAAiB;AAC1E,6BAAyB,YAAY,aAAa;AAAA,EACpD;AAEA,QAAM,UAAU,MAAM;AACpB,oBAAA;AACA,wBAAA;AACA,sBAAA;AAAA,EACF;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,EAAA;AAEJ;","x_google_ignoreList":[0]}