@affectively/dash 5.4.0 → 5.4.5

package/dist/sync/AutomergeProvider.js

@@ -0,0 +1,4421 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// ../../node_modules/.pnpm/@automerge+automerge@3.2.4/node_modules/@automerge/automerge/dist/mjs/wasm_bindgen_output/web/automerge_wasm.js
+var exports_automerge_wasm = {};
+__export(exports_automerge_wasm, {
+  wasmReleaseInfo: () => wasmReleaseInfo,
+  readBundle: () => readBundle,
+  load: () => load,
+  initSyncState: () => initSyncState,
+  initSync: () => initSync,
+  importSyncState: () => importSyncState,
+  exportSyncState: () => exportSyncState,
+  encodeSyncState: () => encodeSyncState,
+  encodeSyncMessage: () => encodeSyncMessage,
+  encodeChange: () => encodeChange,
+  default: () => __wbg_init,
+  decodeSyncState: () => decodeSyncState,
+  decodeSyncMessage: () => decodeSyncMessage,
+  decodeChange: () => decodeChange,
+  create: () => create,
+  SyncState: () => SyncState,
+  Automerge: () => Automerge
+});
+
+class Automerge {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(Automerge.prototype);
+    obj.__wbg_ptr = ptr;
+    AutomergeFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    AutomergeFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_automerge_free(ptr, 0);
+  }
+  applyAndReturnPatches(object, meta) {
+    const ret = wasm.automerge_applyAndReturnPatches(this.__wbg_ptr, object, meta);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  applyChanges(changes) {
+    const ret = wasm.automerge_applyChanges(this.__wbg_ptr, changes);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  applyPatches(object, meta) {
+    const ret = wasm.automerge_applyPatches(this.__wbg_ptr, object, meta);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  clone(actor) {
+    var ptr0 = isLikeNone(actor) ? 0 : passStringToWasm0(actor, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    const ret = wasm.automerge_clone(this.__wbg_ptr, ptr0, len0);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return Automerge.__wrap(ret[0]);
+  }
+  commit(message, time) {
+    var ptr0 = isLikeNone(message) ? 0 : passStringToWasm0(message, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    const ret = wasm.automerge_commit(this.__wbg_ptr, ptr0, len0, !isLikeNone(time), isLikeNone(time) ? 0 : time);
+    return ret;
+  }
+  delete(obj, prop) {
+    const ret = wasm.automerge_delete(this.__wbg_ptr, obj, prop);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  diff(before, after) {
+    const ret = wasm.automerge_diff(this.__wbg_ptr, before, after);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  diffIncremental() {
+    const ret = wasm.automerge_diffIncremental(this.__wbg_ptr);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  diffPath(path, before, after, options) {
+    const ret = wasm.automerge_diffPath(this.__wbg_ptr, path, before, after, options);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  dump() {
+    wasm.automerge_dump(this.__wbg_ptr);
+  }
+  emptyChange(message, time) {
+    var ptr0 = isLikeNone(message) ? 0 : passStringToWasm0(message, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    const ret = wasm.automerge_emptyChange(this.__wbg_ptr, ptr0, len0, !isLikeNone(time), isLikeNone(time) ? 0 : time);
+    return ret;
+  }
+  enableFreeze(enable) {
+    const ret = wasm.automerge_enableFreeze(this.__wbg_ptr, enable);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0] !== 0;
+  }
+  fork(actor, heads) {
+    var ptr0 = isLikeNone(actor) ? 0 : passStringToWasm0(actor, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    const ret = wasm.automerge_fork(this.__wbg_ptr, ptr0, len0, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return Automerge.__wrap(ret[0]);
+  }
+  generateSyncMessage(state) {
+    _assertClass(state, SyncState);
+    const ret = wasm.automerge_generateSyncMessage(this.__wbg_ptr, state.__wbg_ptr);
+    return ret;
+  }
+  get(obj, prop, heads) {
+    const ret = wasm.automerge_get(this.__wbg_ptr, obj, prop, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  getActorId() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.automerge_getActorId(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+  getAll(obj, arg, heads) {
+    const ret = wasm.automerge_getAll(this.__wbg_ptr, obj, arg, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  getBlock(text, index, heads) {
+    const ret = wasm.automerge_getBlock(this.__wbg_ptr, text, index, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  getChangeByHash(hash) {
+    const ret = wasm.automerge_getChangeByHash(this.__wbg_ptr, hash);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  getChangeMetaByHash(hash) {
+    const ret = wasm.automerge_getChangeMetaByHash(this.__wbg_ptr, hash);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  getChanges(have_deps) {
+    const ret = wasm.automerge_getChanges(this.__wbg_ptr, have_deps);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  getChangesAdded(other) {
+    _assertClass(other, Automerge);
+    const ret = wasm.automerge_getChangesAdded(this.__wbg_ptr, other.__wbg_ptr);
+    return ret;
+  }
+  getChangesMeta(have_deps) {
+    const ret = wasm.automerge_getChangesMeta(this.__wbg_ptr, have_deps);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  getCursor(obj, position, heads, move_cursor) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const ret = wasm.automerge_getCursor(this.__wbg_ptr, obj, position, heads, move_cursor);
+      var ptr1 = ret[0];
+      var len1 = ret[1];
+      if (ret[3]) {
+        ptr1 = 0;
+        len1 = 0;
+        throw takeFromExternrefTable0(ret[2]);
+      }
+      deferred2_0 = ptr1;
+      deferred2_1 = len1;
+      return getStringFromWasm0(ptr1, len1);
+    } finally {
+      wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+  }
+  getCursorPosition(obj, cursor, heads) {
+    const ret = wasm.automerge_getCursorPosition(this.__wbg_ptr, obj, cursor, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+  }
+  getDecodedChangeByHash(hash) {
+    const ret = wasm.automerge_getDecodedChangeByHash(this.__wbg_ptr, hash);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  getHeads() {
+    const ret = wasm.automerge_getHeads(this.__wbg_ptr);
+    return ret;
+  }
+  getLastLocalChange() {
+    const ret = wasm.automerge_getLastLocalChange(this.__wbg_ptr);
+    return ret;
+  }
+  getMissingDeps(heads) {
+    const ret = wasm.automerge_getMissingDeps(this.__wbg_ptr, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  getWithType(obj, prop, heads) {
+    const ret = wasm.automerge_getWithType(this.__wbg_ptr, obj, prop, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  hasOurChanges(state) {
+    _assertClass(state, SyncState);
+    const ret = wasm.automerge_hasOurChanges(this.__wbg_ptr, state.__wbg_ptr);
+    return ret !== 0;
+  }
+  increment(obj, prop, value) {
+    const ret = wasm.automerge_increment(this.__wbg_ptr, obj, prop, value);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  insert(obj, index, value, datatype) {
+    const ret = wasm.automerge_insert(this.__wbg_ptr, obj, index, value, datatype);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  insertObject(obj, index, value) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const ret = wasm.automerge_insertObject(this.__wbg_ptr, obj, index, value);
+      var ptr1 = ret[0];
+      var len1 = ret[1];
+      if (ret[3]) {
+        ptr1 = 0;
+        len1 = 0;
+        throw takeFromExternrefTable0(ret[2]);
+      }
+      deferred2_0 = ptr1;
+      deferred2_1 = len1;
+      return getStringFromWasm0(ptr1, len1);
+    } finally {
+      wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+  }
+  integrate() {
+    wasm.automerge_integrate(this.__wbg_ptr);
+  }
+  isolate(heads) {
+    const ret = wasm.automerge_isolate(this.__wbg_ptr, heads);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  joinBlock(obj, index) {
+    const ret = wasm.automerge_joinBlock(this.__wbg_ptr, obj, index);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  keys(obj, heads) {
+    const ret = wasm.automerge_keys(this.__wbg_ptr, obj, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  length(obj, heads) {
+    const ret = wasm.automerge_length(this.__wbg_ptr, obj, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+  }
+  loadIncremental(data) {
+    const ret = wasm.automerge_loadIncremental(this.__wbg_ptr, data);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+  }
+  mark(obj, range, name, value, datatype) {
+    const ret = wasm.automerge_mark(this.__wbg_ptr, obj, range, name, value, datatype);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  marks(obj, heads) {
+    const ret = wasm.automerge_marks(this.__wbg_ptr, obj, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  marksAt(obj, index, heads) {
+    const ret = wasm.automerge_marksAt(this.__wbg_ptr, obj, index, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  materialize(obj, heads, meta) {
+    const ret = wasm.automerge_materialize(this.__wbg_ptr, obj, heads, meta);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  merge(other) {
+    _assertClass(other, Automerge);
+    const ret = wasm.automerge_merge(this.__wbg_ptr, other.__wbg_ptr);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  static new(actor) {
+    var ptr0 = isLikeNone(actor) ? 0 : passStringToWasm0(actor, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    const ret = wasm.automerge_new(ptr0, len0);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return Automerge.__wrap(ret[0]);
+  }
+  objInfo(obj, heads) {
+    const ret = wasm.automerge_objInfo(this.__wbg_ptr, obj, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  pendingOps() {
+    const ret = wasm.automerge_pendingOps(this.__wbg_ptr);
+    return ret;
+  }
+  push(obj, value, datatype) {
+    const ret = wasm.automerge_push(this.__wbg_ptr, obj, value, datatype);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  pushObject(obj, value) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const ret = wasm.automerge_pushObject(this.__wbg_ptr, obj, value);
+      var ptr1 = ret[0];
+      var len1 = ret[1];
+      if (ret[3]) {
+        ptr1 = 0;
+        len1 = 0;
+        throw takeFromExternrefTable0(ret[2]);
+      }
+      deferred2_0 = ptr1;
+      deferred2_1 = len1;
+      return getStringFromWasm0(ptr1, len1);
+    } finally {
+      wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+  }
+  put(obj, prop, value, datatype) {
+    const ret = wasm.automerge_put(this.__wbg_ptr, obj, prop, value, datatype);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  putObject(obj, prop, value) {
+    const ret = wasm.automerge_putObject(this.__wbg_ptr, obj, prop, value);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  receiveSyncMessage(state, message) {
+    _assertClass(state, SyncState);
+    const ret = wasm.automerge_receiveSyncMessage(this.__wbg_ptr, state.__wbg_ptr, message);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  registerDatatype(datatype, construct, deconstruct) {
+    const ret = wasm.automerge_registerDatatype(this.__wbg_ptr, datatype, construct, deconstruct);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  resetDiffCursor() {
+    wasm.automerge_resetDiffCursor(this.__wbg_ptr);
+  }
+  rollback() {
+    const ret = wasm.automerge_rollback(this.__wbg_ptr);
+    return ret;
+  }
+  save() {
+    const ret = wasm.automerge_save(this.__wbg_ptr);
+    return ret;
+  }
+  saveAndVerify() {
+    const ret = wasm.automerge_saveAndVerify(this.__wbg_ptr);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  saveBundle(hashes) {
+    const ret = wasm.automerge_saveBundle(this.__wbg_ptr, hashes);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  saveIncremental() {
+    const ret = wasm.automerge_saveIncremental(this.__wbg_ptr);
+    return ret;
+  }
+  saveNoCompress() {
+    const ret = wasm.automerge_saveNoCompress(this.__wbg_ptr);
+    return ret;
+  }
+  saveSince(heads) {
+    const ret = wasm.automerge_saveSince(this.__wbg_ptr, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  spans(obj, heads) {
+    const ret = wasm.automerge_spans(this.__wbg_ptr, obj, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  splice(obj, start, delete_count, text) {
+    const ret = wasm.automerge_splice(this.__wbg_ptr, obj, start, delete_count, text);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  splitBlock(obj, index, block) {
+    const ret = wasm.automerge_splitBlock(this.__wbg_ptr, obj, index, block);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  stats() {
+    const ret = wasm.automerge_stats(this.__wbg_ptr);
+    return ret;
+  }
+  text(obj, heads) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const ret = wasm.automerge_text(this.__wbg_ptr, obj, heads);
+      var ptr1 = ret[0];
+      var len1 = ret[1];
+      if (ret[3]) {
+        ptr1 = 0;
+        len1 = 0;
+        throw takeFromExternrefTable0(ret[2]);
+      }
+      deferred2_0 = ptr1;
+      deferred2_1 = len1;
+      return getStringFromWasm0(ptr1, len1);
+    } finally {
+      wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+  }
+  toJS(meta) {
+    const ret = wasm.automerge_toJS(this.__wbg_ptr, meta);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  topoHistoryTraversal() {
+    const ret = wasm.automerge_topoHistoryTraversal(this.__wbg_ptr);
+    return ret;
+  }
+  unmark(obj, range, name) {
+    const ret = wasm.automerge_unmark(this.__wbg_ptr, obj, range, name);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  updateBlock(obj, index, block) {
+    const ret = wasm.automerge_updateBlock(this.__wbg_ptr, obj, index, block);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  updateDiffCursor() {
+    wasm.automerge_updateDiffCursor(this.__wbg_ptr);
+  }
+  updateSpans(obj, args, config) {
+    const ret = wasm.automerge_updateSpans(this.__wbg_ptr, obj, args, config);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  updateText(obj, new_text) {
+    const ret = wasm.automerge_updateText(this.__wbg_ptr, obj, new_text);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+}
+
+class SyncState {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(SyncState.prototype);
+    obj.__wbg_ptr = ptr;
+    SyncStateFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    SyncStateFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_syncstate_free(ptr, 0);
+  }
+  clone() {
+    const ret = wasm.syncstate_clone(this.__wbg_ptr);
+    return SyncState.__wrap(ret);
+  }
+  get lastSentHeads() {
+    const ret = wasm.syncstate_lastSentHeads(this.__wbg_ptr);
+    return ret;
+  }
+  set lastSentHeads(heads) {
+    const ret = wasm.syncstate_set_lastSentHeads(this.__wbg_ptr, heads);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  set sentHashes(hashes) {
+    const ret = wasm.syncstate_set_sentHashes(this.__wbg_ptr, hashes);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  get sharedHeads() {
+    const ret = wasm.syncstate_sharedHeads(this.__wbg_ptr);
+    return ret;
+  }
+}
+function create(options) {
+  const ret = wasm.create(options);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return Automerge.__wrap(ret[0]);
+}
+function decodeChange(change) {
+  const ret = wasm.decodeChange(change);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return takeFromExternrefTable0(ret[0]);
+}
+function decodeSyncMessage(msg) {
+  const ret = wasm.decodeSyncMessage(msg);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return takeFromExternrefTable0(ret[0]);
+}
+function decodeSyncState(data) {
+  const ret = wasm.decodeSyncState(data);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return SyncState.__wrap(ret[0]);
+}
+function encodeChange(change) {
+  const ret = wasm.encodeChange(change);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return takeFromExternrefTable0(ret[0]);
+}
+function encodeSyncMessage(message) {
+  const ret = wasm.encodeSyncMessage(message);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return takeFromExternrefTable0(ret[0]);
+}
+function encodeSyncState(state) {
+  _assertClass(state, SyncState);
+  const ret = wasm.encodeSyncState(state.__wbg_ptr);
+  return ret;
+}
+function exportSyncState(state) {
+  _assertClass(state, SyncState);
+  const ret = wasm.exportSyncState(state.__wbg_ptr);
+  return ret;
+}
+function importSyncState(state) {
+  const ret = wasm.importSyncState(state);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return SyncState.__wrap(ret[0]);
+}
+function initSyncState() {
+  const ret = wasm.initSyncState();
+  return SyncState.__wrap(ret);
+}
+function load(data, options) {
+  const ret = wasm.load(data, options);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return Automerge.__wrap(ret[0]);
+}
+function readBundle(bundle) {
+  const ret = wasm.readBundle(bundle);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return takeFromExternrefTable0(ret[0]);
+}
+function wasmReleaseInfo() {
+  const ret = wasm.wasmReleaseInfo();
+  return ret;
+}
+function __wbg_get_imports() {
+  const import0 = {
+    __proto__: null,
+    __wbg_BigInt_b7bbccdff258c9f2: function(arg0) {
+      const ret = BigInt(arg0);
+      return ret;
+    },
+    __wbg_Error_8c4e43fe74559d73: function(arg0, arg1) {
+      const ret = Error(getStringFromWasm0(arg0, arg1));
+      return ret;
+    },
+    __wbg_String_8f0eb39a4a4c2f66: function(arg0, arg1) {
+      const ret = String(arg1);
+      const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const len1 = WASM_VECTOR_LEN;
+      getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+      getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    },
+    __wbg___wbindgen_boolean_get_bbbb1c18aa2f5e25: function(arg0) {
+      const v = arg0;
+      const ret = typeof v === "boolean" ? v : undefined;
+      return isLikeNone(ret) ? 16777215 : ret ? 1 : 0;
+    },
+    __wbg___wbindgen_debug_string_0bc8482c6e3508ae: function(arg0, arg1) {
+      const ret = debugString(arg1);
+      const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const len1 = WASM_VECTOR_LEN;
+      getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+      getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    },
+    __wbg___wbindgen_gt_d7bb3629eac381f5: function(arg0, arg1) {
+      const ret = arg0 > arg1;
+      return ret;
+    },
+    __wbg___wbindgen_is_bigint_31b12575b56f32fc: function(arg0) {
+      const ret = typeof arg0 === "bigint";
+      return ret;
+    },
+    __wbg___wbindgen_is_function_0095a73b8b156f76: function(arg0) {
+      const ret = typeof arg0 === "function";
+      return ret;
+    },
+    __wbg___wbindgen_is_null_ac34f5003991759a: function(arg0) {
+      const ret = arg0 === null;
+      return ret;
+    },
+    __wbg___wbindgen_is_object_5ae8e5880f2c1fbd: function(arg0) {
+      const val = arg0;
+      const ret = typeof val === "object" && val !== null;
+      return ret;
+    },
+    __wbg___wbindgen_is_string_cd444516edc5b180: function(arg0) {
+      const ret = typeof arg0 === "string";
+      return ret;
+    },
+    __wbg___wbindgen_is_undefined_9e4d92534c42d778: function(arg0) {
+      const ret = arg0 === undefined;
+      return ret;
+    },
+    __wbg___wbindgen_jsval_loose_eq_9dd77d8cd6671811: function(arg0, arg1) {
+      const ret = arg0 == arg1;
+      return ret;
+    },
+    __wbg___wbindgen_lt_bb59cc3d23526e0d: function(arg0, arg1) {
+      const ret = arg0 < arg1;
+      return ret;
+    },
+    __wbg___wbindgen_neg_6b4d356dff49dcc6: function(arg0) {
+      const ret = -arg0;
+      return ret;
+    },
+    __wbg___wbindgen_number_get_8ff4255516ccad3e: function(arg0, arg1) {
+      const obj = arg1;
+      const ret = typeof obj === "number" ? obj : undefined;
+      getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+      getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+    },
+    __wbg___wbindgen_string_get_72fb696202c56729: function(arg0, arg1) {
+      const obj = arg1;
+      const ret = typeof obj === "string" ? obj : undefined;
+      var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      var len1 = WASM_VECTOR_LEN;
+      getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+      getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    },
+    __wbg___wbindgen_throw_be289d5034ed271b: function(arg0, arg1) {
+      throw new Error(getStringFromWasm0(arg0, arg1));
+    },
+    __wbg_apply_2e22c45cb4f12415: function() {
+      return handleError(function(arg0, arg1, arg2) {
+        const ret = Reflect.apply(arg0, arg1, arg2);
+        return ret;
+      }, arguments);
+    },
+    __wbg_assign_6170c0d04d5c26f4: function(arg0, arg1) {
+      const ret = Object.assign(arg0, arg1);
+      return ret;
+    },
+    __wbg_call_389efe28435a9388: function() {
+      return handleError(function(arg0, arg1) {
+        const ret = arg0.call(arg1);
+        return ret;
+      }, arguments);
+    },
+    __wbg_call_4708e0c13bdc8e95: function() {
+      return handleError(function(arg0, arg1, arg2) {
+        const ret = arg0.call(arg1, arg2);
+        return ret;
+      }, arguments);
+    },
+    __wbg_concat_f6e5ebc81f4917f1: function(arg0, arg1) {
+      const ret = arg0.concat(arg1);
+      return ret;
+    },
+    __wbg_defineProperty_fc8692a66be8fe2d: function(arg0, arg1, arg2) {
+      const ret = Object.defineProperty(arg0, arg1, arg2);
+      return ret;
+    },
+    __wbg_deleteProperty_8c8a05da881fea59: function() {
+      return handleError(function(arg0, arg1) {
+        const ret = Reflect.deleteProperty(arg0, arg1);
+        return ret;
+      }, arguments);
+    },
+    __wbg_done_57b39ecd9addfe81: function(arg0) {
+      const ret = arg0.done;
+      return ret;
+    },
+    __wbg_entries_58c7934c745daac7: function(arg0) {
+      const ret = Object.entries(arg0);
+      return ret;
+    },
+    __wbg_error_7534b8e9a36f1ab4: function(arg0, arg1) {
+      let deferred0_0;
+      let deferred0_1;
+      try {
+        deferred0_0 = arg0;
+        deferred0_1 = arg1;
+        console.error(getStringFromWasm0(arg0, arg1));
+      } finally {
+        wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+      }
+    },
+    __wbg_for_c3adefd268cb6f1c: function(arg0, arg1) {
+      const ret = Symbol.for(getStringFromWasm0(arg0, arg1));
+      return ret;
+    },
+    __wbg_freeze_661d9047fd889cd0: function(arg0) {
+      const ret = Object.freeze(arg0);
+      return ret;
+    },
+    __wbg_from_bddd64e7d5ff6941: function(arg0) {
+      const ret = Array.from(arg0);
+      return ret;
+    },
+    __wbg_getRandomValues_1c61fac11405ffdc: function() {
+      return handleError(function(arg0, arg1) {
+        globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
+      }, arguments);
+    },
+    __wbg_getTime_1e3cd1391c5c3995: function(arg0) {
+      const ret = arg0.getTime();
+      return ret;
+    },
+    __wbg_get_9b94d73e6221f75c: function(arg0, arg1) {
+      const ret = arg0[arg1 >>> 0];
+      return ret;
+    },
+    __wbg_get_b3ed3ad4be2bc8ac: function() {
+      return handleError(function(arg0, arg1) {
+        const ret = Reflect.get(arg0, arg1);
+        return ret;
+      }, arguments);
+    },
+    __wbg_instanceof_ArrayBuffer_c367199e2fa2aa04: function(arg0) {
+      let result;
+      try {
+        result = arg0 instanceof ArrayBuffer;
+      } catch (_) {
+        result = false;
+      }
+      const ret = result;
+      return ret;
+    },
+    __wbg_instanceof_Date_1b9f15b87f10aa4c: function(arg0) {
+      let result;
+      try {
+        result = arg0 instanceof Date;
+      } catch (_) {
+        result = false;
+      }
+      const ret = result;
+      return ret;
+    },
+    __wbg_instanceof_Object_1c6af87502b733ed: function(arg0) {
+      let result;
+      try {
+        result = arg0 instanceof Object;
+      } catch (_) {
+        result = false;
+      }
+      const ret = result;
+      return ret;
+    },
+    __wbg_instanceof_Uint8Array_9b9075935c74707c: function(arg0) {
+      let result;
+      try {
+        result = arg0 instanceof Uint8Array;
+      } catch (_) {
+        result = false;
+      }
+      const ret = result;
+      return ret;
+    },
+    __wbg_isArray_a2cef7634fcb7c0d: function(arg0) {
+      const ret = Array.isArray(arg0);
+      return ret;
+    },
+    __wbg_isArray_d314bb98fcf08331: function(arg0) {
+      const ret = Array.isArray(arg0);
+      return ret;
+    },
+    __wbg_iterator_6ff6560ca1568e55: function() {
+      const ret = Symbol.iterator;
+      return ret;
+    },
+    __wbg_keys_b50a709a76add04e: function(arg0) {
+      const ret = Object.keys(arg0);
+      return ret;
+    },
+    __wbg_length_32ed9a279acd054c: function(arg0) {
+      const ret = arg0.length;
+      return ret;
+    },
+    __wbg_length_35a7bace40f36eac: function(arg0) {
+      const ret = arg0.length;
+      return ret;
+    },
+    __wbg_length_68dc7c5cf1b6d349: function(arg0) {
+      const ret = arg0.length;
+      return ret;
+    },
+    __wbg_log_6b5ca2e6124b2808: function(arg0) {
+      console.log(arg0);
+    },
+    __wbg_log_b948c93e3e66d64f: function(arg0, arg1) {
+      console.log(arg0, arg1);
+    },
+    __wbg_new_245cd5c49157e602: function(arg0) {
+      const ret = new Date(arg0);
+      return ret;
+    },
+    __wbg_new_361308b2356cecd0: function() {
+      const ret = new Object;
+      return ret;
+    },
+    __wbg_new_3eb36ae241fe6f44: function() {
+      const ret = new Array;
+      return ret;
+    },
+    __wbg_new_72b49615380db768: function(arg0, arg1) {
+      const ret = new Error(getStringFromWasm0(arg0, arg1));
+      return ret;
+    },
+    __wbg_new_8a6f238a6ece86ea: function() {
+      const ret = new Error;
+      return ret;
+    },
+    __wbg_new_911dabf69fa7eb20: function(arg0, arg1) {
+      const ret = new RangeError(getStringFromWasm0(arg0, arg1));
+      return ret;
+    },
+    __wbg_new_dd2b680c8bf6ae29: function(arg0) {
+      const ret = new Uint8Array(arg0);
+      return ret;
+    },
+    __wbg_new_from_slice_a3d2629dc1826784: function(arg0, arg1) {
+      const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+      return ret;
+    },
+    __wbg_next_3482f54c49e8af19: function() {
+      return handleError(function(arg0) {
+        const ret = arg0.next();
+        return ret;
+      }, arguments);
+    },
+    __wbg_next_418f80d8f5303233: function(arg0) {
+      const ret = arg0.next;
+      return ret;
+    },
+    __wbg_ownKeys_c7100fb5fa376c6f: function() {
+      return handleError(function(arg0) {
+        const ret = Reflect.ownKeys(arg0);
+        return ret;
+      }, arguments);
+    },
+    __wbg_prototypesetcall_bdcdcc5842e4d77d: function(arg0, arg1, arg2) {
+      Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+    },
+    __wbg_push_8ffdcb2063340ba5: function(arg0, arg1) {
+      const ret = arg0.push(arg1);
+      return ret;
+    },
+    __wbg_set_3f1d0b984ed272ed: function(arg0, arg1, arg2) {
+      arg0[arg1] = arg2;
+    },
+    __wbg_set_6cb8631f80447a67: function() {
+      return handleError(function(arg0, arg1, arg2) {
+        const ret = Reflect.set(arg0, arg1, arg2);
+        return ret;
+      }, arguments);
+    },
+    __wbg_set_f43e577aea94465b: function(arg0, arg1, arg2) {
+      arg0[arg1 >>> 0] = arg2;
+    },
+    __wbg_slice_b0fa09b1e0041d42: function(arg0, arg1, arg2) {
+      const ret = arg0.slice(arg1 >>> 0, arg2 >>> 0);
+      return ret;
+    },
+    __wbg_stack_0ed75d68575b0f3c: function(arg0, arg1) {
+      const ret = arg1.stack;
+      const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const len1 = WASM_VECTOR_LEN;
+      getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+      getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    },
+    __wbg_stringify_e4a940b133e6b7d8: function(arg0, arg1) {
+      const ret = JSON.stringify(arg1);
+      var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      var len1 = WASM_VECTOR_LEN;
+      getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+      getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    },
+    __wbg_toString_3cadee6e7c22b39e: function() {
+      return handleError(function(arg0, arg1) {
+        const ret = arg0.toString(arg1);
+        return ret;
+      }, arguments);
+    },
+    __wbg_toString_56d946daff83867b: function(arg0, arg1, arg2) {
+      const ret = arg1.toString(arg2);
+      const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const len1 = WASM_VECTOR_LEN;
+      getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+      getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    },
+    __wbg_toString_b388ecd2d3c517c3: function(arg0) {
+      const ret = arg0.toString();
+      return ret;
+    },
+    __wbg_unshift_a4a28a3b4a2e621b: function(arg0, arg1) {
+      const ret = arg0.unshift(arg1);
+      return ret;
+    },
+    __wbg_value_0546255b415e96c1: function(arg0) {
+      const ret = arg0.value;
+      return ret;
+    },
+    __wbg_values_5da93bc719d272cf: function(arg0) {
+      const ret = Object.values(arg0);
+      return ret;
+    },
+    __wbindgen_cast_0000000000000001: function(arg0) {
+      const ret = arg0;
+      return ret;
+    },
+    __wbindgen_cast_0000000000000002: function(arg0) {
+      const ret = arg0;
+      return ret;
+    },
+    __wbindgen_cast_0000000000000003: function(arg0, arg1) {
+      const ret = getStringFromWasm0(arg0, arg1);
+      return ret;
+    },
+    __wbindgen_cast_0000000000000004: function(arg0) {
+      const ret = BigInt.asUintN(64, arg0);
+      return ret;
+    },
+    __wbindgen_init_externref_table: function() {
+      const table = wasm.__wbindgen_externrefs;
+      const offset = table.grow(4);
+      table.set(0, undefined);
+      table.set(offset + 0, undefined);
+      table.set(offset + 1, null);
+      table.set(offset + 2, true);
+      table.set(offset + 3, false);
+    }
+  };
+  return {
+    __proto__: null,
+    "./automerge_wasm_bg.js": import0
+  };
+}
+function addToExternrefTable0(obj) {
+  const idx = wasm.__externref_table_alloc();
+  wasm.__wbindgen_externrefs.set(idx, obj);
+  return idx;
+}
+function _assertClass(instance, klass) {
+  if (!(instance instanceof klass)) {
+    throw new Error(`expected instance of ${klass.name}`);
+  }
+}
+function debugString(val) {
+  const type = typeof val;
+  if (type == "number" || type == "boolean" || val == null) {
+    return `${val}`;
+  }
+  if (type == "string") {
+    return `"${val}"`;
+  }
+  if (type == "symbol") {
+    const description = val.description;
+    if (description == null) {
+      return "Symbol";
+    } else {
+      return `Symbol(${description})`;
+    }
+  }
+  if (type == "function") {
+    const name = val.name;
+    if (typeof name == "string" && name.length > 0) {
+      return `Function(${name})`;
+    } else {
+      return "Function";
+    }
+  }
+  if (Array.isArray(val)) {
+    const length = val.length;
+    let debug = "[";
+    if (length > 0) {
+      debug += debugString(val[0]);
+    }
+    for (let i = 1;i < length; i++) {
+      debug += ", " + debugString(val[i]);
+    }
+    debug += "]";
+    return debug;
+  }
+  const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+  let className;
+  if (builtInMatches && builtInMatches.length > 1) {
+    className = builtInMatches[1];
+  } else {
+    return toString.call(val);
+  }
+  if (className == "Object") {
+    try {
+      return "Object(" + JSON.stringify(val) + ")";
+    } catch (_) {
+      return "Object";
+    }
+  }
+  if (val instanceof Error) {
+    return `${val.name}: ${val.message}
+${val.stack}`;
+  }
+  return className;
+}
+function getArrayU8FromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+function getDataViewMemory0() {
+  if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer) {
+    cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+  }
+  return cachedDataViewMemory0;
+}
+function getStringFromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return decodeText(ptr, len);
+}
+function getUint8ArrayMemory0() {
+  if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+    cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+  }
+  return cachedUint8ArrayMemory0;
+}
+function handleError(f, args) {
+  try {
+    return f.apply(this, args);
+  } catch (e) {
+    const idx = addToExternrefTable0(e);
+    wasm.__wbindgen_exn_store(idx);
+  }
+}
+function isLikeNone(x) {
+  return x === undefined || x === null;
+}
+function passStringToWasm0(arg, malloc, realloc) {
+  if (realloc === undefined) {
+    const buf = cachedTextEncoder.encode(arg);
+    const ptr2 = malloc(buf.length, 1) >>> 0;
+    getUint8ArrayMemory0().subarray(ptr2, ptr2 + buf.length).set(buf);
+    WASM_VECTOR_LEN = buf.length;
+    return ptr2;
+  }
+  let len = arg.length;
+  let ptr = malloc(len, 1) >>> 0;
+  const mem = getUint8ArrayMemory0();
+  let offset = 0;
+  for (;offset < len; offset++) {
+    const code = arg.charCodeAt(offset);
+    if (code > 127)
+      break;
+    mem[ptr + offset] = code;
+  }
+  if (offset !== len) {
+    if (offset !== 0) {
+      arg = arg.slice(offset);
+    }
+    ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+    const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+    const ret = cachedTextEncoder.encodeInto(arg, view);
+    offset += ret.written;
+    ptr = realloc(ptr, len, offset, 1) >>> 0;
+  }
+  WASM_VECTOR_LEN = offset;
+  return ptr;
+}
+function takeFromExternrefTable0(idx) {
+  const value = wasm.__wbindgen_externrefs.get(idx);
+  wasm.__externref_table_dealloc(idx);
+  return value;
+}
+function decodeText(ptr, len) {
+  numBytesDecoded += len;
+  if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+    cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+    cachedTextDecoder.decode();
+    numBytesDecoded = len;
+  }
+  return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+function __wbg_finalize_init(instance, module) {
+  wasm = instance.exports;
+  wasmModule = module;
+  cachedDataViewMemory0 = null;
+  cachedUint8ArrayMemory0 = null;
+  wasm.__wbindgen_start();
+  return wasm;
+}
+async function __wbg_load(module, imports) {
+  if (typeof Response === "function" && module instanceof Response) {
+    if (typeof WebAssembly.instantiateStreaming === "function") {
+      try {
+        return await WebAssembly.instantiateStreaming(module, imports);
+      } catch (e) {
+        const validResponse = module.ok && expectedResponseType(module.type);
+        if (validResponse && module.headers.get("Content-Type") !== "application/wasm") {
+          console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+        } else {
+          throw e;
+        }
+      }
+    }
+    const bytes = await module.arrayBuffer();
+    return await WebAssembly.instantiate(bytes, imports);
+  } else {
+    const instance = await WebAssembly.instantiate(module, imports);
+    if (instance instanceof WebAssembly.Instance) {
+      return { instance, module };
+    } else {
+      return instance;
+    }
+  }
+  function expectedResponseType(type) {
+    switch (type) {
+      case "basic":
+      case "cors":
+      case "default":
+        return true;
+    }
+    return false;
+  }
+}
+function initSync(module) {
+  if (wasm !== undefined)
+    return wasm;
+  if (module !== undefined) {
+    if (Object.getPrototypeOf(module) === Object.prototype) {
+      ({ module } = module);
+    } else {
+      console.warn("using deprecated parameters for `initSync()`; pass a single object instead");
+    }
+  }
+  const imports = __wbg_get_imports();
+  if (!(module instanceof WebAssembly.Module)) {
+    module = new WebAssembly.Module(module);
+  }
+  const instance = new WebAssembly.Instance(module, imports);
+  return __wbg_finalize_init(instance, module);
+}
+async function __wbg_init(module_or_path) {
+  if (wasm !== undefined)
+    return wasm;
+  if (module_or_path !== undefined) {
+    if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+      ({ module_or_path } = module_or_path);
+    } else {
+      console.warn("using deprecated parameters for the initialization function; pass a single object instead");
+    }
+  }
+  if (module_or_path === undefined) {
+    module_or_path = new URL("automerge_wasm_bg.wasm", import.meta.url);
+  }
+  const imports = __wbg_get_imports();
+  if (typeof module_or_path === "string" || typeof Request === "function" && module_or_path instanceof Request || typeof URL === "function" && module_or_path instanceof URL) {
+    module_or_path = fetch(module_or_path);
+  }
+  const { instance, module } = await __wbg_load(await module_or_path, imports);
+  return __wbg_finalize_init(instance, module);
+}
+var AutomergeFinalization, SyncStateFinalization, cachedDataViewMemory0 = null, cachedUint8ArrayMemory0 = null, cachedTextDecoder, MAX_SAFARI_DECODE_BYTES = 2146435072, numBytesDecoded = 0, cachedTextEncoder, WASM_VECTOR_LEN = 0, wasmModule, wasm;
+var init_automerge_wasm = __esm(() => {
+  if (Symbol.dispose)
+    Automerge.prototype[Symbol.dispose] = Automerge.prototype.free;
+  if (Symbol.dispose)
+    SyncState.prototype[Symbol.dispose] = SyncState.prototype.free;
+  AutomergeFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm.__wbg_automerge_free(ptr >>> 0, 1));
+  SyncStateFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm.__wbg_syncstate_free(ptr >>> 0, 1));
+  cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+  cachedTextDecoder.decode();
+  cachedTextEncoder = new TextEncoder;
+  if (!("encodeInto" in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function(arg, view) {
+      const buf = cachedTextEncoder.encode(arg);
+      view.set(buf);
+      return {
+        read: arg.length,
+        written: buf.length
+      };
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@automerge+automerge@3.2.4/node_modules/@automerge/automerge/dist/mjs/low_level.js
+function UseApi(api) {
+  for (const k in api) {
+    ApiHandler[k] = api[k];
+  }
+  _initialized = true;
+  for (const listener of _initializeListeners) {
+    listener();
+  }
+}
+function initializeWasm(wasmBlob) {
+  return __wbg_init({ module_or_path: wasmBlob }).then((_) => {
+    UseApi(exports_automerge_wasm);
+  });
+}
+function initializeBase64Wasm(wasmBase64) {
+  return initializeWasm(Uint8Array.from(atob(wasmBase64), (c) => c.charCodeAt(0)));
+}
+function wasmInitialized() {
+  if (_initialized)
+    return Promise.resolve();
+  return new Promise((resolve) => {
+    _initializeListeners.push(resolve);
+  });
+}
+function isWasmInitialized() {
+  return _initialized;
+}
+var _initialized = false, _initializeListeners, ApiHandler;
+var init_low_level = __esm(() => {
+  init_automerge_wasm();
+  init_automerge_wasm();
+  _initializeListeners = [];
+  ApiHandler = {
+    create(options) {
+      throw new RangeError("Automerge.use() not called");
+    },
+    load(data, options) {
+      throw new RangeError("Automerge.use() not called (load)");
+    },
+    encodeChange(change) {
+      throw new RangeError("Automerge.use() not called (encodeChange)");
+    },
+    decodeChange(change) {
+      throw new RangeError("Automerge.use() not called (decodeChange)");
+    },
+    initSyncState() {
+      throw new RangeError("Automerge.use() not called (initSyncState)");
+    },
+    encodeSyncMessage(message) {
+      throw new RangeError("Automerge.use() not called (encodeSyncMessage)");
+    },
+    decodeSyncMessage(msg) {
+      throw new RangeError("Automerge.use() not called (decodeSyncMessage)");
+    },
+    encodeSyncState(state) {
+      throw new RangeError("Automerge.use() not called (encodeSyncState)");
+    },
+    decodeSyncState(data) {
+      throw new RangeError("Automerge.use() not called (decodeSyncState)");
+    },
+    exportSyncState(state) {
+      throw new RangeError("Automerge.use() not called (exportSyncState)");
+    },
+    importSyncState(state) {
+      throw new RangeError("Automerge.use() not called (importSyncState)");
+    },
+    readBundle(data) {
+      throw new RangeError("Automerge.use() not called (readBundle)");
+    },
+    wasmReleaseInfo() {
+      throw new RangeError("Automerge.use() not called (wasmReleaseInfo)");
+    }
+  };
+});
+
+// ../../node_modules/.pnpm/@automerge+automerge@3.2.4/node_modules/@automerge/automerge/dist/mjs/wasm_bindgen_output/bundler/automerge_wasm_bg.wasm
+var exports_automerge_wasm_bg = {};
+__export(exports_automerge_wasm_bg, {
+  default: () => automerge_wasm_bg_default
+});
+var automerge_wasm_bg_default = "../automerge_wasm_bg-4hg5vg2g.wasm";
+var init_automerge_wasm_bg = () => {};
+
+// ../../node_modules/.pnpm/@automerge+automerge@3.2.4/node_modules/@automerge/automerge/dist/mjs/wasm_bindgen_output/bundler/automerge_wasm_bg.js
+class Automerge2 {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(Automerge2.prototype);
+    obj.__wbg_ptr = ptr;
+    AutomergeFinalization2.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    AutomergeFinalization2.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm2.__wbg_automerge_free(ptr, 0);
+  }
+  applyAndReturnPatches(object, meta) {
+    const ret = wasm2.automerge_applyAndReturnPatches(this.__wbg_ptr, object, meta);
+    if (ret[2]) {
+      throw takeFromExternrefTable02(ret[1]);
+    }
+    return takeFromExternrefTable02(ret[0]);
+  }
+  applyChanges(changes) {
+    const ret = wasm2.automerge_applyChanges(this.__wbg_ptr, changes);
+    if (ret[1]) {
+      throw takeFromExternrefTable02(ret[0]);
+    }
+  }
+  applyPatches(object, meta) {
+    const ret = wasm2.automerge_applyPatches(this.__wbg_ptr, object, meta);
+    if (ret[2]) {
+      throw takeFromExternrefTable02(ret[1]);
+    }
+    return takeFromExternrefTable02(ret[0]);
+  }
+  clone(actor) {
+    var ptr0 = isLikeNone2(actor) ? 0 : passStringToWasm02(actor, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN2;
+    const ret = wasm2.automerge_clone(this.__wbg_ptr, ptr0, len0);
+    if (ret[2]) {
+      throw takeFromExternrefTable02(ret[1]);
+    }
+    return Automerge2.__wrap(ret[0]);
+  }
+  commit(message, time) {
+    var ptr0 = isLikeNone2(message) ? 0 : passStringToWasm02(message, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN2;
+    const ret = wasm2.automerge_commit(this.__wbg_ptr, ptr0, len0, !isLikeNone2(time), isLikeNone2(time) ? 0 : time);
+    return ret;
+  }
+  delete(obj, prop) {
+    const ret = wasm2.automerge_delete(this.__wbg_ptr, obj, prop);
+    if (ret[1]) {
+      throw takeFromExternrefTable02(ret[0]);
+    }
+  }
+  diff(before, after) {
+    const ret = wasm2.automerge_diff(this.__wbg_ptr, before, after);
+    if (ret[2]) {
+      throw takeFromExternrefTable02(ret[1]);
+    }
+    return takeFromExternrefTable02(ret[0]);
+  }
+  diffIncremental() {
+    const ret = wasm2.automerge_diffIncremental(this.__wbg_ptr);
+    if (ret[2]) {
+      throw takeFromExternrefTable02(ret[1]);
+    }
+    return takeFromExternrefTable02(ret[0]);
+  }
+  diffPath(path, before, after, options) {
+    const ret = wasm2.automerge_diffPath(this.__wbg_ptr, path, before, after, options);
+    if (ret[2]) {
+      throw takeFromExternrefTable02(ret[1]);
+    }
+    return takeFromExternrefTable02(ret[0]);
+  }
+  dump() {
+    wasm2.automerge_dump(this.__wbg_ptr);
+  }
+  emptyChange(message, time) {
+    var ptr0 = isLikeNone2(message) ? 0 : passStringToWasm02(message, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN2;
+    const ret = wasm2.automerge_emptyChange(this.__wbg_ptr, ptr0, len0, !isLikeNone2(time), isLikeNone2(time) ? 0 : time);
+    return ret;
+  }
+  enableFreeze(enable) {
+    const ret = wasm2.automerge_enableFreeze(this.__wbg_ptr, enable);
+    if (ret[2]) {
+      throw takeFromExternrefTable02(ret[1]);
+    }
+    return ret[0] !== 0;
+  }
+  fork(actor, heads) {
+    var ptr0 = isLikeNone2(actor) ? 0 : passStringToWasm02(actor, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN2;
+    const ret = wasm2.automerge_fork(this.__wbg_ptr, ptr0, len0, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable02(ret[1]);
+    }
+    return Automerge2.__wrap(ret[0]);
+  }
+  generateSyncMessage(state) {
+    _assertClass2(state, SyncState2);
+    const ret = wasm2.automerge_generateSyncMessage(this.__wbg_ptr, state.__wbg_ptr);
+    return ret;
+  }
+  get(obj, prop, heads) {
+    const ret = wasm2.automerge_get(this.__wbg_ptr, obj, prop, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable02(ret[1]);
+    }
+    return takeFromExternrefTable02(ret[0]);
+  }
+  getActorId() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm2.automerge_getActorId(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm02(ret[0], ret[1]);
+    } finally {
+      wasm2.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+  getAll(obj, arg, heads) {
+    const ret = wasm2.automerge_getAll(this.__wbg_ptr, obj, arg, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable02(ret[1]);
+    }
+    return takeFromExternrefTable02(ret[0]);
+  }
+  getBlock(text, index, heads) {
+    const ret = wasm2.automerge_getBlock(this.__wbg_ptr, text, index, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable02(ret[1]);
+    }
+    return takeFromExternrefTable02(ret[0]);
+  }
+  getChangeByHash(hash) {
+    const ret = wasm2.automerge_getChangeByHash(this.__wbg_ptr, hash);
+    if (ret[2]) {
+      throw takeFromExternrefTable02(ret[1]);
+    }
+    return takeFromExternrefTable02(ret[0]);
+  }
+  getChangeMetaByHash(hash) {
+    const ret = wasm2.automerge_getChangeMetaByHash(this.__wbg_ptr, hash);
+    if (ret[2]) {
+      throw takeFromExternrefTable02(ret[1]);
+    }
+    return takeFromExternrefTable02(ret[0]);
+  }
+  getChanges(have_deps) {
+    const ret = wasm2.automerge_getChanges(this.__wbg_ptr, have_deps);
+    if (ret[2]) {
+      throw takeFromExternrefTable02(ret[1]);
+    }
+    return takeFromExternrefTable02(ret[0]);
+  }
+  getChangesAdded(other) {
+    _assertClass2(other, Automerge2);
+    const ret = wasm2.automerge_getChangesAdded(this.__wbg_ptr, other.__wbg_ptr);
+    return ret;
+  }
+  getChangesMeta(have_deps) {
+    const ret = wasm2.automerge_getChangesMeta(this.__wbg_ptr, have_deps);
+    if (ret[2]) {
+      throw takeFromExternrefTable02(ret[1]);
+    }
+    return takeFromExternrefTable02(ret[0]);
+  }
+  getCursor(obj, position, heads, move_cursor) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const ret = wasm2.automerge_getCursor(this.__wbg_ptr, obj, position, heads, move_cursor);
+      var ptr1 = ret[0];
+      var len1 = ret[1];
+      if (ret[3]) {
+        ptr1 = 0;
+        len1 = 0;
+        throw takeFromExternrefTable02(ret[2]);
+      }
+      deferred2_0 = ptr1;
+      deferred2_1 = len1;
+      return getStringFromWasm02(ptr1, len1);
+    } finally {
+      wasm2.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+  }
+  getCursorPosition(obj, cursor, heads) {
+    const ret = wasm2.automerge_getCursorPosition(this.__wbg_ptr, obj, cursor, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable02(ret[1]);
+    }
+    return ret[0];
+  }
+  getDecodedChangeByHash(hash) {
+    const ret = wasm2.automerge_getDecodedChangeByHash(this.__wbg_ptr, hash);
+    if (ret[2]) {
+      throw takeFromExternrefTable02(ret[1]);
+    }
+    return takeFromExternrefTable02(ret[0]);
+  }
+  getHeads() {
+    const ret = wasm2.automerge_getHeads(this.__wbg_ptr);
+    return ret;
+  }
+  getLastLocalChange() {
+    const ret = wasm2.automerge_getLastLocalChange(this.__wbg_ptr);
+    return ret;
+  }
+  getMissingDeps(heads) {
+    const ret = wasm2.automerge_getMissingDeps(this.__wbg_ptr, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable02(ret[1]);
+    }
+    return takeFromExternrefTable02(ret[0]);
+  }
+  getWithType(obj, prop, heads) {
+    const ret = wasm2.automerge_getWithType(this.__wbg_ptr, obj, prop, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable02(ret[1]);
+    }
+    return takeFromExternrefTable02(ret[0]);
+  }
+  hasOurChanges(state) {
+    _assertClass2(state, SyncState2);
+    const ret = wasm2.automerge_hasOurChanges(this.__wbg_ptr, state.__wbg_ptr);
+    return ret !== 0;
+  }
+  increment(obj, prop, value) {
+    const ret = wasm2.automerge_increment(this.__wbg_ptr, obj, prop, value);
+    if (ret[1]) {
+      throw takeFromExternrefTable02(ret[0]);
+    }
+  }
+  insert(obj, index, value, datatype) {
+    const ret = wasm2.automerge_insert(this.__wbg_ptr, obj, index, value, datatype);
+    if (ret[1]) {
+      throw takeFromExternrefTable02(ret[0]);
+    }
+  }
+  insertObject(obj, index, value) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const ret = wasm2.automerge_insertObject(this.__wbg_ptr, obj, index, value);
+      var ptr1 = ret[0];
+      var len1 = ret[1];
+      if (ret[3]) {
+        ptr1 = 0;
+        len1 = 0;
+        throw takeFromExternrefTable02(ret[2]);
+      }
+      deferred2_0 = ptr1;
+      deferred2_1 = len1;
+      return getStringFromWasm02(ptr1, len1);
+    } finally {
+      wasm2.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+  }
+  integrate() {
+    wasm2.automerge_integrate(this.__wbg_ptr);
+  }
+  isolate(heads) {
+    const ret = wasm2.automerge_isolate(this.__wbg_ptr, heads);
+    if (ret[1]) {
+      throw takeFromExternrefTable02(ret[0]);
+    }
+  }
+  joinBlock(obj, index) {
+    const ret = wasm2.automerge_joinBlock(this.__wbg_ptr, obj, index);
+    if (ret[1]) {
+      throw takeFromExternrefTable02(ret[0]);
+    }
+  }
+  keys(obj, heads) {
+    const ret = wasm2.automerge_keys(this.__wbg_ptr, obj, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable02(ret[1]);
+    }
+    return takeFromExternrefTable02(ret[0]);
+  }
+  length(obj, heads) {
+    const ret = wasm2.automerge_length(this.__wbg_ptr, obj, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable02(ret[1]);
+    }
+    return ret[0];
+  }
+  loadIncremental(data) {
+    const ret = wasm2.automerge_loadIncremental(this.__wbg_ptr, data);
+    if (ret[2]) {
+      throw takeFromExternrefTable02(ret[1]);
+    }
+    return ret[0];
+  }
+  mark(obj, range, name, value, datatype) {
+    const ret = wasm2.automerge_mark(this.__wbg_ptr, obj, range, name, value, datatype);
+    if (ret[1]) {
+      throw takeFromExternrefTable02(ret[0]);
+    }
+  }
+  marks(obj, heads) {
+    const ret = wasm2.automerge_marks(this.__wbg_ptr, obj, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable02(ret[1]);
+    }
+    return takeFromExternrefTable02(ret[0]);
+  }
+  marksAt(obj, index, heads) {
+    const ret = wasm2.automerge_marksAt(this.__wbg_ptr, obj, index, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable02(ret[1]);
+    }
+    return takeFromExternrefTable02(ret[0]);
+  }
+  materialize(obj, heads, meta) {
+    const ret = wasm2.automerge_materialize(this.__wbg_ptr, obj, heads, meta);
+    if (ret[2]) {
+      throw takeFromExternrefTable02(ret[1]);
+    }
+    return takeFromExternrefTable02(ret[0]);
+  }
+  merge(other) {
+    _assertClass2(other, Automerge2);
+    const ret = wasm2.automerge_merge(this.__wbg_ptr, other.__wbg_ptr);
+    if (ret[2]) {
+      throw takeFromExternrefTable02(ret[1]);
+    }
+    return takeFromExternrefTable02(ret[0]);
+  }
+  static new(actor) {
+    var ptr0 = isLikeNone2(actor) ? 0 : passStringToWasm02(actor, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN2;
+    const ret = wasm2.automerge_new(ptr0, len0);
+    if (ret[2]) {
+      throw takeFromExternrefTable02(ret[1]);
+    }
+    return Automerge2.__wrap(ret[0]);
+  }
+  objInfo(obj, heads) {
+    const ret = wasm2.automerge_objInfo(this.__wbg_ptr, obj, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable02(ret[1]);
+    }
+    return takeFromExternrefTable02(ret[0]);
+  }
+  pendingOps() {
+    const ret = wasm2.automerge_pendingOps(this.__wbg_ptr);
+    return ret;
+  }
+  push(obj, value, datatype) {
+    const ret = wasm2.automerge_push(this.__wbg_ptr, obj, value, datatype);
+    if (ret[1]) {
+      throw takeFromExternrefTable02(ret[0]);
+    }
+  }
+  pushObject(obj, value) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const ret = wasm2.automerge_pushObject(this.__wbg_ptr, obj, value);
+      var ptr1 = ret[0];
+      var len1 = ret[1];
+      if (ret[3]) {
+        ptr1 = 0;
+        len1 = 0;
+        throw takeFromExternrefTable02(ret[2]);
+      }
+      deferred2_0 = ptr1;
+      deferred2_1 = len1;
+      return getStringFromWasm02(ptr1, len1);
+    } finally {
+      wasm2.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+  }
+  put(obj, prop, value, datatype) {
+    const ret = wasm2.automerge_put(this.__wbg_ptr, obj, prop, value, datatype);
+    if (ret[1]) {
+      throw takeFromExternrefTable02(ret[0]);
+    }
+  }
+  putObject(obj, prop, value) {
+    const ret = wasm2.automerge_putObject(this.__wbg_ptr, obj, prop, value);
+    if (ret[2]) {
+      throw takeFromExternrefTable02(ret[1]);
+    }
+    return takeFromExternrefTable02(ret[0]);
+  }
+  receiveSyncMessage(state, message) {
+    _assertClass2(state, SyncState2);
+    const ret = wasm2.automerge_receiveSyncMessage(this.__wbg_ptr, state.__wbg_ptr, message);
+    if (ret[1]) {
+      throw takeFromExternrefTable02(ret[0]);
+    }
+  }
+  registerDatatype(datatype, construct, deconstruct) {
+    const ret = wasm2.automerge_registerDatatype(this.__wbg_ptr, datatype, construct, deconstruct);
+    if (ret[1]) {
+      throw takeFromExternrefTable02(ret[0]);
+    }
+  }
+  resetDiffCursor() {
+    wasm2.automerge_resetDiffCursor(this.__wbg_ptr);
+  }
+  rollback() {
+    const ret = wasm2.automerge_rollback(this.__wbg_ptr);
+    return ret;
+  }
+  save() {
+    const ret = wasm2.automerge_save(this.__wbg_ptr);
+    return ret;
+  }
+  saveAndVerify() {
+    const ret = wasm2.automerge_saveAndVerify(this.__wbg_ptr);
+    if (ret[2]) {
+      throw takeFromExternrefTable02(ret[1]);
+    }
+    return takeFromExternrefTable02(ret[0]);
+  }
+  saveBundle(hashes) {
+    const ret = wasm2.automerge_saveBundle(this.__wbg_ptr, hashes);
+    if (ret[2]) {
+      throw takeFromExternrefTable02(ret[1]);
+    }
+    return takeFromExternrefTable02(ret[0]);
+  }
+  saveIncremental() {
+    const ret = wasm2.automerge_saveIncremental(this.__wbg_ptr);
+    return ret;
+  }
+  saveNoCompress() {
+    const ret = wasm2.automerge_saveNoCompress(this.__wbg_ptr);
+    return ret;
+  }
+  saveSince(heads) {
+    const ret = wasm2.automerge_saveSince(this.__wbg_ptr, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable02(ret[1]);
+    }
+    return takeFromExternrefTable02(ret[0]);
+  }
+  spans(obj, heads) {
+    const ret = wasm2.automerge_spans(this.__wbg_ptr, obj, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable02(ret[1]);
+    }
+    return takeFromExternrefTable02(ret[0]);
+  }
+  splice(obj, start, delete_count, text) {
+    const ret = wasm2.automerge_splice(this.__wbg_ptr, obj, start, delete_count, text);
+    if (ret[1]) {
+      throw takeFromExternrefTable02(ret[0]);
+    }
+  }
+  splitBlock(obj, index, block) {
+    const ret = wasm2.automerge_splitBlock(this.__wbg_ptr, obj, index, block);
+    if (ret[1]) {
+      throw takeFromExternrefTable02(ret[0]);
+    }
+  }
+  stats() {
+    const ret = wasm2.automerge_stats(this.__wbg_ptr);
+    return ret;
+  }
+  text(obj, heads) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const ret = wasm2.automerge_text(this.__wbg_ptr, obj, heads);
+      var ptr1 = ret[0];
+      var len1 = ret[1];
+      if (ret[3]) {
+        ptr1 = 0;
+        len1 = 0;
+        throw takeFromExternrefTable02(ret[2]);
+      }
+      deferred2_0 = ptr1;
+      deferred2_1 = len1;
+      return getStringFromWasm02(ptr1, len1);
+    } finally {
+      wasm2.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+  }
+  toJS(meta) {
+    const ret = wasm2.automerge_toJS(this.__wbg_ptr, meta);
+    if (ret[2]) {
+      throw takeFromExternrefTable02(ret[1]);
+    }
+    return takeFromExternrefTable02(ret[0]);
+  }
+  topoHistoryTraversal() {
+    const ret = wasm2.automerge_topoHistoryTraversal(this.__wbg_ptr);
+    return ret;
+  }
+  unmark(obj, range, name) {
+    const ret = wasm2.automerge_unmark(this.__wbg_ptr, obj, range, name);
+    if (ret[1]) {
+      throw takeFromExternrefTable02(ret[0]);
+    }
+  }
+  updateBlock(obj, index, block) {
+    const ret = wasm2.automerge_updateBlock(this.__wbg_ptr, obj, index, block);
+    if (ret[1]) {
+      throw takeFromExternrefTable02(ret[0]);
+    }
+  }
+  updateDiffCursor() {
+    wasm2.automerge_updateDiffCursor(this.__wbg_ptr);
+  }
+  updateSpans(obj, args, config) {
+    const ret = wasm2.automerge_updateSpans(this.__wbg_ptr, obj, args, config);
+    if (ret[1]) {
+      throw takeFromExternrefTable02(ret[0]);
+    }
+  }
+  updateText(obj, new_text) {
+    const ret = wasm2.automerge_updateText(this.__wbg_ptr, obj, new_text);
+    if (ret[1]) {
+      throw takeFromExternrefTable02(ret[0]);
+    }
+  }
+}
+
+class SyncState2 {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(SyncState2.prototype);
+    obj.__wbg_ptr = ptr;
+    SyncStateFinalization2.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    SyncStateFinalization2.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm2.__wbg_syncstate_free(ptr, 0);
+  }
+  clone() {
+    const ret = wasm2.syncstate_clone(this.__wbg_ptr);
+    return SyncState2.__wrap(ret);
+  }
+  get lastSentHeads() {
+    const ret = wasm2.syncstate_lastSentHeads(this.__wbg_ptr);
+    return ret;
+  }
+  set lastSentHeads(heads) {
+    const ret = wasm2.syncstate_set_lastSentHeads(this.__wbg_ptr, heads);
+    if (ret[1]) {
+      throw takeFromExternrefTable02(ret[0]);
+    }
+  }
+  set sentHashes(hashes) {
+    const ret = wasm2.syncstate_set_sentHashes(this.__wbg_ptr, hashes);
+    if (ret[1]) {
+      throw takeFromExternrefTable02(ret[0]);
+    }
+  }
+  get sharedHeads() {
+    const ret = wasm2.syncstate_sharedHeads(this.__wbg_ptr);
+    return ret;
+  }
+}
+function create2(options) {
+  const ret = wasm2.create(options);
+  if (ret[2]) {
+    throw takeFromExternrefTable02(ret[1]);
+  }
+  return Automerge2.__wrap(ret[0]);
+}
+function decodeChange2(change) {
+  const ret = wasm2.decodeChange(change);
+  if (ret[2]) {
+    throw takeFromExternrefTable02(ret[1]);
+  }
+  return takeFromExternrefTable02(ret[0]);
+}
+function decodeSyncMessage2(msg) {
+  const ret = wasm2.decodeSyncMessage(msg);
+  if (ret[2]) {
+    throw takeFromExternrefTable02(ret[1]);
+  }
+  return takeFromExternrefTable02(ret[0]);
+}
+function decodeSyncState2(data) {
+  const ret = wasm2.decodeSyncState(data);
+  if (ret[2]) {
+    throw takeFromExternrefTable02(ret[1]);
+  }
+  return SyncState2.__wrap(ret[0]);
+}
+function encodeChange2(change) {
+  const ret = wasm2.encodeChange(change);
+  if (ret[2]) {
+    throw takeFromExternrefTable02(ret[1]);
+  }
+  return takeFromExternrefTable02(ret[0]);
+}
+function encodeSyncMessage2(message) {
+  const ret = wasm2.encodeSyncMessage(message);
+  if (ret[2]) {
+    throw takeFromExternrefTable02(ret[1]);
+  }
+  return takeFromExternrefTable02(ret[0]);
+}
+function encodeSyncState2(state) {
+  _assertClass2(state, SyncState2);
+  const ret = wasm2.encodeSyncState(state.__wbg_ptr);
+  return ret;
+}
+function exportSyncState2(state) {
+  _assertClass2(state, SyncState2);
+  const ret = wasm2.exportSyncState(state.__wbg_ptr);
+  return ret;
+}
+function importSyncState2(state) {
+  const ret = wasm2.importSyncState(state);
+  if (ret[2]) {
+    throw takeFromExternrefTable02(ret[1]);
+  }
+  return SyncState2.__wrap(ret[0]);
+}
+function initSyncState2() {
+  const ret = wasm2.initSyncState();
+  return SyncState2.__wrap(ret);
+}
+function load2(data, options) {
+  const ret = wasm2.load(data, options);
+  if (ret[2]) {
+    throw takeFromExternrefTable02(ret[1]);
+  }
+  return Automerge2.__wrap(ret[0]);
+}
+function readBundle2(bundle) {
+  const ret = wasm2.readBundle(bundle);
+  if (ret[2]) {
+    throw takeFromExternrefTable02(ret[1]);
+  }
+  return takeFromExternrefTable02(ret[0]);
+}
+function wasmReleaseInfo2() {
+  const ret = wasm2.wasmReleaseInfo();
+  return ret;
+}
+function _assertClass2(instance, klass) {
+  if (!(instance instanceof klass)) {
+    throw new Error(`expected instance of ${klass.name}`);
+  }
+}
+function getStringFromWasm02(ptr, len) {
+  ptr = ptr >>> 0;
+  return decodeText2(ptr, len);
+}
+function getUint8ArrayMemory02() {
+  if (cachedUint8ArrayMemory02 === null || cachedUint8ArrayMemory02.byteLength === 0) {
+    cachedUint8ArrayMemory02 = new Uint8Array(wasm2.memory.buffer);
+  }
+  return cachedUint8ArrayMemory02;
+}
+function isLikeNone2(x) {
+  return x === undefined || x === null;
+}
+function passStringToWasm02(arg, malloc, realloc) {
+  if (realloc === undefined) {
+    const buf = cachedTextEncoder2.encode(arg);
+    const ptr2 = malloc(buf.length, 1) >>> 0;
+    getUint8ArrayMemory02().subarray(ptr2, ptr2 + buf.length).set(buf);
+    WASM_VECTOR_LEN2 = buf.length;
+    return ptr2;
+  }
+  let len = arg.length;
+  let ptr = malloc(len, 1) >>> 0;
+  const mem = getUint8ArrayMemory02();
+  let offset = 0;
+  for (;offset < len; offset++) {
+    const code = arg.charCodeAt(offset);
+    if (code > 127)
+      break;
+    mem[ptr + offset] = code;
+  }
+  if (offset !== len) {
+    if (offset !== 0) {
+      arg = arg.slice(offset);
+    }
+    ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+    const view = getUint8ArrayMemory02().subarray(ptr + offset, ptr + len);
+    const ret = cachedTextEncoder2.encodeInto(arg, view);
+    offset += ret.written;
+    ptr = realloc(ptr, len, offset, 1) >>> 0;
+  }
+  WASM_VECTOR_LEN2 = offset;
+  return ptr;
+}
+function takeFromExternrefTable02(idx) {
+  const value = wasm2.__wbindgen_externrefs.get(idx);
+  wasm2.__externref_table_dealloc(idx);
+  return value;
+}
+function decodeText2(ptr, len) {
+  numBytesDecoded2 += len;
+  if (numBytesDecoded2 >= MAX_SAFARI_DECODE_BYTES2) {
+    cachedTextDecoder2 = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+    cachedTextDecoder2.decode();
+    numBytesDecoded2 = len;
+  }
+  return cachedTextDecoder2.decode(getUint8ArrayMemory02().subarray(ptr, ptr + len));
+}
+function __wbg_set_wasm(val) {
+  wasm2 = val;
+}
+var AutomergeFinalization2, SyncStateFinalization2, cachedUint8ArrayMemory02 = null, cachedTextDecoder2, MAX_SAFARI_DECODE_BYTES2 = 2146435072, numBytesDecoded2 = 0, cachedTextEncoder2, WASM_VECTOR_LEN2 = 0, wasm2;
+var init_automerge_wasm_bg2 = __esm(() => {
+  if (Symbol.dispose)
+    Automerge2.prototype[Symbol.dispose] = Automerge2.prototype.free;
+  if (Symbol.dispose)
+    SyncState2.prototype[Symbol.dispose] = SyncState2.prototype.free;
+  AutomergeFinalization2 = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm2.__wbg_automerge_free(ptr >>> 0, 1));
+  SyncStateFinalization2 = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm2.__wbg_syncstate_free(ptr >>> 0, 1));
+  cachedTextDecoder2 = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+  cachedTextDecoder2.decode();
+  cachedTextEncoder2 = new TextEncoder;
+  if (!("encodeInto" in cachedTextEncoder2)) {
+    cachedTextEncoder2.encodeInto = function(arg, view) {
+      const buf = cachedTextEncoder2.encode(arg);
+      view.set(buf);
+      return {
+        read: arg.length,
+        written: buf.length
+      };
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@automerge+automerge@3.2.4/node_modules/@automerge/automerge/dist/mjs/wasm_bindgen_output/bundler/automerge_wasm.js
+var exports_automerge_wasm2 = {};
+__export(exports_automerge_wasm2, {
+  wasmReleaseInfo: () => wasmReleaseInfo2,
+  readBundle: () => readBundle2,
+  load: () => load2,
+  initSyncState: () => initSyncState2,
+  importSyncState: () => importSyncState2,
+  exportSyncState: () => exportSyncState2,
+  encodeSyncState: () => encodeSyncState2,
+  encodeSyncMessage: () => encodeSyncMessage2,
+  encodeChange: () => encodeChange2,
+  decodeSyncState: () => decodeSyncState2,
+  decodeSyncMessage: () => decodeSyncMessage2,
+  decodeChange: () => decodeChange2,
+  create: () => create2,
+  SyncState: () => SyncState2,
+  Automerge: () => Automerge2
+});
+var init_automerge_wasm2 = __esm(() => {
+  init_automerge_wasm_bg();
+  init_automerge_wasm_bg2();
+  init_automerge_wasm_bg2();
+  __wbg_set_wasm(exports_automerge_wasm_bg);
+  undefined();
+});
+
+// ../../node_modules/.pnpm/@automerge+automerge@3.2.4/node_modules/@automerge/automerge/dist/mjs/constants.js
+var STATE, TRACE, OBJECT_ID, IS_PROXY, CLEAR_CACHE, UINT, INT, F64, COUNTER, TEXT, IMMUTABLE_STRING;
+var init_constants = __esm(() => {
+  STATE = Symbol.for("_am_meta");
+  TRACE = Symbol.for("_am_trace");
+  OBJECT_ID = Symbol.for("_am_objectId");
+  IS_PROXY = Symbol.for("_am_isProxy");
+  CLEAR_CACHE = Symbol.for("_am_clearCache");
+  UINT = Symbol.for("_am_uint");
+  INT = Symbol.for("_am_int");
+  F64 = Symbol.for("_am_f64");
+  COUNTER = Symbol.for("_am_counter");
+  TEXT = Symbol.for("_am_text");
+  IMMUTABLE_STRING = Symbol.for("_am_immutableString");
+});
+
+// ../../node_modules/.pnpm/@automerge+automerge@3.2.4/node_modules/@automerge/automerge/dist/mjs/counter.js
+class Counter {
+  constructor(value) {
+    this.value = value || 0;
+    Reflect.defineProperty(this, COUNTER, { value: true });
+  }
+  valueOf() {
+    return this.value;
+  }
+  toString() {
+    return this.valueOf().toString();
+  }
+  toJSON() {
+    return this.value;
+  }
+  increment(_delta) {
+    throw new Error("Counters should not be incremented outside of a change callback");
+  }
+  decrement(_delta) {
+    throw new Error("Counters should not be decremented outside of a change callback");
+  }
+}
+function getWriteableCounter(value, context, path, objectId, key) {
+  return new WriteableCounter(value, context, path, objectId, key);
+}
+var WriteableCounter;
+var init_counter = __esm(() => {
+  init_constants();
+  WriteableCounter = class WriteableCounter extends Counter {
+    constructor(value, context, path, objectId, key) {
+      super(value);
+      this.context = context;
+      this.path = path;
+      this.objectId = objectId;
+      this.key = key;
+    }
+    increment(delta) {
+      delta = typeof delta === "number" ? delta : 1;
+      this.context.increment(this.objectId, this.key, delta);
+      this.value += delta;
+      return this.value;
+    }
+    decrement(delta) {
+      return this.increment(typeof delta === "number" ? -delta : -1);
+    }
+  };
+});
+
+// ../../node_modules/.pnpm/@automerge+automerge@3.2.4/node_modules/@automerge/automerge/dist/mjs/immutable_string.js
+class ImmutableString {
+  constructor(val) {
+    this[_a] = true;
+    this.val = val;
+  }
+  toString() {
+    return this.val;
+  }
+  toJSON() {
+    return this.val;
+  }
+}
+var _a;
+var init_immutable_string = __esm(() => {
+  init_constants();
+  _a = IMMUTABLE_STRING;
+});
+
+// ../../node_modules/.pnpm/@automerge+automerge@3.2.4/node_modules/@automerge/automerge/dist/mjs/proxies.js
+function parseListIndex(key) {
+  if (typeof key === "string" && /^[0-9]+$/.test(key))
+    key = parseInt(key, 10);
+  if (typeof key !== "number") {
+    return key;
+  }
+  if (key < 0 || isNaN(key) || key === Infinity || key === -Infinity) {
+    throw new RangeError("A list index must be positive, but you passed " + key);
+  }
+  return key;
+}
+function valueAt(target, prop) {
+  const { context, objectId, path } = target;
+  const value = context.getWithType(objectId, prop);
+  if (value === null) {
+    return;
+  }
+  const datatype = value[0];
+  const val = value[1];
+  switch (datatype) {
+    case undefined:
+      return;
+    case "map":
+      return mapProxy(context, val, [...path, prop]);
+    case "list":
+      return listProxy(context, val, [...path, prop]);
+    case "text":
+      return context.text(val);
+    case "str":
+      return new ImmutableString(val);
+    case "uint":
+      return val;
+    case "int":
+      return val;
+    case "f64":
+      return val;
+    case "boolean":
+      return val;
+    case "null":
+      return null;
+    case "bytes":
+      return val;
+    case "timestamp":
+      return val;
+    case "counter": {
+      const counter = getWriteableCounter(val, context, path, objectId, prop);
+      return counter;
+    }
+    default:
+      throw RangeError(`datatype ${datatype} unimplemented`);
+  }
+}
+function import_value(value, path, context) {
+  const type = typeof value;
+  switch (type) {
+    case "object":
+      if (value == null) {
+        return [null, "null"];
+      } else if (value[UINT]) {
+        return [value.value, "uint"];
+      } else if (value[INT]) {
+        return [value.value, "int"];
+      } else if (value[F64]) {
+        return [value.value, "f64"];
+      } else if (value[COUNTER]) {
+        return [value.value, "counter"];
+      } else if (value instanceof Date) {
+        return [value.getTime(), "timestamp"];
+      } else if (isImmutableString(value)) {
+        return [value.toString(), "str"];
+      } else if (value instanceof Uint8Array) {
+        return [value, "bytes"];
+      } else if (value instanceof Array) {
+        return [value, "list"];
+      } else if (Object.prototype.toString.call(value) === "[object Object]") {
+        return [value, "map"];
+      } else if (isSameDocument(value, context)) {
+        throw new RangeError("Cannot create a reference to an existing document object");
+      } else {
+        throw new RangeError(`Cannot assign unknown object: ${value}`);
+      }
+    case "boolean":
+      return [value, "boolean"];
+    case "bigint":
+      if (value > MAX_I64) {
+        return [value, "uint"];
+      } else {
+        return [value, "int"];
+      }
+    case "number":
+      if (Number.isInteger(value)) {
+        return [value, "int"];
+      } else {
+        return [value, "f64"];
+      }
+    case "string":
+      return [value, "text"];
+    case "undefined":
+      throw new RangeError([
+        `Cannot assign undefined value at ${printPath(path)}, `,
+        "because `undefined` is not a valid JSON data type. ",
+        "You might consider setting the property's value to `null`, ",
+        "or using `delete` to remove it altogether."
+      ].join(""));
+    default:
+      throw new RangeError([
+        `Cannot assign ${type} value at ${printPath(path)}. `,
+        `All JSON primitive datatypes (object, array, string, number, boolean, null) `,
+        `are supported in an Automerge document; ${type} values are not. `
+      ].join(""));
+  }
+}
+function isSameDocument(val, context) {
+  var _b, _c;
+  if (val instanceof Date) {
+    return false;
+  }
+  if (val && ((_c = (_b = val[STATE]) === null || _b === undefined ? undefined : _b.handle) === null || _c === undefined ? undefined : _c.__wbg_ptr) === context.__wbg_ptr) {
+    return true;
+  }
+  return false;
+}
+function mapProxy(context, objectId, path) {
+  const target = {
+    context,
+    objectId,
+    path: path || [],
+    cache: {}
+  };
+  const proxied = {};
+  Object.assign(proxied, target);
+  const result = new Proxy(proxied, MapHandler);
+  return result;
+}
+function listProxy(context, objectId, path) {
+  const target = {
+    context,
+    objectId,
+    path: path || [],
+    cache: {}
+  };
+  const proxied = [];
+  Object.assign(proxied, target);
+  return new Proxy(proxied, ListHandler);
+}
+function rootProxy(context) {
+  return mapProxy(context, "_root", []);
+}
+function listMethods(target) {
+  const { context, objectId, path } = target;
+  const methods = {
+    at(index) {
+      return valueAt(target, index);
+    },
+    deleteAt(index, numDelete) {
+      if (typeof numDelete === "number") {
+        context.splice(objectId, index, numDelete);
+      } else {
+        context.delete(objectId, index);
+      }
+      return this;
+    },
+    fill(val, start, end) {
+      const [value, datatype] = import_value(val, [...path, start], context);
+      const length = context.length(objectId);
+      start = parseListIndex(start || 0);
+      end = parseListIndex(end || length);
+      for (let i = start;i < Math.min(end, length); i++) {
+        if (datatype === "list" || datatype === "map") {
+          context.putObject(objectId, i, value);
+        } else if (datatype === "text") {
+          context.putObject(objectId, i, value);
+        } else {
+          context.put(objectId, i, value, datatype);
+        }
+      }
+      return this;
+    },
+    indexOf(searchElement, start = 0) {
+      const length = context.length(objectId);
+      for (let i = start;i < length; i++) {
+        const valueWithType = context.getWithType(objectId, i);
+        if (!valueWithType) {
+          continue;
+        }
+        const [valType, value] = valueWithType;
+        const isObject = ["map", "list", "text"].includes(valType);
+        if (!isObject) {
+          if (value === searchElement) {
+            return i;
+          } else {
+            continue;
+          }
+        }
+        if (valType === "text" && typeof searchElement === "string") {
+          if (searchElement === valueAt(target, i)) {
+            return i;
+          }
+        }
+        if (searchElement[OBJECT_ID] === value) {
+          return i;
+        }
+      }
+      return -1;
+    },
+    insertAt(index, ...values) {
+      this.splice(index, 0, ...values);
+      return this;
+    },
+    pop() {
+      const length = context.length(objectId);
+      if (length == 0) {
+        return;
+      }
+      const last = valueAt(target, length - 1);
+      context.delete(objectId, length - 1);
+      return last;
+    },
+    push(...values) {
+      const len = context.length(objectId);
+      this.splice(len, 0, ...values);
+      return context.length(objectId);
+    },
+    shift() {
+      if (context.length(objectId) == 0)
+        return;
+      const first = valueAt(target, 0);
+      context.delete(objectId, 0);
+      return first;
+    },
+    splice(index, del, ...vals) {
+      index = parseListIndex(index);
+      if (typeof del !== "number") {
+        del = context.length(objectId) - index;
+      }
+      del = parseListIndex(del);
+      for (const val of vals) {
+        if (isSameDocument(val, context)) {
+          throw new RangeError("Cannot create a reference to an existing document object");
+        }
+      }
+      const result = [];
+      for (let i = 0;i < del; i++) {
+        const value = valueAt(target, index);
+        if (value !== undefined) {
+          result.push(value);
+        }
+        context.delete(objectId, index);
+      }
+      const values = vals.map((val, index2) => {
+        try {
+          return import_value(val, [...path], context);
+        } catch (e) {
+          if (e instanceof RangeError) {
+            throw new RangeError(`${e.message} (at index ${index2} in the input)`);
+          } else {
+            throw e;
+          }
+        }
+      });
+      for (const [value, datatype] of values) {
+        switch (datatype) {
+          case "list": {
+            const list = context.insertObject(objectId, index, []);
+            const proxyList = listProxy(context, list, [...path, index]);
+            proxyList.splice(0, 0, ...value);
+            break;
+          }
+          case "text": {
+            context.insertObject(objectId, index, value);
+            break;
+          }
+          case "map": {
+            const map = context.insertObject(objectId, index, {});
+            const proxyMap = mapProxy(context, map, [...path, index]);
+            for (const key in value) {
+              proxyMap[key] = value[key];
+            }
+            break;
+          }
+          default:
+            context.insert(objectId, index, value, datatype);
+        }
+        index += 1;
+      }
+      return result;
+    },
+    unshift(...values) {
+      this.splice(0, 0, ...values);
+      return context.length(objectId);
+    },
+    entries() {
+      let i = 0;
+      const iterator = {
+        next: () => {
+          const value = valueAt(target, i);
+          if (value === undefined) {
+            return { value: undefined, done: true };
+          } else {
+            return { value: [i++, value], done: false };
+          }
+        },
+        [Symbol.iterator]() {
+          return this;
+        }
+      };
+      return iterator;
+    },
+    keys() {
+      let i = 0;
+      const len = context.length(objectId);
+      const iterator = {
+        next: () => {
+          if (i < len) {
+            return { value: i++, done: false };
+          }
+          return { value: undefined, done: true };
+        },
+        [Symbol.iterator]() {
+          return this;
+        }
+      };
+      return iterator;
+    },
+    values() {
+      let i = 0;
+      const iterator = {
+        next: () => {
+          const value = valueAt(target, i++);
+          if (value === undefined) {
+            return { value: undefined, done: true };
+          } else {
+            return { value, done: false };
+          }
+        },
+        [Symbol.iterator]() {
+          return this;
+        }
+      };
+      return iterator;
+    },
+    toArray() {
+      const list = [];
+      let value;
+      do {
+        value = valueAt(target, list.length);
+        if (value !== undefined) {
+          list.push(value);
+        }
+      } while (value !== undefined);
+      return list;
+    },
+    map(f) {
+      return this.toArray().map(f);
+    },
+    toString() {
+      return this.toArray().toString();
+    },
+    toLocaleString() {
+      return this.toArray().toLocaleString();
+    },
+    forEach(f) {
+      return this.toArray().forEach(f);
+    },
+    concat(other) {
+      return this.toArray().concat(other);
+    },
+    every(f) {
+      return this.toArray().every(f);
+    },
+    filter(f) {
+      return this.toArray().filter(f);
+    },
+    find(f) {
+      let index = 0;
+      for (const v of this) {
+        if (f(v, index)) {
+          return v;
+        }
+        index += 1;
+      }
+    },
+    findIndex(f) {
+      let index = 0;
+      for (const v of this) {
+        if (f(v, index)) {
+          return index;
+        }
+        index += 1;
+      }
+      return -1;
+    },
+    includes(elem) {
+      return this.find((e) => e === elem) !== undefined;
+    },
+    join(sep) {
+      return this.toArray().join(sep);
+    },
+    reduce(f, initialValue) {
+      return this.toArray().reduce(f, initialValue);
+    },
+    reduceRight(f, initialValue) {
+      return this.toArray().reduceRight(f, initialValue);
+    },
+    lastIndexOf(search, fromIndex = Infinity) {
+      return this.toArray().lastIndexOf(search, fromIndex);
+    },
+    slice(index, num) {
+      return this.toArray().slice(index, num);
+    },
+    some(f) {
+      let index = 0;
+      for (const v of this) {
+        if (f(v, index)) {
+          return true;
+        }
+        index += 1;
+      }
+      return false;
+    },
+    [Symbol.iterator]: function* () {
+      let i = 0;
+      let value = valueAt(target, i);
+      while (value !== undefined) {
+        yield value;
+        i += 1;
+        value = valueAt(target, i);
+      }
+    }
+  };
+  return methods;
+}
+function printPath(path) {
+  const jsonPointerComponents = path.map((component) => {
+    if (typeof component === "number") {
+      return component.toString();
+    } else if (typeof component === "string") {
+      return component.replace(/~/g, "~0").replace(/\//g, "~1");
+    }
+  });
+  if (path.length === 0) {
+    return "";
+  } else {
+    return "/" + jsonPointerComponents.join("/");
+  }
+}
+function isImmutableString(obj) {
+  return typeof obj === "object" && obj !== null && Object.prototype.hasOwnProperty.call(obj, IMMUTABLE_STRING);
+}
+function isCounter(obj) {
+  return typeof obj === "object" && obj !== null && Object.prototype.hasOwnProperty.call(obj, COUNTER);
+}
+var MAX_I64, MapHandler, ListHandler;
+var init_proxies = __esm(() => {
+  init_counter();
+  init_constants();
+  init_immutable_string();
+  MAX_I64 = BigInt("9223372036854775807");
+  MapHandler = {
+    get(target, key) {
+      const { context, objectId, cache } = target;
+      if (key === Symbol.toStringTag) {
+        return target[Symbol.toStringTag];
+      }
+      if (key === OBJECT_ID)
+        return objectId;
+      if (key === IS_PROXY)
+        return true;
+      if (key === TRACE)
+        return target.trace;
+      if (key === STATE)
+        return { handle: context };
+      if (!cache[key]) {
+        cache[key] = valueAt(target, key);
+      }
+      return cache[key];
+    },
+    set(target, key, val) {
+      const { context, objectId, path } = target;
+      target.cache = {};
+      if (isSameDocument(val, context)) {
+        throw new RangeError("Cannot create a reference to an existing document object");
+      }
+      if (key === TRACE) {
+        target.trace = val;
+        return true;
+      }
+      if (key === CLEAR_CACHE) {
+        return true;
+      }
+      const [value, datatype] = import_value(val, [...path, key], context);
+      switch (datatype) {
+        case "list": {
+          const list = context.putObject(objectId, key, []);
+          const proxyList = listProxy(context, list, [...path, key]);
+          for (let i = 0;i < value.length; i++) {
+            proxyList[i] = value[i];
+          }
+          break;
+        }
+        case "text": {
+          context.putObject(objectId, key, value);
+          break;
+        }
+        case "map": {
+          const map = context.putObject(objectId, key, {});
+          const proxyMap = mapProxy(context, map, [...path, key]);
+          for (const key2 in value) {
+            proxyMap[key2] = value[key2];
+          }
+          break;
+        }
+        default:
+          context.put(objectId, key, value, datatype);
+      }
+      return true;
+    },
+    deleteProperty(target, key) {
+      const { context, objectId } = target;
+      target.cache = {};
+      context.delete(objectId, key);
+      return true;
+    },
+    has(target, key) {
+      const value = this.get(target, key);
+      return value !== undefined;
+    },
+    getOwnPropertyDescriptor(target, key) {
+      const value = this.get(target, key);
+      if (typeof value !== "undefined") {
+        return {
+          configurable: true,
+          enumerable: true,
+          value
+        };
+      }
+    },
+    ownKeys(target) {
+      const { context, objectId } = target;
+      const keys = context.keys(objectId);
+      return [...new Set(keys)];
+    }
+  };
+  ListHandler = {
+    get(target, index) {
+      const { context, objectId } = target;
+      index = parseListIndex(index);
+      if (index === Symbol.hasInstance) {
+        return (instance) => {
+          return Array.isArray(instance);
+        };
+      }
+      if (index === Symbol.toStringTag) {
+        return target[Symbol.toStringTag];
+      }
+      if (index === OBJECT_ID)
+        return objectId;
+      if (index === IS_PROXY)
+        return true;
+      if (index === TRACE)
+        return target.trace;
+      if (index === STATE)
+        return { handle: context };
+      if (index === "length")
+        return context.length(objectId);
+      if (typeof index === "number") {
+        return valueAt(target, index);
+      } else {
+        return listMethods(target)[index];
+      }
+    },
+    set(target, index, val) {
+      const { context, objectId, path } = target;
+      index = parseListIndex(index);
+      if (isSameDocument(val, context)) {
+        throw new RangeError("Cannot create a reference to an existing document object");
+      }
+      if (index === CLEAR_CACHE) {
+        return true;
+      }
+      if (index === TRACE) {
+        target.trace = val;
+        return true;
+      }
+      if (typeof index == "string") {
+        throw new RangeError("list index must be a number");
+      }
+      const [value, datatype] = import_value(val, [...path, index], context);
+      switch (datatype) {
+        case "list": {
+          let list;
+          if (index >= context.length(objectId)) {
+            list = context.insertObject(objectId, index, []);
+          } else {
+            list = context.putObject(objectId, index, []);
+          }
+          const proxyList = listProxy(context, list, [...path, index]);
+          proxyList.splice(0, 0, ...value);
+          break;
+        }
+        case "text": {
+          if (index >= context.length(objectId)) {
+            context.insertObject(objectId, index, value);
+          } else {
+            context.putObject(objectId, index, value);
+          }
+          break;
+        }
+        case "map": {
+          let map;
+          if (index >= context.length(objectId)) {
+            map = context.insertObject(objectId, index, {});
+          } else {
+            map = context.putObject(objectId, index, {});
+          }
+          const proxyMap = mapProxy(context, map, [...path, index]);
+          for (const key in value) {
+            proxyMap[key] = value[key];
+          }
+          break;
+        }
+        default:
+          if (index >= context.length(objectId)) {
+            context.insert(objectId, index, value, datatype);
+          } else {
+            context.put(objectId, index, value, datatype);
+          }
+      }
+      return true;
+    },
+    deleteProperty(target, index) {
+      const { context, objectId } = target;
+      index = parseListIndex(index);
+      const elem = context.get(objectId, index);
+      if (elem != null && elem[0] == "counter") {
+        throw new TypeError("Unsupported operation: deleting a counter from a list");
+      }
+      context.delete(objectId, index);
+      return true;
+    },
+    has(target, index) {
+      const { context, objectId } = target;
+      index = parseListIndex(index);
+      if (typeof index === "number") {
+        return index < context.length(objectId);
+      }
+      return index === "length";
+    },
+    getOwnPropertyDescriptor(target, index) {
+      const { context, objectId } = target;
+      if (index === "length")
+        return { writable: true, value: context.length(objectId) };
+      if (index === OBJECT_ID)
+        return { configurable: false, enumerable: false, value: objectId };
+      index = parseListIndex(index);
+      const value = valueAt(target, index);
+      return { configurable: true, enumerable: true, value };
+    },
+    getPrototypeOf(target) {
+      return Object.getPrototypeOf(target);
+    },
+    ownKeys() {
+      const keys = [];
+      keys.push("length");
+      return keys;
+    }
+  };
+});
+
+// ../../node_modules/.pnpm/@automerge+automerge@3.2.4/node_modules/@automerge/automerge/dist/mjs/numbers.js
+class Int {
+  constructor(value) {
+    if (!(Number.isInteger(value) && value <= Number.MAX_SAFE_INTEGER && value >= Number.MIN_SAFE_INTEGER)) {
+      throw new RangeError(`Value ${value} cannot be a uint`);
+    }
+    this.value = value;
+    Reflect.defineProperty(this, INT, { value: true });
+    Object.freeze(this);
+  }
+}
+
+class Uint {
+  constructor(value) {
+    if (!(Number.isInteger(value) && value <= Number.MAX_SAFE_INTEGER && value >= 0)) {
+      throw new RangeError(`Value ${value} cannot be a uint`);
+    }
+    this.value = value;
+    Reflect.defineProperty(this, UINT, { value: true });
+    Object.freeze(this);
+  }
+}
+
+class Float64 {
+  constructor(value) {
+    if (typeof value !== "number") {
+      throw new RangeError(`Value ${value} cannot be a float64`);
+    }
+    this.value = value || 0;
+    Reflect.defineProperty(this, F64, { value: true });
+    Object.freeze(this);
+  }
+}
+var init_numbers = __esm(() => {
+  init_constants();
+});
+
+// ../../node_modules/.pnpm/@automerge+automerge@3.2.4/node_modules/@automerge/automerge/dist/mjs/types.js
+var init_types = __esm(() => {
+  init_counter();
+  init_numbers();
+  init_immutable_string();
+});
+
+// ../../node_modules/.pnpm/@automerge+automerge@3.2.4/node_modules/@automerge/automerge/dist/mjs/generated/release-info.js
+var JS_GIT_HEAD = "b8dfc4845c50633f9d850a5d4e2a4219d518f8ad";
+
+// ../../node_modules/.pnpm/@automerge+automerge@3.2.4/node_modules/@automerge/automerge/dist/mjs/internal_state.js
+function _state(doc, checkroot = true) {
+  if (typeof doc !== "object") {
+    throw new RangeError("must be the document root");
+  }
+  const state = Reflect.get(doc, STATE);
+  if (state === undefined || state == null || checkroot && _obj(doc) !== "_root") {
+    throw new RangeError("must be the document root");
+  }
+  return state;
+}
+function _clear_cache(doc) {
+  Reflect.set(doc, CLEAR_CACHE, true);
+}
+function _trace(doc) {
+  return Reflect.get(doc, TRACE);
+}
+function _obj(doc) {
+  if (!(typeof doc === "object") || doc === null) {
+    return null;
+  }
+  return Reflect.get(doc, OBJECT_ID);
+}
+function _is_proxy(doc) {
+  return !!Reflect.get(doc, IS_PROXY);
+}
+var init_internal_state = __esm(() => {
+  init_constants();
+});
+
+// ../../node_modules/.pnpm/@automerge+automerge@3.2.4/node_modules/@automerge/automerge/dist/mjs/apply_patches.js
+function applyPatch(doc, patch) {
+  let path = resolvePath(doc, patch.path);
+  if (patch.action === "put") {
+    applyPutPatch(doc, path, patch);
+  } else if (patch.action === "insert") {
+    applyInsertPatch(doc, path, patch);
+  } else if (patch.action === "del") {
+    applyDelPatch(doc, path, patch);
+  } else if (patch.action === "splice") {
+    applySplicePatch(doc, path, patch);
+  } else if (patch.action === "inc") {
+    applyIncPatch(doc, path, patch);
+  } else if (patch.action === "mark") {
+    applyMarkPatch(doc, path, patch);
+  } else if (patch.action === "unmark") {
+    applyUnmarkPatch(doc, path, patch);
+  } else if (patch.action === "conflict") {} else {
+    throw new RangeError(`unsupported patch: ${patch}`);
+  }
+}
+function applyPutPatch(doc, path, patch) {
+  let { obj: parent, prop } = pathElemAt(path, -1);
+  parent[prop] = patch.value;
+}
+function applyInsertPatch(doc, path, patch) {
+  let { obj: parent, prop } = pathElemAt(path, -1);
+  if (!Array.isArray(parent)) {
+    throw new RangeError(`target is not an array for patch`);
+  }
+  if (!(typeof prop === "number")) {
+    throw new RangeError(`index is not a number for patch`);
+  }
+  parent.splice(prop, 0, ...patch.values);
+}
+function applyDelPatch(doc, path, patch) {
+  let { obj: parent, prop, parentPath } = pathElemAt(path, -1);
+  if (!(typeof prop === "number")) {
+    throw new RangeError(`index is not a number for patch`);
+  }
+  if (Array.isArray(parent)) {
+    parent.splice(prop, patch.length || 1);
+  } else if (typeof parent === "string") {
+    if (isAutomerge(doc)) {
+      splice(doc, parentPath, prop, patch.length || 1);
+    } else {
+      let { obj: grandParent, prop: grandParentProp } = pathElemAt(path, -2);
+      if (typeof prop !== "number") {
+        throw new RangeError(`index is not a number for patch`);
+      }
+      let target = grandParent[grandParentProp];
+      if (target == null || typeof target !== "string") {
+        throw new RangeError(`target is not a string for patch`);
+      }
+      let newString = target.slice(0, prop) + target.slice(prop + (patch.length || 1));
+      grandParent[grandParentProp] = newString;
+    }
+  } else {
+    throw new RangeError(`target is not an array or string for patch`);
+  }
+}
+function applySplicePatch(doc, path, patch) {
+  if (isAutomerge(doc)) {
+    let { obj: parent, prop, parentPath } = pathElemAt(path, -1);
+    if (!(typeof prop === "number")) {
+      throw new RangeError(`index is not a number for patch`);
+    }
+    splice(doc, parentPath, prop, 0, patch.value);
+  } else {
+    let { obj: parent, prop } = pathElemAt(path, -1);
+    let { obj: grandParent, prop: grandParentProp } = pathElemAt(path, -2);
+    if (typeof prop !== "number") {
+      throw new RangeError(`index is not a number for patch`);
+    }
+    let target = grandParent[grandParentProp];
+    if (target == null || typeof target !== "string") {
+      throw new RangeError(`target is not a string for patch`);
+    }
+    let newString = target.slice(0, prop) + patch.value + target.slice(prop);
+    grandParent[grandParentProp] = newString;
+  }
+}
+function applyIncPatch(doc, path, patch) {
+  let { obj: parent, prop } = pathElemAt(path, -1);
+  const counter = parent[prop];
+  if (isAutomerge(doc)) {
+    if (!isCounter(counter)) {
+      throw new RangeError(`target is not a counter for patch`);
+    }
+    counter.increment(patch.value);
+  } else {
+    if (!(typeof counter === "number")) {
+      throw new RangeError(`target is not a number for patch`);
+    }
+    parent[prop] = counter + patch.value;
+  }
+}
+function applyMarkPatch(doc, path, patch) {
+  let { obj: parent, prop } = pathElemAt(path, -1);
+  if (!isAutomerge(doc)) {
+    return;
+  }
+  for (const markSpec of patch.marks) {
+    mark(doc, patch.path, { start: markSpec.start, end: markSpec.end, expand: "none" }, markSpec.name, markSpec.value);
+  }
+}
+function applyUnmarkPatch(doc, path, patch) {
+  if (!isAutomerge(doc)) {
+    return;
+  }
+  unmark(doc, patch.path, { start: patch.start, end: patch.end, expand: "none" }, patch.name);
+}
+function applyPatches(doc, patches) {
+  for (const patch of patches) {
+    applyPatch(doc, patch);
+  }
+}
+function resolvePath(doc, path) {
+  const result = [];
+  let current = doc;
+  let currentPath = [];
+  for (const [index, prop] of path.entries()) {
+    result.push({ obj: current, prop, parentPath: currentPath.slice() });
+    currentPath.push(prop);
+    if (index !== path.length - 1) {
+      if (current == null || typeof current != "object") {
+        throw new Error(`Invalid path: ${path}`);
+      }
+      current = current[prop];
+    } else {
+      break;
+    }
+  }
+  return result;
+}
+function pathElemAt(resolved, index) {
+  let result = resolved.at(index);
+  if (result == undefined) {
+    throw new Error("invalid path");
+  }
+  return result;
+}
+var init_apply_patches = __esm(() => {
+  init_implementation();
+});
+
+// ../../node_modules/.pnpm/@automerge+automerge@3.2.4/node_modules/@automerge/automerge/dist/mjs/conflicts.js
+function conflictAt(context, objectId, prop, withinChangeCallback) {
+  const values = context.getAll(objectId, prop);
+  if (values.length <= 1) {
+    return;
+  }
+  const result = {};
+  for (const fullVal of values) {
+    switch (fullVal[0]) {
+      case "map":
+        if (withinChangeCallback) {
+          result[fullVal[1]] = mapProxy(context, fullVal[1], [prop]);
+        } else {
+          result[fullVal[1]] = reifyFullValue(context, [fullVal[0], fullVal[1]]);
+        }
+        break;
+      case "list":
+        if (withinChangeCallback) {
+          result[fullVal[1]] = listProxy(context, fullVal[1], [prop]);
+        } else {
+          result[fullVal[1]] = reifyFullValue(context, [fullVal[0], fullVal[1]]);
+        }
+        break;
+      case "text":
+        result[fullVal[1]] = context.text(fullVal[1]);
+        break;
+      case "str":
+      case "uint":
+      case "int":
+      case "f64":
+      case "boolean":
+      case "bytes":
+      case "null":
+        result[fullVal[2]] = fullVal[1];
+        break;
+      case "counter":
+        result[fullVal[2]] = new Counter(fullVal[1]);
+        break;
+      case "timestamp":
+        result[fullVal[2]] = new Date(fullVal[1]);
+        break;
+      default:
+        throw RangeError(`datatype ${fullVal[0]} unimplemented`);
+    }
+  }
+  return result;
+}
+function reifyFullValue(context, fullValue) {
+  switch (fullValue[0]) {
+    case "map":
+      const mapResult = {};
+      for (const key of context.keys(fullValue[1])) {
+        let subVal = context.getWithType(fullValue[1], key);
+        if (!subVal) {
+          throw new Error("unexpected null map value");
+        }
+        mapResult[key] = reifyFullValue(context, subVal);
+      }
+      return Object.freeze(mapResult);
+    case "list":
+      const listResult = [];
+      const length = context.length(fullValue[1]);
+      for (let i = 0;i < length; i++) {
+        let subVal = context.getWithType(fullValue[1], i);
+        if (!subVal) {
+          throw new Error("unexpected null list element");
+        }
+        listResult.push(reifyFullValue(context, subVal));
+      }
+      return Object.freeze(listResult);
+    case "text":
+      return context.text(fullValue[1]);
+    case "str":
+    case "uint":
+    case "int":
+    case "f64":
+    case "boolean":
+    case "bytes":
+    case "null":
+      return fullValue[1];
+    case "counter":
+      return new Counter(fullValue[1]);
+    case "timestamp":
+      return new Date(fullValue[1]);
+    default:
+      throw RangeError(`datatype ${fullValue[0]} unimplemented`);
+  }
+}
+var init_conflicts = __esm(() => {
+  init_types();
+  init_proxies();
+});
+
+// ../../node_modules/.pnpm/@automerge+automerge@3.2.4/node_modules/@automerge/automerge/dist/mjs/implementation.js
+var exports_implementation = {};
+__export(exports_implementation, {
+  wasmInitialized: () => wasmInitialized,
+  view: () => view,
+  use: () => use,
+  updateText: () => updateText,
+  updateSpans: () => updateSpans,
+  updateBlock: () => updateBlock,
+  unmark: () => unmark,
+  topoHistoryTraversal: () => topoHistoryTraversal,
+  toJS: () => toJS,
+  stats: () => stats,
+  splitBlock: () => splitBlock,
+  splice: () => splice,
+  spans: () => spans,
+  saveSince: () => saveSince,
+  saveIncremental: () => saveIncremental,
+  saveBundle: () => saveBundle,
+  save: () => save,
+  releaseInfo: () => releaseInfo,
+  receiveSyncMessage: () => receiveSyncMessage,
+  readBundle: () => readBundle3,
+  merge: () => merge,
+  marksAt: () => marksAt,
+  marks: () => marks,
+  mark: () => mark,
+  loadIncremental: () => loadIncremental,
+  load: () => load3,
+  joinBlock: () => joinBlock,
+  isWasmInitialized: () => isWasmInitialized,
+  isRawString: () => isRawString,
+  isImmutableString: () => isImmutableString,
+  isCounter: () => isCounter,
+  isAutomerge: () => isAutomerge,
+  inspectChange: () => inspectChange,
+  insertAt: () => insertAt,
+  initializeWasm: () => initializeWasm,
+  initializeBase64Wasm: () => initializeBase64Wasm,
+  initSyncState: () => initSyncState3,
+  init: () => init,
+  hasOurChanges: () => hasOurChanges,
+  hasHeads: () => hasHeads,
+  getObjectId: () => getObjectId,
+  getMissingDeps: () => getMissingDeps,
+  getLastLocalChange: () => getLastLocalChange,
+  getHistory: () => getHistory,
+  getHeads: () => getHeads,
+  getCursorPosition: () => getCursorPosition,
+  getCursor: () => getCursor,
+  getConflicts: () => getConflicts,
+  getChangesSince: () => getChangesSince,
+  getChangesMetaSince: () => getChangesMetaSince,
+  getChanges: () => getChanges,
+  getBackend: () => getBackend,
+  getAllChanges: () => getAllChanges,
+  getActorId: () => getActorId,
+  generateSyncMessage: () => generateSyncMessage,
+  from: () => from,
+  free: () => free,
+  equals: () => equals,
+  encodeSyncState: () => encodeSyncState3,
+  encodeSyncMessage: () => encodeSyncMessage3,
+  encodeChange: () => encodeChange3,
+  emptyChange: () => emptyChange,
+  dump: () => dump,
+  diffPath: () => diffPath,
+  diff: () => diff,
+  deleteAt: () => deleteAt,
+  decodeSyncState: () => decodeSyncState3,
+  decodeSyncMessage: () => decodeSyncMessage3,
+  decodeChange: () => decodeChange3,
+  clone: () => clone,
+  changeAt: () => changeAt,
+  change: () => change,
+  block: () => block,
+  applyPatches: () => applyPatches,
+  applyPatch: () => applyPatch,
+  applyChanges: () => applyChanges,
+  Uint: () => Uint,
+  RawString: () => RawString,
+  Int: () => Int,
+  ImmutableString: () => ImmutableString,
+  Float64: () => Float64,
+  Counter: () => Counter
+});
+function insertAt(list, index, ...values) {
+  if (!_is_proxy(list)) {
+    throw new RangeError("object cannot be modified outside of a change block");
+  }
+  list.insertAt(index, ...values);
+}
+function deleteAt(list, index, numDelete) {
+  if (!_is_proxy(list)) {
+    throw new RangeError("object cannot be modified outside of a change block");
+  }
+  list.deleteAt(index, numDelete);
+}
+function use(api) {
+  UseApi(api);
+}
+function getBackend(doc) {
+  return _state(doc).handle;
+}
+function importOpts(_actor) {
+  if (typeof _actor === "object") {
+    return _actor;
+  } else {
+    return { actor: _actor };
+  }
+}
+function getChangesSince(state, heads) {
+  const n = _state(state);
+  return n.handle.getChanges(heads);
+}
+function getChangesMetaSince(state, heads) {
+  const n = _state(state);
+  return n.handle.getChangesMeta(heads);
+}
+function cursorToIndex(state, value, index) {
+  if (typeof index == "string") {
+    if (/^-?[0-9]+@[0-9a-zA-Z]+$|^[se]$/.test(index)) {
+      return state.handle.getCursorPosition(value, index);
+    } else {
+      throw new RangeError("index must be a number or cursor");
+    }
+  } else {
+    return index;
+  }
+}
+function init(_opts) {
+  const opts = importOpts(_opts);
+  const freeze = !!opts.freeze;
+  const patchCallback = opts.patchCallback;
+  const actor = opts.actor;
+  const handle = ApiHandler.create({ actor });
+  handle.enableFreeze(!!opts.freeze);
+  registerDatatypes(handle);
+  const doc = handle.materialize("/", undefined, {
+    handle,
+    heads: undefined,
+    freeze,
+    patchCallback
+  });
+  return doc;
+}
+function view(doc, heads) {
+  const state = _state(doc);
+  const handle = state.handle;
+  return state.handle.materialize("/", heads, Object.assign(Object.assign({}, state), {
+    handle,
+    heads
+  }));
+}
+function clone(doc, _opts) {
+  const state = _state(doc);
+  const heads = state.heads;
+  const opts = importOpts(_opts);
+  const handle = state.handle.fork(opts.actor, heads);
+  handle.updateDiffCursor();
+  const { heads: _oldHeads } = state, stateSansHeads = __rest(state, ["heads"]);
+  stateSansHeads.patchCallback = opts.patchCallback;
+  return handle.applyPatches(doc, Object.assign(Object.assign({}, stateSansHeads), { handle }));
+}
+function free(doc) {
+  return _state(doc).handle.free();
+}
+function from(initialState, _opts) {
+  return _change(init(_opts), "from", {}, (d) => Object.assign(d, initialState)).newDoc;
+}
+function change(doc, options, callback) {
+  if (typeof options === "function") {
+    return _change(doc, "change", {}, options).newDoc;
+  } else if (typeof callback === "function") {
+    if (typeof options === "string") {
+      options = { message: options };
+    }
+    return _change(doc, "change", options, callback).newDoc;
+  } else {
+    throw RangeError("Invalid args for change");
+  }
+}
+function changeAt(doc, scope, options, callback) {
+  if (typeof options === "function") {
+    return _change(doc, "changeAt", {}, options, scope);
+  } else if (typeof callback === "function") {
+    if (typeof options === "string") {
+      options = { message: options };
+    }
+    return _change(doc, "changeAt", options, callback, scope);
+  } else {
+    throw RangeError("Invalid args for changeAt");
+  }
+}
+function progressDocument(doc, source, heads, callback) {
+  if (heads == null) {
+    return doc;
+  }
+  const state = _state(doc);
+  const nextState = Object.assign(Object.assign({}, state), { heads: undefined });
+  const { value: nextDoc, patches } = state.handle.applyAndReturnPatches(doc, nextState);
+  if (patches.length > 0) {
+    if (callback != null) {
+      callback(patches, { before: doc, after: nextDoc, source });
+    }
+    const newState = _state(nextDoc);
+    newState.mostRecentPatch = {
+      before: _state(doc).heads,
+      after: newState.handle.getHeads(),
+      patches
+    };
+  }
+  state.heads = heads;
+  return nextDoc;
+}
+function _change(doc, source, options, callback, scope) {
+  if (typeof callback !== "function") {
+    throw new RangeError("invalid change function");
+  }
+  const state = _state(doc);
+  if (doc === undefined || state === undefined) {
+    throw new RangeError("must be the document root");
+  }
+  if (state.heads) {
+    throw new RangeError("Attempting to change an outdated document.  Use Automerge.clone() if you wish to make a writable copy.");
+  }
+  if (_is_proxy(doc)) {
+    throw new RangeError("Calls to Automerge.change cannot be nested");
+  }
+  let heads = state.handle.getHeads();
+  if (scope && headsEqual(scope, heads)) {
+    scope = undefined;
+  }
+  if (scope) {
+    state.handle.isolate(scope);
+    heads = scope;
+  }
+  if (!("time" in options)) {
+    options.time = Math.floor(Date.now() / 1000);
+  }
+  try {
+    state.heads = heads;
+    const root = rootProxy(state.handle);
+    callback(root);
+    if (state.handle.pendingOps() === 0) {
+      state.heads = undefined;
+      if (scope) {
+        state.handle.integrate();
+      }
+      return {
+        newDoc: doc,
+        newHeads: null
+      };
+    } else {
+      const newHead = state.handle.commit(options.message, options.time);
+      state.handle.integrate();
+      return {
+        newDoc: progressDocument(doc, source, heads, options.patchCallback || state.patchCallback),
+        newHeads: newHead != null ? [newHead] : null
+      };
+    }
+  } catch (e) {
+    state.heads = undefined;
+    state.handle.rollback();
+    throw e;
+  }
+}
+function emptyChange(doc, options) {
+  if (options === undefined) {
+    options = {};
+  }
+  if (typeof options === "string") {
+    options = { message: options };
+  }
+  if (!("time" in options)) {
+    options.time = Math.floor(Date.now() / 1000);
+  }
+  const state = _state(doc);
+  if (state.heads) {
+    throw new RangeError("Attempting to change an outdated document.  Use Automerge.clone() if you wish to make a writable copy.");
+  }
+  if (_is_proxy(doc)) {
+    throw new RangeError("Calls to Automerge.change cannot be nested");
+  }
+  const heads = state.handle.getHeads();
+  state.handle.emptyChange(options.message, options.time);
+  return progressDocument(doc, "emptyChange", heads);
+}
+function load3(data, _opts) {
+  const opts = importOpts(_opts);
+  if (opts.patchCallback) {
+    return loadIncremental(init(opts), data);
+  }
+  const actor = opts.actor;
+  const patchCallback = opts.patchCallback;
+  const unchecked = opts.unchecked || false;
+  const allowMissingDeps = opts.allowMissingChanges || false;
+  const convertImmutableStringsToText = opts.convertImmutableStringsToText || false;
+  const handle = ApiHandler.load(data, {
+    actor,
+    unchecked,
+    allowMissingDeps,
+    convertImmutableStringsToText
+  });
+  handle.enableFreeze(!!opts.freeze);
+  registerDatatypes(handle);
+  const doc = handle.materialize("/", undefined, {
+    handle,
+    heads: undefined,
+    patchCallback
+  });
+  return doc;
+}
+function loadIncremental(doc, data, opts) {
+  if (!opts) {
+    opts = {};
+  }
+  const state = _state(doc);
+  if (state.heads) {
+    throw new RangeError("Attempting to change an out of date document - set at: " + _trace(doc));
+  }
+  if (_is_proxy(doc)) {
+    throw new RangeError("Calls to Automerge.change cannot be nested");
+  }
+  const heads = state.handle.getHeads();
+  state.handle.loadIncremental(data);
+  return progressDocument(doc, "loadIncremental", heads, opts.patchCallback || state.patchCallback);
+}
+function saveIncremental(doc) {
+  const state = _state(doc);
+  if (state.heads) {
+    throw new RangeError("Attempting to change an out of date document - set at: " + _trace(doc));
+  }
+  if (_is_proxy(doc)) {
+    throw new RangeError("Calls to Automerge.change cannot be nested");
+  }
+  return state.handle.saveIncremental();
+}
+function save(doc) {
+  return _state(doc).handle.save();
+}
+function merge(local, remote) {
+  const localState = _state(local);
+  if (localState.heads) {
+    throw new RangeError("Attempting to change an out of date document - set at: " + _trace(local));
+  }
+  const heads = localState.handle.getHeads();
+  const remoteState = _state(remote);
+  const changes = localState.handle.getChangesAdded(remoteState.handle);
+  localState.handle.applyChanges(changes);
+  return progressDocument(local, "merge", heads, localState.patchCallback);
+}
+function getActorId(doc) {
+  const state = _state(doc);
+  return state.handle.getActorId();
+}
+function getConflicts(doc, prop) {
+  const state = _state(doc, false);
+  const objectId = _obj(doc);
+  if (objectId != null) {
+    const withinChangeCallback = _is_proxy(doc);
+    return conflictAt(state.handle, objectId, prop, withinChangeCallback);
+  } else {
+    return;
+  }
+}
+function getLastLocalChange(doc) {
+  const state = _state(doc);
+  return state.handle.getLastLocalChange() || undefined;
+}
+function getObjectId(doc, prop) {
+  if (prop) {
+    const state = _state(doc, false);
+    const objectId = _obj(doc);
+    if (!state || !objectId) {
+      return null;
+    }
+    return state.handle.get(objectId, prop);
+  } else {
+    return _obj(doc);
+  }
+}
+function getChanges(oldState, newState) {
+  const n = _state(newState);
+  return n.handle.getChanges(getHeads(oldState));
+}
+function getAllChanges(doc) {
+  const state = _state(doc);
+  return state.handle.getChanges([]);
+}
+function applyChanges(doc, changes, opts) {
+  const state = _state(doc);
+  if (!opts) {
+    opts = {};
+  }
+  if (state.heads) {
+    throw new RangeError("Attempting to change an outdated document.  Use Automerge.clone() if you wish to make a writable copy.");
+  }
+  if (_is_proxy(doc)) {
+    throw new RangeError("Calls to Automerge.change cannot be nested");
+  }
+  const heads = state.handle.getHeads();
+  state.handle.applyChanges(changes);
+  state.heads = heads;
+  return [
+    progressDocument(doc, "applyChanges", heads, opts.patchCallback || state.patchCallback)
+  ];
+}
+function getHistory(doc) {
+  const history = getAllChanges(doc);
+  return history.map((change2, index) => ({
+    get change() {
+      return decodeChange3(change2);
+    },
+    get snapshot() {
+      const [state] = applyChanges(init(), history.slice(0, index + 1));
+      return state;
+    }
+  }));
+}
+function diff(doc, before, after) {
+  checkHeads(before, "before heads");
+  checkHeads(after, "after heads");
+  const state = _state(doc);
+  if (state.mostRecentPatch && equals(state.mostRecentPatch.before, before) && equals(state.mostRecentPatch.after, after)) {
+    return state.mostRecentPatch.patches;
+  }
+  return state.handle.diff(before, after);
+}
+function diffPath(doc, path, before, after, opts) {
+  checkHeads(before, "before");
+  checkHeads(after, "after");
+  const state = _state(doc);
+  const objPath = absoluteObjPath(doc, path, "diff");
+  return state.handle.diffPath(objPath, before, after, opts);
+}
+function headsEqual(heads1, heads2) {
+  if (heads1.length !== heads2.length) {
+    return false;
+  }
+  for (let i = 0;i < heads1.length; i++) {
+    if (heads1[i] !== heads2[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+function checkHeads(heads, fieldname) {
+  if (!Array.isArray(heads)) {
+    throw new Error(`invalid ${fieldname}: must be an array`);
+  }
+}
+function equals(val1, val2) {
+  if (!isObject(val1) || !isObject(val2))
+    return val1 === val2;
+  const keys1 = Object.keys(val1).sort(), keys2 = Object.keys(val2).sort();
+  if (keys1.length !== keys2.length)
+    return false;
+  for (let i = 0;i < keys1.length; i++) {
+    if (keys1[i] !== keys2[i])
+      return false;
+    if (!equals(val1[keys1[i]], val2[keys2[i]]))
+      return false;
+  }
+  return true;
+}
+function encodeSyncState3(state) {
+  const sync = ApiHandler.importSyncState(state);
+  const result = ApiHandler.encodeSyncState(sync);
+  sync.free();
+  return result;
+}
+function decodeSyncState3(state) {
+  const sync = ApiHandler.decodeSyncState(state);
+  const result = ApiHandler.exportSyncState(sync);
+  sync.free();
+  return result;
+}
+function generateSyncMessage(doc, inState) {
+  const state = _state(doc);
+  const syncState = ApiHandler.importSyncState(inState);
+  const message = state.handle.generateSyncMessage(syncState);
+  const outState = ApiHandler.exportSyncState(syncState);
+  return [outState, message];
+}
+function receiveSyncMessage(doc, inState, message, opts) {
+  const syncState = ApiHandler.importSyncState(inState);
+  if (!opts) {
+    opts = {};
+  }
+  const state = _state(doc);
+  if (state.heads) {
+    throw new RangeError("Attempting to change an outdated document.  Use Automerge.clone() if you wish to make a writable copy.");
+  }
+  if (_is_proxy(doc)) {
+    throw new RangeError("Calls to Automerge.change cannot be nested");
+  }
+  const heads = state.handle.getHeads();
+  state.handle.receiveSyncMessage(syncState, message);
+  const outSyncState = ApiHandler.exportSyncState(syncState);
+  return [
+    progressDocument(doc, "receiveSyncMessage", heads, opts.patchCallback || state.patchCallback),
+    outSyncState,
+    null
+  ];
+}
+function hasOurChanges(doc, remoteState) {
+  const state = _state(doc);
+  const syncState = ApiHandler.importSyncState(remoteState);
+  return state.handle.hasOurChanges(syncState);
+}
+function initSyncState3() {
+  return ApiHandler.exportSyncState(ApiHandler.initSyncState());
+}
+function encodeChange3(change2) {
+  return ApiHandler.encodeChange(change2);
+}
+function decodeChange3(data) {
+  return ApiHandler.decodeChange(data);
+}
+function encodeSyncMessage3(message) {
+  return ApiHandler.encodeSyncMessage(message);
+}
+function decodeSyncMessage3(message) {
+  return ApiHandler.decodeSyncMessage(message);
+}
+function getMissingDeps(doc, heads) {
+  const state = _state(doc);
+  return state.handle.getMissingDeps(heads);
+}
+function getHeads(doc) {
+  const state = _state(doc);
+  return state.heads || state.handle.getHeads();
+}
+function dump(doc) {
+  const state = _state(doc);
+  state.handle.dump();
+}
+function toJS(doc) {
+  const state = _state(doc);
+  const enabled = state.handle.enableFreeze(false);
+  const result = state.handle.materialize("/", state.heads);
+  state.handle.enableFreeze(enabled);
+  return result;
+}
+function isAutomerge(doc) {
+  if (typeof doc == "object" && doc !== null) {
+    return getObjectId(doc) === "_root" && !!Reflect.get(doc, STATE);
+  } else {
+    return false;
+  }
+}
+function isObject(obj) {
+  return typeof obj === "object" && obj !== null;
+}
+function saveSince(doc, heads) {
+  const state = _state(doc);
+  const result = state.handle.saveSince(heads);
+  return result;
+}
+function hasHeads(doc, heads) {
+  const state = _state(doc);
+  for (const hash of heads) {
+    if (!state.handle.getChangeByHash(hash)) {
+      return false;
+    }
+  }
+  return true;
+}
+function registerDatatypes(handle) {
+  handle.registerDatatype("counter", (n) => new Counter(n), (n) => {
+    if (n instanceof Counter) {
+      return n.value;
+    }
+  });
+  handle.registerDatatype("str", (n) => {
+    return new ImmutableString(n);
+  }, (s) => {
+    if (isImmutableString(s)) {
+      return s.val;
+    }
+  });
+}
+function topoHistoryTraversal(doc) {
+  const state = _state(doc);
+  return state.handle.topoHistoryTraversal();
+}
+function inspectChange(doc, changeHash) {
+  const state = _state(doc);
+  return state.handle.getDecodedChangeByHash(changeHash);
+}
+function stats(doc) {
+  var _a2, _b, _c, _d, _e, _f;
+  const state = _state(doc);
+  const wasmStats = state.handle.stats();
+  const release = releaseInfo();
+  return Object.assign(Object.assign({}, wasmStats), { cargoPackageName: (_b = (_a2 = release.wasm) === null || _a2 === undefined ? undefined : _a2.cargoPackageName) !== null && _b !== undefined ? _b : "unknown", cargoPackageVersion: (_d = (_c = release.wasm) === null || _c === undefined ? undefined : _c.cargoPackageVersion) !== null && _d !== undefined ? _d : "unknown", rustcVersion: (_f = (_e = release.wasm) === null || _e === undefined ? undefined : _e.rustcVersion) !== null && _f !== undefined ? _f : "unknown" });
+}
+function releaseInfo() {
+  let wasm3 = null;
+  try {
+    wasm3 = ApiHandler.wasmReleaseInfo();
+  } catch (_a2) {}
+  return {
+    js: {
+      gitHead: JS_GIT_HEAD
+    },
+    wasm: wasm3
+  };
+}
+function splice(doc, path, index, del, newText) {
+  const objPath = absoluteObjPath(doc, path, "splice");
+  if (!_is_proxy(doc)) {
+    throw new RangeError("object cannot be modified outside of a change block");
+  }
+  const state = _state(doc, false);
+  _clear_cache(doc);
+  index = cursorToIndex(state, objPath, index);
+  try {
+    return state.handle.splice(objPath, index, del, newText);
+  } catch (e) {
+    throw new RangeError(`Cannot splice: ${e}`);
+  }
+}
+function updateText(doc, path, newText) {
+  const objPath = absoluteObjPath(doc, path, "updateText");
+  if (!_is_proxy(doc)) {
+    throw new RangeError("object cannot be modified outside of a change block");
+  }
+  const state = _state(doc, false);
+  _clear_cache(doc);
+  try {
+    return state.handle.updateText(objPath, newText);
+  } catch (e) {
+    throw new RangeError(`Cannot updateText: ${e}`);
+  }
+}
+function spans(doc, path) {
+  const state = _state(doc, false);
+  const objPath = absoluteObjPath(doc, path, "spans");
+  try {
+    return state.handle.spans(objPath, state.heads);
+  } catch (e) {
+    throw new RangeError(`Cannot splice: ${e}`);
+  }
+}
+function block(doc, path, index) {
+  const objPath = absoluteObjPath(doc, path, "splitBlock");
+  const state = _state(doc, false);
+  index = cursorToIndex(state, objPath, index);
+  try {
+    return state.handle.getBlock(objPath, index);
+  } catch (e) {
+    throw new RangeError(`Cannot get block: ${e}`);
+  }
+}
+function splitBlock(doc, path, index, block2) {
+  if (!_is_proxy(doc)) {
+    throw new RangeError("object cannot be modified outside of a change block");
+  }
+  const objPath = absoluteObjPath(doc, path, "splitBlock");
+  const state = _state(doc, false);
+  _clear_cache(doc);
+  index = cursorToIndex(state, objPath, index);
+  try {
+    state.handle.splitBlock(objPath, index, block2);
+  } catch (e) {
+    throw new RangeError(`Cannot splice: ${e}`);
+  }
+}
+function joinBlock(doc, path, index) {
+  if (!_is_proxy(doc)) {
+    throw new RangeError("object cannot be modified outside of a change block");
+  }
+  const objPath = absoluteObjPath(doc, path, "joinBlock");
+  const state = _state(doc, false);
+  _clear_cache(doc);
+  index = cursorToIndex(state, objPath, index);
+  try {
+    state.handle.joinBlock(objPath, index);
+  } catch (e) {
+    throw new RangeError(`Cannot joinBlock: ${e}`);
+  }
+}
+function updateBlock(doc, path, index, block2) {
+  if (!_is_proxy(doc)) {
+    throw new RangeError("object cannot be modified outside of a change block");
+  }
+  const objPath = absoluteObjPath(doc, path, "updateBlock");
+  const state = _state(doc, false);
+  _clear_cache(doc);
+  index = cursorToIndex(state, objPath, index);
+  try {
+    state.handle.updateBlock(objPath, index, block2);
+  } catch (e) {
+    throw new RangeError(`Cannot updateBlock: ${e}`);
+  }
+}
+function updateSpans(doc, path, newSpans, config) {
+  if (!_is_proxy(doc)) {
+    throw new RangeError("object cannot be modified outside of a change block");
+  }
+  const objPath = absoluteObjPath(doc, path, "updateSpans");
+  const state = _state(doc, false);
+  _clear_cache(doc);
+  try {
+    state.handle.updateSpans(objPath, newSpans, config);
+  } catch (e) {
+    throw new RangeError(`Cannot updateSpans: ${e}`);
+  }
+}
+function getCursor(doc, path, position, move) {
+  const objPath = absoluteObjPath(doc, path, "getCursor");
+  const state = _state(doc, false);
+  try {
+    return state.handle.getCursor(objPath, position, state.heads, move);
+  } catch (e) {
+    throw new RangeError(`Cannot getCursor: ${e}`);
+  }
+}
+function getCursorPosition(doc, path, cursor) {
+  const objPath = absoluteObjPath(doc, path, "getCursorPosition");
+  const state = _state(doc, false);
+  try {
+    return state.handle.getCursorPosition(objPath, cursor, state.heads);
+  } catch (e) {
+    throw new RangeError(`Cannot getCursorPosition: ${e}`);
+  }
+}
+function mark(doc, path, range, name, value) {
+  const objPath = absoluteObjPath(doc, path, "mark");
+  if (!_is_proxy(doc)) {
+    throw new RangeError("object cannot be modified outside of a change block");
+  }
+  const state = _state(doc, false);
+  try {
+    return state.handle.mark(objPath, range, name, value);
+  } catch (e) {
+    throw new RangeError(`Cannot mark: ${e}`);
+  }
+}
+function unmark(doc, path, range, name) {
+  const objPath = absoluteObjPath(doc, path, "unmark");
+  if (!_is_proxy(doc)) {
+    throw new RangeError("object cannot be modified outside of a change block");
+  }
+  const state = _state(doc, false);
+  try {
+    return state.handle.unmark(objPath, range, name);
+  } catch (e) {
+    throw new RangeError(`Cannot unmark: ${e}`);
+  }
+}
+function marks(doc, path) {
+  const objPath = absoluteObjPath(doc, path, "marks");
+  const state = _state(doc, false);
+  try {
+    return state.handle.marks(objPath);
+  } catch (e) {
+    throw new RangeError(`Cannot call marks(): ${e}`);
+  }
+}
+function marksAt(doc, path, index) {
+  const objPath = absoluteObjPath(doc, path, "marksAt");
+  const state = _state(doc, false);
+  try {
+    return state.handle.marksAt(objPath, index);
+  } catch (e) {
+    throw new RangeError(`Cannot call marksAt(): ${e}`);
+  }
+}
+function absoluteObjPath(doc, path, functionName) {
+  path = path.slice();
+  const objectId = _obj(doc);
+  if (!objectId) {
+    throw new RangeError(`invalid object for ${functionName}`);
+  }
+  path.unshift(objectId);
+  return path.join("/");
+}
+function saveBundle(doc, hashes) {
+  const state = _state(doc, false);
+  return state.handle.saveBundle(hashes);
+}
+function readBundle3(bundle) {
+  return ApiHandler.readBundle(bundle);
+}
+var __rest = function(s, e) {
+  var t = {};
+  for (var p in s)
+    if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+      t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function")
+    for (var i = 0, p = Object.getOwnPropertySymbols(s);i < p.length; i++) {
+      if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+        t[p[i]] = s[p[i]];
+    }
+  return t;
+}, _SyncStateSymbol, isRawString, RawString;
+var init_implementation = __esm(() => {
+  init_proxies();
+  init_proxies();
+  init_constants();
+  init_types();
+  init_types();
+  init_low_level();
+  init_low_level();
+  init_immutable_string();
+  init_immutable_string();
+  init_internal_state();
+  init_apply_patches();
+  init_conflicts();
+  _SyncStateSymbol = Symbol("_syncstate");
+  isRawString = isImmutableString;
+  RawString = ImmutableString;
+});
+
+// ../../node_modules/.pnpm/@automerge+automerge@3.2.4/node_modules/@automerge/automerge/dist/mjs/index.js
+var init_mjs = __esm(() => {
+  init_implementation();
+  init_implementation();
+});
+
+// ../../node_modules/.pnpm/@automerge+automerge@3.2.4/node_modules/@automerge/automerge/dist/mjs/entrypoints/fullfat_bundler.js
+var exports_fullfat_bundler = {};
+__export(exports_fullfat_bundler, {
+  wasmInitialized: () => wasmInitialized,
+  view: () => view,
+  use: () => use,
+  updateText: () => updateText,
+  updateSpans: () => updateSpans,
+  updateBlock: () => updateBlock,
+  unmark: () => unmark,
+  topoHistoryTraversal: () => topoHistoryTraversal,
+  toJS: () => toJS,
+  stats: () => stats,
+  splitBlock: () => splitBlock,
+  splice: () => splice,
+  spans: () => spans,
+  saveSince: () => saveSince,
+  saveIncremental: () => saveIncremental,
+  saveBundle: () => saveBundle,
+  save: () => save,
+  releaseInfo: () => releaseInfo,
+  receiveSyncMessage: () => receiveSyncMessage,
+  readBundle: () => readBundle3,
+  next: () => exports_implementation,
+  merge: () => merge,
+  marksAt: () => marksAt,
+  marks: () => marks,
+  mark: () => mark,
+  loadIncremental: () => loadIncremental,
+  load: () => load3,
+  joinBlock: () => joinBlock,
+  isWasmInitialized: () => isWasmInitialized,
+  isRawString: () => isRawString,
+  isImmutableString: () => isImmutableString,
+  isCounter: () => isCounter,
+  isAutomerge: () => isAutomerge,
+  inspectChange: () => inspectChange,
+  insertAt: () => insertAt,
+  initializeWasm: () => initializeWasm,
+  initializeBase64Wasm: () => initializeBase64Wasm,
+  initSyncState: () => initSyncState3,
+  init: () => init,
+  hasOurChanges: () => hasOurChanges,
+  hasHeads: () => hasHeads,
+  getObjectId: () => getObjectId,
+  getMissingDeps: () => getMissingDeps,
+  getLastLocalChange: () => getLastLocalChange,
+  getHistory: () => getHistory,
+  getHeads: () => getHeads,
+  getCursorPosition: () => getCursorPosition,
+  getCursor: () => getCursor,
+  getConflicts: () => getConflicts,
+  getChangesSince: () => getChangesSince,
+  getChangesMetaSince: () => getChangesMetaSince,
+  getChanges: () => getChanges,
+  getBackend: () => getBackend,
+  getAllChanges: () => getAllChanges,
+  getActorId: () => getActorId,
+  generateSyncMessage: () => generateSyncMessage,
+  from: () => from,
+  free: () => free,
+  equals: () => equals,
+  encodeSyncState: () => encodeSyncState3,
+  encodeSyncMessage: () => encodeSyncMessage3,
+  encodeChange: () => encodeChange3,
+  emptyChange: () => emptyChange,
+  dump: () => dump,
+  diffPath: () => diffPath,
+  diff: () => diff,
+  deleteAt: () => deleteAt,
+  decodeSyncState: () => decodeSyncState3,
+  decodeSyncMessage: () => decodeSyncMessage3,
+  decodeChange: () => decodeChange3,
+  clone: () => clone,
+  changeAt: () => changeAt,
+  change: () => change,
+  block: () => block,
+  applyPatches: () => applyPatches,
+  applyPatch: () => applyPatch,
+  applyChanges: () => applyChanges,
+  Uint: () => Uint,
+  RawString: () => RawString,
+  Int: () => Int,
+  ImmutableString: () => ImmutableString,
+  Float64: () => Float64,
+  Counter: () => Counter
+});
+var init_fullfat_bundler = __esm(() => {
+  init_low_level();
+  init_automerge_wasm2();
+  init_mjs();
+  UseApi(exports_automerge_wasm2);
+});
+
+// src/sync/AutomergeProvider.ts
+var RELAY_PROTOCOL = "dashrelay-v1";
+
+class AutomergeProvider {
+  config;
+  _doc;
+  _onChange;
+  _ws = null;
+  _syncState = null;
+  _automerge = null;
+  _ready;
+  _destroyed = false;
+  _joined = false;
+  _reconnectTimer = null;
+  _reconnectDelayMs = 1000;
+  _maxReconnectDelayMs = 30000;
+  constructor(doc, config, options) {
+    this._doc = doc;
+    this.config = config;
+    this._onChange = options?.onChange;
+    this._ready = this.initialize();
+  }
+  async initialize() {
+    const am = await Promise.resolve().then(() => (init_fullfat_bundler(), exports_fullfat_bundler));
+    this._automerge = am;
+    this._syncState = am.initSyncState();
+    this.connectWebSocket();
+  }
+  getRelayUrl() {
+    if (this.config.websocket?.url) {
+      return toRelaySocketUrl(this.config.websocket.url);
+    }
+    if (this.config.webtransport?.url) {
+      return toRelaySocketUrl(this.config.webtransport.url);
+    }
+    return null;
+  }
+  getJoinAuthToken() {
+    const ucanToken = this.config.ucanToken?.trim();
+    if (ucanToken && ucanToken.length > 0) {
+      return ucanToken;
+    }
+    const apiKey = this.config.apiKey?.trim();
+    if (apiKey && apiKey.length > 0) {
+      return apiKey;
+    }
+    return;
+  }
+  connectWebSocket() {
+    if (this._destroyed) {
+      return;
+    }
+    const relayUrl = this.getRelayUrl();
+    if (!relayUrl) {
+      return;
+    }
+    const wsUrl = new URL(relayUrl);
+    wsUrl.searchParams.set("room", this.config.roomName);
+    try {
+      this._ws = new WebSocket(wsUrl.toString());
+      this._ws.binaryType = "arraybuffer";
+      this._joined = false;
+    } catch {
+      this.scheduleReconnect();
+      return;
+    }
+    this._ws.addEventListener("open", () => {
+      this._reconnectDelayMs = 1000;
+      if (!this._ws || this._ws.readyState !== WebSocket.OPEN) {
+        return;
+      }
+      const joinMessage = {
+        type: "join",
+        protocol: RELAY_PROTOCOL,
+        room: this.config.roomName,
+        auth: this.getJoinAuthToken(),
+        mode: "opaque-relay",
+        clientId: `automerge-${Math.random().toString(36).slice(2, 10)}`
+      };
+      this._ws.send(JSON.stringify(joinMessage));
+    });
+    this._ws.addEventListener("message", (event) => {
+      this.handleSocketMessage(event.data).catch(() => {
+        this._ws?.close();
+      });
+    });
+    this._ws.addEventListener("close", () => {
+      this._ws = null;
+      this._joined = false;
+      this.scheduleReconnect();
+    });
+    this._ws.addEventListener("error", () => {});
+  }
+  async handleSocketMessage(data) {
+    if (typeof data === "string") {
+      this.handleControlMessage(data);
+      return;
+    }
+    if (data instanceof ArrayBuffer) {
+      this.handleBinaryMessage(data);
+      return;
+    }
+    if (data instanceof Blob) {
+      const buffer = await data.arrayBuffer();
+      this.handleBinaryMessage(buffer);
+    }
+  }
+  handleControlMessage(raw) {
+    let payload;
+    try {
+      payload = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    const record = asRecord(payload);
+    if (!record) {
+      return;
+    }
+    const type = record["type"];
+    if (type === "joined") {
+      const joined = record;
+      if (joined.protocol === RELAY_PROTOCOL && joined.room === this.config.roomName && joined.mode === "opaque-relay") {
+        this._joined = true;
+        this.sendSyncMessage();
+      }
+      return;
+    }
+    if (type === "error") {
+      const relayError = record;
+      throw new Error(relayError.error || "relay_error");
+    }
+  }
+  handleBinaryMessage(data) {
+    if (!this._joined) {
+      return;
+    }
+    this.handleMessage(data);
+  }
+  scheduleReconnect() {
+    if (this._destroyed || this._reconnectTimer) {
+      return;
+    }
+    this._reconnectTimer = setTimeout(() => {
+      this._reconnectTimer = null;
+      this.connectWebSocket();
+    }, this._reconnectDelayMs);
+    this._reconnectDelayMs = Math.min(this._reconnectDelayMs * 2, this._maxReconnectDelayMs);
+  }
+  sendSyncMessage() {
+    const am = this._automerge;
+    if (!am || !this._ws || this._ws.readyState !== WebSocket.OPEN || !this._joined) {
+      return;
+    }
+    const [nextSyncState, message] = am.generateSyncMessage(this._doc, this._syncState);
+    this._syncState = nextSyncState;
+    if (message) {
+      this._ws.send(message);
+    }
+  }
+  handleMessage(data) {
+    const am = this._automerge;
+    if (!am) {
+      return;
+    }
+    const message = new Uint8Array(data);
+    const [nextDoc, nextSyncState] = am.receiveSyncMessage(this._doc, this._syncState, message);
+    this._doc = nextDoc;
+    this._syncState = nextSyncState;
+    this._onChange?.(this._doc);
+    this.sendSyncMessage();
+  }
+  updateDoc(newDoc) {
+    this._doc = newDoc;
+    this.sendSyncMessage();
+  }
+  get doc() {
+    return this._doc;
+  }
+  get ready() {
+    return this._ready;
+  }
+  get roomName() {
+    return this.config.roomName;
+  }
+  get connected() {
+    return this._ws !== null && this._ws.readyState === WebSocket.OPEN && this._joined;
+  }
+  disconnect() {
+    if (this._reconnectTimer) {
+      clearTimeout(this._reconnectTimer);
+      this._reconnectTimer = null;
+    }
+    if (this._ws) {
+      this._ws.close();
+      this._ws = null;
+    }
+    this._joined = false;
+  }
+  async destroy() {
+    this._destroyed = true;
+    this.disconnect();
+  }
+}
+function toWsUrl(url) {
+  if (url.startsWith("wss://") || url.startsWith("ws://")) {
+    return url;
+  }
+  if (url.startsWith("https://")) {
+    return `wss://${url.slice("https://".length)}`;
+  }
+  if (url.startsWith("http://")) {
+    return `ws://${url.slice("http://".length)}`;
+  }
+  return url;
+}
+function toRelaySocketUrl(url) {
+  const wsUrl = toWsUrl(url).replace(/\/+$/, "");
+  if (/\/relay\/sync$/i.test(wsUrl)) {
+    return wsUrl;
+  }
+  if (/\/relay$/i.test(wsUrl)) {
+    return `${wsUrl}/sync`;
+  }
+  if (/\/sync$/i.test(wsUrl)) {
+    return wsUrl.replace(/\/sync$/i, "/relay/sync");
+  }
+  return `${wsUrl}/relay/sync`;
+}
+function asRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+}
+export {
+  AutomergeProvider
+};