@automerge/automerge-repo-solid-primitives 2.5.0 → 2.5.1

package/dist/index.js

@@ -1,912 +1,1479 @@
-import { onCleanup as Y, createMemo as G, createContext as X, useContext as J, createResource as Z, createEffect as Q } from "solid-js";
-import { createStore as ee, produce as te, reconcile as re } from "solid-js/store";
-const m = Symbol.for("_am_meta"), w = Symbol.for("_am_trace"), y = Symbol.for("_am_objectId"), O = Symbol.for("_am_isProxy"), A = Symbol.for("_am_clearCache"), ne = Symbol.for("_am_uint"), oe = Symbol.for("_am_int"), se = Symbol.for("_am_f64"), T = Symbol.for("_am_counter"), W = Symbol.for("_am_immutableString");
-class ie {
-  constructor(e) {
-    this.value = e || 0, Reflect.defineProperty(this, T, { value: !0 });
-  }
-  /**
-   * A peculiar JavaScript language feature from its early days: if the object
-   * `x` has a `valueOf()` method that returns a number, you can use numerical
-   * operators on the object `x` directly, such as `x + 1` or `x < 4`.
-   * This method is also called when coercing a value to a string by
-   * concatenating it with another string, as in `x + ''`.
-   * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/valueOf
-   */
-  valueOf() {
-    return this.value;
-  }
-  /**
-   * Returns the counter value as a decimal string. If `x` is a counter object,
-   * this method is called e.g. when you do `['value: ', x].join('')` or when
-   * you use string interpolation: `value: ${x}`.
-   */
-  toString() {
-    return this.valueOf().toString();
-  }
-  /**
-   * Returns the counter value, so that a JSON serialization of an Automerge
-   * document represents the counter simply as an integer.
-   */
-  toJSON() {
-    return this.value;
-  }
-  /**
-   * Increases the value of the counter by `delta`. If `delta` is not given,
-   * increases the value of the counter by 1.
-   *
-   * Will throw an error if used outside of a change callback.
-   */
-  increment(e) {
-    throw new Error("Counters should not be incremented outside of a change callback");
-  }
-  /**
-   * Decreases the value of the counter by `delta`. If `delta` is not given,
-   * decreases the value of the counter by 1.
-   *
-   * Will throw an error if used outside of a change callback.
-   */
-  decrement(e) {
-    throw new Error("Counters should not be decremented outside of a change callback");
-  }
-}
-class ue extends ie {
-  constructor(e, r, o, s, n) {
-    super(e), this.context = r, this.path = o, this.objectId = s, this.key = n;
-  }
-  /**
-   * Increases the value of the counter by `delta`. If `delta` is not given,
-   * increases the value of the counter by 1.
-   */
-  increment(e) {
-    return e = typeof e == "number" ? e : 1, this.context.increment(this.objectId, this.key, e), this.value += e, this.value;
-  }
-  /**
-   * Decreases the value of the counter by `delta`. If `delta` is not given,
-   * decreases the value of the counter by 1.
-   */
-  decrement(e) {
-    return this.increment(typeof e == "number" ? -e : -1);
-  }
+import { onCleanup, createMemo, createContext, useContext, createResource, createEffect } from 'solid-js';
+import { createStore, produce, reconcile } from 'solid-js/store';
+
+// Properties of the document root object
+const STATE = Symbol.for("_am_meta"); // symbol used to hide application metadata on automerge objects
+const TRACE = Symbol.for("_am_trace"); // used for debugging
+const OBJECT_ID = Symbol.for("_am_objectId"); // symbol used to hide the object id on automerge objects
+const IS_PROXY = Symbol.for("_am_isProxy"); // symbol used to test if the document is a proxy object
+const CLEAR_CACHE = Symbol.for("_am_clearCache"); // symbol used to tell a proxy object to clear its cache
+const UINT = Symbol.for("_am_uint");
+const INT = Symbol.for("_am_int");
+const F64 = Symbol.for("_am_f64");
+const COUNTER = Symbol.for("_am_counter");
+const IMMUTABLE_STRING = Symbol.for("_am_immutableString");
+
+/**
+ * The most basic CRDT: an integer value that can be changed only by
+ * incrementing and decrementing. Since addition of integers is commutative,
+ * the value trivially converges.
+ */
+class Counter {
+    constructor(value) {
+        this.value = value || 0;
+        Reflect.defineProperty(this, COUNTER, { value: true });
+    }
+    /**
+     * A peculiar JavaScript language feature from its early days: if the object
+     * `x` has a `valueOf()` method that returns a number, you can use numerical
+     * operators on the object `x` directly, such as `x + 1` or `x < 4`.
+     * This method is also called when coercing a value to a string by
+     * concatenating it with another string, as in `x + ''`.
+     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/valueOf
+     */
+    valueOf() {
+        return this.value;
+    }
+    /**
+     * Returns the counter value as a decimal string. If `x` is a counter object,
+     * this method is called e.g. when you do `['value: ', x].join('')` or when
+     * you use string interpolation: `value: ${x}`.
+     */
+    toString() {
+        return this.valueOf().toString();
+    }
+    /**
+     * Returns the counter value, so that a JSON serialization of an Automerge
+     * document represents the counter simply as an integer.
+     */
+    toJSON() {
+        return this.value;
+    }
+    /**
+     * Increases the value of the counter by `delta`. If `delta` is not given,
+     * increases the value of the counter by 1.
+     *
+     * Will throw an error if used outside of a change callback.
+     */
+    increment(_delta) {
+        throw new Error("Counters should not be incremented outside of a change callback");
+    }
+    /**
+     * Decreases the value of the counter by `delta`. If `delta` is not given,
+     * decreases the value of the counter by 1.
+     *
+     * Will throw an error if used outside of a change callback.
+     */
+    decrement(_delta) {
+        throw new Error("Counters should not be decremented outside of a change callback");
+    }
 }
-function ae(t, e, r, o, s) {
-  return new ue(t, e, r, o, s);
+/**
+ * An instance of this class is used when a counter is accessed within a change
+ * callback.
+ */
+class WriteableCounter extends Counter {
+    constructor(value, context, path, objectId, key) {
+        super(value);
+        this.context = context;
+        this.path = path;
+        this.objectId = objectId;
+        this.key = key;
+    }
+    /**
+     * Increases the value of the counter by `delta`. If `delta` is not given,
+     * increases the value of the counter by 1.
+     */
+    increment(delta) {
+        delta = typeof delta === "number" ? delta : 1;
+        this.context.increment(this.objectId, this.key, delta);
+        this.value += delta;
+        return this.value;
+    }
+    /**
+     * Decreases the value of the counter by `delta`. If `delta` is not given,
+     * decreases the value of the counter by 1.
+     */
+    decrement(delta) {
+        return this.increment(typeof delta === "number" ? -delta : -1);
+    }
 }
-var z;
-class ce {
-  constructor(e) {
-    this[z] = !0, this.val = e;
-  }
-  /**
-   * Returns the content of the ImmutableString object as a simple string
-   */
-  toString() {
-    return this.val;
-  }
-  toJSON() {
-    return this.val;
-  }
+/**
+ * Returns an instance of `WriteableCounter` for use in a change callback.
+ * `context` is the proxy context that keeps track of the mutations.
+ * `objectId` is the ID of the object containing the counter, and `key` is
+ * the property name (key in map, or index in list) where the counter is
+ * located.
+ */
+function getWriteableCounter(value, context, path, objectId, key) {
+    return new WriteableCounter(value, context, path, objectId, key);
 }
-z = W;
-function h(t) {
-  if (typeof t == "string" && /^[0-9]+$/.test(t) && (t = parseInt(t, 10)), typeof t != "number")
-    return t;
-  if (t < 0 || isNaN(t) || t === 1 / 0 || t === -1 / 0)
-    throw new RangeError("A list index must be positive, but you passed " + t);
-  return t;
-}
-function p(t, e) {
-  const { context: r, objectId: o, path: s } = t, n = r.getWithType(o, e);
-  if (n === null)
-    return;
-  const i = n[0], u = n[1];
-  switch (i) {
-    case void 0:
-      return;
-    case "map":
-      return P(r, u, [...s, e]);
-    case "list":
-      return _(r, u, [...s, e]);
-    case "text":
-      return r.text(u);
-    case "str":
-      return new ce(u);
-    case "uint":
-      return u;
-    case "int":
-      return u;
-    case "f64":
-      return u;
-    case "boolean":
-      return u;
-    case "null":
-      return null;
-    case "bytes":
-      return u;
-    case "timestamp":
-      return u;
-    case "counter":
-      return ae(u, r, s, o, e);
-    default:
-      throw RangeError(`datatype ${i} unimplemented`);
-  }
+//module.exports = { Counter, getWriteableCounter }
+
+var _a;
+class ImmutableString {
+    constructor(val) {
+        // Used to detect whether a value is a ImmutableString object rather than using an instanceof check
+        this[_a] = true;
+        this.val = val;
+    }
+    /**
+     * Returns the content of the ImmutableString object as a simple string
+     */
+    toString() {
+        return this.val;
+    }
+    toJSON() {
+        return this.val;
+    }
 }
-function S(t, e, r) {
-  const o = typeof t;
-  switch (o) {
-    case "object":
-      if (t == null)
-        return [null, "null"];
-      if (t[ne])
-        return [t.value, "uint"];
-      if (t[oe])
-        return [t.value, "int"];
-      if (t[se])
-        return [t.value, "f64"];
-      if (t[T])
-        return [t.value, "counter"];
-      if (t instanceof Date)
-        return [t.getTime(), "timestamp"];
-      if (pe(t))
-        return [t.toString(), "str"];
-      if (t instanceof Uint8Array)
-        return [t, "bytes"];
-      if (t instanceof Array)
-        return [t, "list"];
-      if (Object.prototype.toString.call(t) === "[object Object]")
-        return [t, "map"];
-      throw E(t, r) ? new RangeError("Cannot create a reference to an existing document object") : new RangeError(`Cannot assign unknown object: ${t}`);
-    case "boolean":
-      return [t, "boolean"];
-    case "number":
-      return Number.isInteger(t) ? [t, "int"] : [t, "f64"];
-    case "string":
-      return [t, "text"];
-    case "undefined":
-      throw new RangeError([
-        `Cannot assign undefined value at ${M(e)}, `,
-        "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 ${o} value at ${M(e)}. `,
-        "All JSON primitive datatypes (object, array, string, number, boolean, null) ",
-        `are supported in an Automerge document; ${o} values are not. `
-      ].join(""));
-  }
+_a = IMMUTABLE_STRING;
+
+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 E(t, e) {
-  var r, o;
-  return t instanceof Date ? !1 : !!(t && ((o = (r = t[m]) === null || r === void 0 ? void 0 : r.handle) === null || o === void 0 ? void 0 : o.__wbg_ptr) === e.__wbg_ptr);
-}
-const fe = {
-  get(t, e) {
-    const { context: r, objectId: o, cache: s } = t;
-    return e === Symbol.toStringTag ? t[Symbol.toStringTag] : e === y ? o : e === O ? !0 : e === w ? t.trace : e === m ? { handle: r } : (s[e] || (s[e] = p(t, e)), s[e]);
-  },
-  set(t, e, r) {
-    const { context: o, objectId: s, path: n } = t;
-    if (t.cache = {}, E(r, o))
-      throw new RangeError("Cannot create a reference to an existing document object");
-    if (e === w)
-      return t.trace = r, !0;
-    if (e === A)
-      return !0;
-    const [i, u] = S(r, [...n, e], o);
-    switch (u) {
-      case "list": {
-        const a = o.putObject(s, e, []), f = _(o, a, [...n, e]);
-        for (let c = 0; c < i.length; c++)
-          f[c] = i[c];
-        break;
-      }
-      case "text": {
-        o.putObject(s, e, i);
-        break;
-      }
-      case "map": {
-        const a = o.putObject(s, e, {}), f = P(o, a, [...n, e]);
-        for (const c in i)
-          f[c] = i[c];
-        break;
-      }
-      default:
-        o.put(s, e, i, u);
-    }
-    return !0;
-  },
-  deleteProperty(t, e) {
-    const { context: r, objectId: o } = t;
-    return t.cache = {}, r.delete(o, e), !0;
-  },
-  has(t, e) {
-    return this.get(t, e) !== void 0;
-  },
-  getOwnPropertyDescriptor(t, e) {
-    const r = this.get(t, e);
-    if (typeof r < "u")
-      return {
-        configurable: !0,
-        enumerable: !0,
-        value: r
-      };
-  },
-  ownKeys(t) {
-    const { context: e, objectId: r } = t, o = e.keys(r);
-    return [...new Set(o)];
-  }
-}, F = {
-  get(t, e) {
-    const { context: r, objectId: o } = t;
-    return e = h(e), e === Symbol.hasInstance ? (s) => Array.isArray(s) : e === Symbol.toStringTag ? t[Symbol.toStringTag] : e === y ? o : e === O ? !0 : e === w ? t.trace : e === m ? { handle: r } : e === "length" ? r.length(o) : typeof e == "number" ? p(t, e) : C(t)[e];
-  },
-  set(t, e, r) {
-    const { context: o, objectId: s, path: n } = t;
-    if (e = h(e), E(r, o))
-      throw new RangeError("Cannot create a reference to an existing document object");
-    if (e === A)
-      return !0;
-    if (e === w)
-      return t.trace = r, !0;
-    if (typeof e == "string")
-      throw new RangeError("list index must be a number");
-    const [i, u] = S(r, [...n, e], o);
-    switch (u) {
-      case "list": {
-        let a;
-        e >= o.length(s) ? a = o.insertObject(s, e, []) : a = o.putObject(s, e, []), _(o, a, [...n, e]).splice(0, 0, ...i);
-        break;
-      }
-      case "text": {
-        e >= o.length(s) ? o.insertObject(s, e, i) : o.putObject(s, e, i);
-        break;
-      }
-      case "map": {
-        let a;
-        e >= o.length(s) ? a = o.insertObject(s, e, {}) : a = o.putObject(s, e, {});
-        const f = P(o, a, [...n, e]);
-        for (const c in i)
-          f[c] = i[c];
-        break;
-      }
-      default:
-        e >= o.length(s) ? o.insert(s, e, i, u) : o.put(s, e, i, u);
-    }
-    return !0;
-  },
-  deleteProperty(t, e) {
-    const { context: r, objectId: o } = t;
-    e = h(e);
-    const s = r.get(o, e);
-    if (s != null && s[0] == "counter")
-      throw new TypeError("Unsupported operation: deleting a counter from a list");
-    return r.delete(o, e), !0;
-  },
-  has(t, e) {
-    const { context: r, objectId: o } = t;
-    return e = h(e), typeof e == "number" ? e < r.length(o) : e === "length";
-  },
-  getOwnPropertyDescriptor(t, e) {
-    const { context: r, objectId: o } = t;
-    return e === "length" ? { writable: !0, value: r.length(o) } : e === y ? { configurable: !1, enumerable: !1, value: o } : (e = h(e), { configurable: !0, enumerable: !0, value: p(t, e) });
-  },
-  getPrototypeOf(t) {
-    return Object.getPrototypeOf(t);
-  },
-  ownKeys() {
-    const t = [];
-    return t.push("length"), t;
-  }
-};
-Object.assign({}, F, {
-  get(t, e) {
-    const { context: r, objectId: o } = t;
-    return e = h(e), e === Symbol.hasInstance ? (s) => Array.isArray(s) : e === Symbol.toStringTag ? t[Symbol.toStringTag] : e === y ? o : e === O ? !0 : e === w ? t.trace : e === m ? { handle: r } : e === "length" ? r.length(o) : typeof e == "number" ? p(t, e) : le(t)[e] || C(t)[e];
-  },
-  getPrototypeOf() {
-    return Object.getPrototypeOf(new Text());
-  }
-});
-function P(t, e, r) {
-  const o = {
-    context: t,
-    objectId: e,
-    path: r || [],
-    cache: {}
-  }, s = {};
-  return Object.assign(s, o), new Proxy(s, fe);
-}
-function _(t, e, r) {
-  const o = {
-    context: t,
-    objectId: e,
-    path: r || [],
-    cache: {}
-  }, s = [];
-  return Object.assign(s, o), new Proxy(s, F);
-}
-function C(t) {
-  const { context: e, objectId: r, path: o } = t;
-  return {
-    at(n) {
-      return p(t, n);
-    },
-    deleteAt(n, i) {
-      return typeof i == "number" ? e.splice(r, n, i) : e.delete(r, n), this;
-    },
-    fill(n, i, u) {
-      const [a, f] = S(n, [...o, i], e), c = e.length(r);
-      i = h(i || 0), u = h(u || c);
-      for (let l = i; l < Math.min(u, c); l++)
-        f === "list" || f === "map" || f === "text" ? e.putObject(r, l, a) : e.put(r, l, a, f);
-      return this;
-    },
-    indexOf(n, i = 0) {
-      const u = e.length(r);
-      for (let a = i; a < u; a++) {
-        const f = e.getWithType(r, a);
-        if (!f)
-          continue;
-        const [c, l] = f;
-        if (!["map", "list", "text"].includes(c)) {
-          if (l === n)
-            return a;
-          continue;
-        }
-        if (c === "text" && typeof n == "string" && n === p(t, a) || n[y] === l)
-          return a;
-      }
-      return -1;
-    },
-    insertAt(n, ...i) {
-      return this.splice(n, 0, ...i), this;
-    },
-    pop() {
-      const n = e.length(r);
-      if (n == 0)
-        return;
-      const i = p(t, n - 1);
-      return e.delete(r, n - 1), i;
-    },
-    push(...n) {
-      const i = e.length(r);
-      return this.splice(i, 0, ...n), e.length(r);
-    },
-    shift() {
-      if (e.length(r) == 0)
+function valueAt(target, prop) {
+    const { context, objectId, path } = target;
+    const value = context.getWithType(objectId, prop);
+    if (value === null) {
         return;
-      const n = p(t, 0);
-      return e.delete(r, 0), n;
-    },
-    splice(n, i, ...u) {
-      n = h(n), typeof i != "number" && (i = e.length(r) - n), i = h(i);
-      for (const c of u)
-        if (E(c, e))
-          throw new RangeError("Cannot create a reference to an existing document object");
-      const a = [];
-      for (let c = 0; c < i; c++) {
-        const l = p(t, n);
-        l !== void 0 && a.push(l), e.delete(r, n);
-      }
-      const f = u.map((c, l) => {
-        try {
-          return S(c, [...o], e);
-        } catch (g) {
-          throw g instanceof RangeError ? new RangeError(`${g.message} (at index ${l} in the input)`) : g;
+    }
+    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;
         }
-      });
-      for (const [c, l] of f) {
-        switch (l) {
-          case "list": {
-            const g = e.insertObject(r, n, []);
-            _(e, g, [...o, n]).splice(0, 0, ...c);
-            break;
-          }
-          case "text": {
-            e.insertObject(r, n, c);
-            break;
-          }
-          case "map": {
-            const g = e.insertObject(r, n, {}), L = P(e, g, [...o, n]);
-            for (const D in c)
-              L[D] = c[D];
-            break;
-          }
-          default:
-            e.insert(r, n, c, l);
+        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 "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(""));
+    }
+}
+// When we assign a value to a property in a proxy we recursively walk through
+// the value we are assigning and copy it into the document. This is generally
+// desirable behaviour. However, a very common bug is to accidentally assign a
+// value which is already in the document to another key within the same
+// document, this often leads to surprising behaviour where users expected to
+// _move_ the object, but it is instead copied. To avoid this we check if the
+// value is from the same document and if it is we throw an error, this means
+// we require an explicit Object.assign call to copy the object, thus avoiding
+// the footgun
+function isSameDocument(val, context) {
+    var _b, _c;
+    // Date is technically an object, but immutable, so allowing people to assign
+    // a date from one place in the document to another place in the document is
+    // not likely to be a bug
+    if (val instanceof Date) {
+        return false;
+    }
+    // this depends on __wbg_ptr being the wasm pointer
+    // a new version of wasm-bindgen will break this
+    // but the tests should expose the break
+    if (val && ((_c = (_b = val[STATE]) === null || _b === void 0 ? void 0 : _b.handle) === null || _c === void 0 ? void 0 : _c.__wbg_ptr) === context.__wbg_ptr) {
+        return true;
+    }
+    return false;
+}
+const MapHandler = {
+    get(target, key) {
+        const { context, objectId, cache } = target;
+        if (key === Symbol.toStringTag) {
+            return target[Symbol.toStringTag];
         }
-        n += 1;
-      }
-      return a;
-    },
-    unshift(...n) {
-      return this.splice(0, 0, ...n), e.length(r);
-    },
-    entries() {
-      let n = 0;
-      return {
-        next: () => {
-          const u = p(t, n);
-          return u === void 0 ? { value: void 0, done: !0 } : { value: [n++, u], done: !1 };
-        },
-        [Symbol.iterator]() {
-          return this;
+        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];
     },
-    keys() {
-      let n = 0;
-      const i = e.length(r);
-      return {
-        next: () => n < i ? { value: n++, done: !1 } : { value: void 0, done: !0 },
-        [Symbol.iterator]() {
-          return this;
-        }
-      };
-    },
-    values() {
-      let n = 0;
-      return {
-        next: () => {
-          const u = p(t, n++);
-          return u === void 0 ? { value: void 0, done: !0 } : { value: u, done: !1 };
-        },
-        [Symbol.iterator]() {
-          return this;
+    set(target, key, val) {
+        const { context, objectId, path } = target;
+        target.cache = {}; // reset cache on set
+        if (isSameDocument(val, context)) {
+            throw new RangeError("Cannot create a reference to an existing document object");
         }
-      };
-    },
-    toArray() {
-      const n = [];
-      let i;
-      do
-        i = p(t, n.length), i !== void 0 && n.push(i);
-      while (i !== void 0);
-      return n;
-    },
-    map(n) {
-      return this.toArray().map(n);
-    },
-    toString() {
-      return this.toArray().toString();
-    },
-    toLocaleString() {
-      return this.toArray().toLocaleString();
-    },
-    forEach(n) {
-      return this.toArray().forEach(n);
-    },
-    // todo: real concat function is different
-    concat(n) {
-      return this.toArray().concat(n);
-    },
-    every(n) {
-      return this.toArray().every(n);
-    },
-    filter(n) {
-      return this.toArray().filter(n);
-    },
-    find(n) {
-      let i = 0;
-      for (const u of this) {
-        if (n(u, i))
-          return u;
-        i += 1;
-      }
+        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 key in value) {
+                    proxyMap[key] = value[key];
+                }
+                break;
+            }
+            default:
+                context.put(objectId, key, value, datatype);
+        }
+        return true;
     },
-    findIndex(n) {
-      let i = 0;
-      for (const u of this) {
-        if (n(u, i))
-          return i;
-        i += 1;
-      }
-      return -1;
+    deleteProperty(target, key) {
+        const { context, objectId } = target;
+        target.cache = {}; // reset cache on delete
+        context.delete(objectId, key);
+        return true;
     },
-    includes(n) {
-      return this.find((i) => i === n) !== void 0;
+    has(target, key) {
+        const value = this.get(target, key);
+        return value !== undefined;
     },
-    join(n) {
-      return this.toArray().join(n);
+    getOwnPropertyDescriptor(target, key) {
+        // const { context, objectId } = target
+        const value = this.get(target, key);
+        if (typeof value !== "undefined") {
+            return {
+                configurable: true,
+                enumerable: true,
+                value,
+            };
+        }
     },
-    reduce(n, i) {
-      return this.toArray().reduce(n, i);
+    ownKeys(target) {
+        const { context, objectId } = target;
+        // FIXME - this is a tmp workaround until fix the dupe key bug in keys()
+        const keys = context.keys(objectId);
+        return [...new Set(keys)];
     },
-    reduceRight(n, i) {
-      return this.toArray().reduceRight(n, i);
+};
+const 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];
+        }
     },
-    lastIndexOf(n, i = 1 / 0) {
-      return this.toArray().lastIndexOf(n, i);
+    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;
     },
-    slice(n, i) {
-      return this.toArray().slice(n, i);
+    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;
     },
-    some(n) {
-      let i = 0;
-      for (const u of this) {
-        if (n(u, i))
-          return !0;
-        i += 1;
-      }
-      return !1;
+    has(target, index) {
+        const { context, objectId } = target;
+        index = parseListIndex(index);
+        if (typeof index === "number") {
+            return index < context.length(objectId);
+        }
+        return index === "length";
     },
-    [Symbol.iterator]: function* () {
-      let n = 0, i = p(t, n);
-      for (; i !== void 0; )
-        yield i, n += 1, i = p(t, n);
-    }
-  };
-}
-function le(t) {
-  const { context: e, objectId: r } = t;
-  return {
-    set(s, n) {
-      return this[s] = n;
+    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 };
     },
-    get(s) {
-      return this[s];
+    getPrototypeOf(target) {
+        return Object.getPrototypeOf(target);
     },
-    toString() {
-      return e.text(r).replace(//g, "");
+    ownKeys( /*target*/) {
+        const keys = [];
+        // uncommenting this causes assert.deepEqual() to fail when comparing to a pojo array
+        // but not uncommenting it causes for (i in list) {} to not enumerate values properly
+        //const {context, objectId } = target
+        //for (let i = 0; i < target.context.length(objectId); i++) { keys.push(i.toString()) }
+        keys.push("length");
+        return keys;
     },
-    toSpans() {
-      const s = [];
-      let n = "";
-      const i = e.length(r);
-      for (let u = 0; u < i; u++) {
-        const a = this[u];
-        typeof a == "string" ? n += a : (n.length > 0 && (s.push(n), n = ""), s.push(a));
-      }
-      return n.length > 0 && s.push(n), s;
-    },
-    toJSON() {
-      return this.toString();
+};
+Object.assign({}, 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 textMethods(target)[index] || listMethods(target)[index];
+        }
     },
-    indexOf(s, n = 0) {
-      return e.text(r).indexOf(s, n);
+    getPrototypeOf( /*target*/) {
+        return Object.getPrototypeOf(new Text());
     },
-    insertAt(s, ...n) {
-      n.every((i) => typeof i == "string") ? e.splice(r, s, 0, n.join("")) : C(t).insertAt(s, ...n);
+});
+function mapProxy(context, objectId, path) {
+    const target = {
+        context,
+        objectId,
+        path: path || [],
+        cache: {},
+    };
+    const proxied = {};
+    Object.assign(proxied, target);
+    const result = new Proxy(proxied, MapHandler);
+    // conversion through unknown is necessary because the types are so different
+    return result;
+}
+function listProxy(context, objectId, path) {
+    const target = {
+        context,
+        objectId,
+        path: path || [],
+        cache: {},
+    };
+    const proxied = [];
+    Object.assign(proxied, target);
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    return new Proxy(proxied, ListHandler);
+}
+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;
+                // Either the target element is an object, and we return if we have found
+                // the same object or it is a primitive value and we return if it matches
+                // the current value
+                const isObject = ["map", "list", "text"].includes(valType);
+                if (!isObject) {
+                    // If the element is not an object, then check if the value is equal to the target
+                    if (value === searchElement) {
+                        return i;
+                    }
+                    else {
+                        continue;
+                    }
+                }
+                // if it's an object, but the type of the search element is a string, then we
+                // need to check if the object is a text object with the same value as the search element
+                if (valType === "text" && typeof searchElement === "string") {
+                    if (searchElement === valueAt(target, i)) {
+                        return i;
+                    }
+                }
+                // The only possible match now is if the searchElement is an object already in the
+                // automerge document with the same object ID as the value
+                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 undefined;
+            }
+            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 del is undefined, delete until the end of the list
+            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, index) => {
+                try {
+                    return import_value(val, [...path], context);
+                }
+                catch (e) {
+                    if (e instanceof RangeError) {
+                        throw new RangeError(`${e.message} (at index ${index} 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);
+        },
+        // todo: real concat function is different
+        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) {
+            // this can be faster
+            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 textMethods(target) {
+    const { context, objectId } = target;
+    const methods = {
+        set(index, value) {
+            return (this[index] = value);
+        },
+        get(index) {
+            return this[index];
+        },
+        toString() {
+            return context.text(objectId).replace(//g, "");
+        },
+        toSpans() {
+            const spans = [];
+            let chars = "";
+            const length = context.length(objectId);
+            for (let i = 0; i < length; i++) {
+                const value = this[i];
+                if (typeof value === "string") {
+                    chars += value;
+                }
+                else {
+                    if (chars.length > 0) {
+                        spans.push(chars);
+                        chars = "";
+                    }
+                    spans.push(value);
+                }
+            }
+            if (chars.length > 0) {
+                spans.push(chars);
+            }
+            return spans;
+        },
+        toJSON() {
+            return this.toString();
+        },
+        indexOf(o, start = 0) {
+            const text = context.text(objectId);
+            return text.indexOf(o, start);
+        },
+        insertAt(index, ...values) {
+            if (values.every(v => typeof v === "string")) {
+                context.splice(objectId, index, 0, values.join(""));
+            }
+            else {
+                listMethods(target).insertAt(index, ...values);
+            }
+        },
+    };
+    return methods;
+}
+function printPath(path) {
+    // print the path as a json pointer
+    const jsonPointerComponents = path.map(component => {
+        // if its a number just turn it into a string
+        if (typeof component === "number") {
+            return component.toString();
+        }
+        else if (typeof component === "string") {
+            // otherwise we have to escape `/` and `~` characters
+            return component.replace(/~/g, "~0").replace(/\//g, "~1");
+        }
+    });
+    if (path.length === 0) {
+        return "";
+    }
+    else {
+        return "/" + jsonPointerComponents.join("/");
     }
-  };
 }
-function M(t) {
-  const e = t.map((r) => {
-    if (typeof r == "number")
-      return r.toString();
-    if (typeof r == "string")
-      return r.replace(/~/g, "~0").replace(/\//g, "~1");
-  });
-  return t.length === 0 ? "" : "/" + e.join("/");
-}
-function pe(t) {
-  return typeof t == "object" && t !== null && Object.prototype.hasOwnProperty.call(t, W);
-}
-function he(t) {
-  return typeof t == "object" && t !== null && Object.prototype.hasOwnProperty.call(t, T);
-}
-let B;
-const v = typeof TextEncoder < "u" ? new TextEncoder("utf-8") : { encode: () => {
-  throw Error("TextEncoder not available");
-} };
-v.encodeInto;
-const be = typeof TextDecoder < "u" ? new TextDecoder("utf-8", { ignoreBOM: !0, fatal: !0 }) : { decode: () => {
-  throw Error("TextDecoder not available");
-} };
-typeof TextDecoder < "u" && be.decode();
-typeof FinalizationRegistry > "u" || new FinalizationRegistry((t) => B.__wbg_automerge_free(t >>> 0, 1));
-typeof FinalizationRegistry > "u" || new FinalizationRegistry((t) => B.__wbg_syncstate_free(t >>> 0, 1));
-function j(t, e = !0) {
-  if (typeof t != "object")
-    throw new RangeError("must be the document root");
-  const r = Reflect.get(t, m);
-  if (r === void 0 || r == null || e && x(t) !== "_root")
-    throw new RangeError("must be the document root");
-  return r;
-}
-function ge(t) {
-  Reflect.set(t, A, !0);
-}
-function x(t) {
-  return typeof t != "object" || t === null ? null : Reflect.get(t, y);
-}
-function k(t) {
-  return !!Reflect.get(t, O);
-}
-function ye(t, e) {
-  let r = Ee(t, e.path);
-  if (e.action === "put")
-    me(t, r, e);
-  else if (e.action === "insert")
-    de(t, r, e);
-  else if (e.action === "del")
-    we(t, r, e);
-  else if (e.action === "splice")
-    je(t, r, e);
-  else if (e.action === "inc")
-    Re(t, r, e);
-  else if (e.action === "mark")
-    Se(t, r, e);
-  else if (e.action === "unmark")
-    Oe(t, r, e);
-  else if (e.action !== "conflict") throw new RangeError(`unsupported patch: ${e}`);
-}
-function me(t, e, r) {
-  let { obj: o, prop: s } = b(e, -1);
-  o[s] = r.value;
-}
-function de(t, e, r) {
-  let { obj: o, prop: s } = b(e, -1);
-  if (!Array.isArray(o))
-    throw new RangeError("target is not an array for patch");
-  if (typeof s != "number")
-    throw new RangeError("index is not a number for patch");
-  o.splice(s, 0, ...r.values);
-}
-function we(t, e, r) {
-  let { obj: o, prop: s, parentPath: n } = b(e, -1);
-  if (typeof s != "number")
-    throw new RangeError("index is not a number for patch");
-  if (Array.isArray(o))
-    o.splice(s, r.length || 1);
-  else if (typeof o == "string")
-    if (R(t))
-      K(t, n, s, r.length || 1);
+/*
+ * Check if an object is a {@link ImmutableString}
+ */
+function isImmutableString(obj) {
+    // We used to determine whether something was a ImmutableString by doing an instanceof check, but
+    // this doesn't work if the automerge module is loaded twice somehow. Instead, use the presence
+    // of a symbol to determine if something is a ImmutableString
+    return (typeof obj === "object" &&
+        obj !== null &&
+        Object.prototype.hasOwnProperty.call(obj, IMMUTABLE_STRING));
+}
+function isCounter(obj) {
+    // We used to determine whether something was a Counter by doing an instanceof check, but
+    // this doesn't work if the automerge module is loaded twice somehow. Instead, use the presence
+    // of a symbol to determine if something is a Counter
+    return (typeof obj === "object" &&
+        obj !== null &&
+        Object.prototype.hasOwnProperty.call(obj, COUNTER));
+}
+
+let wasm;
+
+const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } );
+
+(typeof cachedTextEncoder.encodeInto === 'function'
+    ? function (arg, view) {
+    return cachedTextEncoder.encodeInto(arg, view);
+}
+    : function (arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+        read: arg.length,
+        written: buf.length
+    };
+});
+
+const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
+
+if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); }
+(typeof FinalizationRegistry === 'undefined')
+    ? { }
+    : new FinalizationRegistry(ptr => wasm.__wbg_automerge_free(ptr >>> 0, 1));
+
+(typeof FinalizationRegistry === 'undefined')
+    ? { }
+    : new FinalizationRegistry(ptr => wasm.__wbg_syncstate_free(ptr >>> 0, 1));
+
+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 _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);
+}
+
+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 {
-      let { obj: i, prop: u } = b(e, -2);
-      if (typeof s != "number")
-        throw new RangeError("index is not a number for patch");
-      let a = i[u];
-      if (a == null || typeof a != "string")
-        throw new RangeError("target is not a string for patch");
-      let f = a.slice(0, s) + a.slice(s + (r.length || 1));
-      i[u] = f;
-    }
-  else
-    throw new RangeError("target is not an array or string for patch");
-}
-function je(t, e, r) {
-  if (R(t)) {
-    let { obj: o, prop: s, parentPath: n } = b(e, -1);
-    if (typeof s != "number")
-      throw new RangeError("index is not a number for patch");
-    K(t, n, s, 0, r.value);
-  } else {
-    let { obj: o, prop: s } = b(e, -1), { obj: n, prop: i } = b(e, -2);
-    if (typeof s != "number")
-      throw new RangeError("index is not a number for patch");
-    let u = n[i];
-    if (u == null || typeof u != "string")
-      throw new RangeError("target is not a string for patch");
-    let a = u.slice(0, s) + r.value + u.slice(s);
-    n[i] = a;
-  }
+        throw new RangeError(`unsupported patch: ${patch}`);
+    }
 }
-function Re(t, e, r) {
-  let { obj: o, prop: s } = b(e, -1);
-  const n = o[s];
-  if (R(t)) {
-    if (!he(n))
-      throw new RangeError("target is not a counter for patch");
-    n.increment(r.value);
-  } else {
-    if (typeof n != "number")
-      throw new RangeError("target is not a number for patch");
-    o[s] = n + r.value;
-  }
+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 Se(t, e, r) {
-  let { obj: o, prop: s } = b(e, -1);
-  if (R(t))
-    for (const n of r.marks)
-      Ae(
-        t,
-        r.path,
+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, 
         // TODO: add mark expansion to patches. This will require emitting
         // the expand values in patches.
-        { start: n.start, end: n.end, expand: "none" },
-        n.name,
-        n.value
-      );
-}
-function Oe(t, e, r) {
-  R(t) && Te(t, r.path, { start: r.start, end: r.end, expand: "none" }, r.name);
-}
-function q(t, e) {
-  for (const r of e)
-    ye(t, r);
-}
-function Ee(t, e) {
-  const r = [];
-  let o = t, s = [];
-  for (const [n, i] of e.entries())
-    if (r.push({ obj: o, prop: i, parentPath: s.slice() }), s.push(i), n !== e.length - 1) {
-      if (o == null || typeof o != "object")
-        throw new Error(`Invalid path: ${e}`);
-      o = o[i];
-    } else
-      break;
-  return r;
-}
-function b(t, e) {
-  let r = t.at(e);
-  if (r == null)
-    throw new Error("invalid path");
-  return r;
-}
-function Pe(t, e, r) {
-  if (typeof r == "string") {
-    if (/^-?[0-9]+@[0-9a-zA-Z]+$|^[se]$/.test(r))
-      return t.handle.getCursorPosition(e, r);
-    throw new RangeError("index must be a number or cursor");
-  } else
-    return r;
-}
-function _e(t, e) {
-  return x(t);
-}
-function ve(t, e, r) {
-  N(e, "before"), N(r, "after");
-  const o = j(t);
-  return o.mostRecentPatch && I(o.mostRecentPatch.before, e) && I(o.mostRecentPatch.after, r) ? o.mostRecentPatch.patches : o.handle.diff(e, r);
-}
-function N(t, e) {
-  if (!Array.isArray(t))
-    throw new Error(`${e} must be an array`);
-}
-function I(t, e) {
-  if (!U(t) || !U(e))
-    return t === e;
-  const r = Object.keys(t).sort(), o = Object.keys(e).sort();
-  if (r.length !== o.length)
-    return !1;
-  for (let s = 0; s < r.length; s++)
-    if (r[s] !== o[s] || !I(t[r[s]], e[o[s]]))
-      return !1;
-  return !0;
-}
-function Ie(t) {
-  const e = j(t);
-  return e.heads || e.handle.getHeads();
-}
-function R(t) {
-  return typeof t == "object" && t !== null ? _e(t) === "_root" && !!Reflect.get(t, m) : !1;
-}
-function U(t) {
-  return typeof t == "object" && t !== null;
-}
-function K(t, e, r, o, s) {
-  const n = $(t, e, "splice");
-  if (!k(t))
-    throw new RangeError("object cannot be modified outside of a change block");
-  const i = j(t, !1);
-  ge(t), r = Pe(i, n, r);
-  try {
-    return i.handle.splice(n, r, o, s);
-  } catch (u) {
-    throw new RangeError(`Cannot splice: ${u}`);
-  }
+        { start: markSpec.start, end: markSpec.end, expand: "none" }, markSpec.name, markSpec.value);
+    }
 }
-function Ae(t, e, r, o, s) {
-  const n = $(t, e, "mark");
-  if (!k(t))
-    throw new RangeError("object cannot be modified outside of a change block");
-  const i = j(t, !1);
-  try {
-    return i.handle.mark(n, r, o, s);
-  } catch (u) {
-    throw new RangeError(`Cannot mark: ${u}`);
-  }
+function applyUnmarkPatch(doc, path, patch) {
+    if (!isAutomerge(doc)) {
+        return;
+    }
+    unmark(doc, patch.path, { start: patch.start, end: patch.end, expand: "none" }, patch.name);
 }
-function Te(t, e, r, o) {
-  const s = $(t, e, "unmark");
-  if (!k(t))
-    throw new RangeError("object cannot be modified outside of a change block");
-  const n = j(t, !1);
-  try {
-    return n.handle.unmark(s, r, o);
-  } catch (i) {
-    throw new RangeError(`Cannot unmark: ${i}`);
-  }
+function applyPatches(doc, patches) {
+    for (const patch of patches) {
+        applyPatch(doc, patch);
+    }
+}
+/**
+ * Walk through a path with an object and for each element in the path return a resolved path element.
+ *
+ * A resolved path element looks like this:
+ *
+ * ```typescript
+ * {
+ *   obj: any,           // The object that this element in the path is a property of
+ *   prop: Prop,         // The property within `obj` that this path element points at
+ *   parentPath: Prop[]  // The path to `obj` within the original `doc` passed to `resolvePath`
+ * }
+ * ````
+ *
+ * For example, given an object like this:
+ *
+ * ```typescript
+ * {
+ *      todos: [{ task: "remember the milk"}]
+ * }
+ * ```
+ *
+ * Then `resolvePath(doc, ["todos", 0, "task"])` would return:
+ *
+ * ```typescript
+ * [
+ *   { obj: { todos: [{ task: "remember the milk"}] }, prop: "todos", parentPath: [] },
+ *   { obj: [{ task: "remember the milk"}], prop: 0, parentPath: ["todos"] },
+ *   { obj: { task: "remember the milk" }, prop: "task", parentPath: ["todos", 0] }
+ * ]
+ * ```
+ */
+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") {
+                // If we're not the last item in the path then we need the current
+                // object to be an object so we can access it in the next iteration
+                throw new Error(`Invalid path: ${path}`);
+            }
+            current = current[prop];
+        }
+        else {
+            break;
+        }
+    }
+    return result;
+}
+/**
+ * Get an element from a resolved path, throwing an exception if the element does not exist
+ *
+ * @param resolved - The path to lookup in
+ * @param index    - The index of the element to lookup, negative indices search backwards
+ */
+function pathElemAt(resolved, index) {
+    let result = resolved.at(index);
+    if (result == undefined) {
+        throw new Error("invalid path");
+    }
+    return result;
+}
+
+(undefined && undefined.__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;
+};
+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;
+    }
+}
+/**
+ * Return the object ID of an arbitrary javascript value
+ *
+ * This is useful to determine if something is actually an automerge document,
+ * if `doc` is not an automerge document this will return null.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function getObjectId(doc, prop) {
+    {
+        return _obj(doc);
+    }
+}
+/**
+ * Create a set of patches representing the change from one set of heads to another
+ *
+ * If either of the heads are missing from the document the returned set of patches will be empty
+ */
+function diff(doc, before, after) {
+    checkHeads(before, "before");
+    checkHeads(after, "after");
+    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 checkHeads(heads, fieldname) {
+    if (!Array.isArray(heads)) {
+        throw new Error(`${fieldname} must be an array`);
+    }
+}
+/** @hidden */
+// FIXME : no tests
+// FIXME can we just use deep equals now?
+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;
+}
+/**
+ * Get the hashes of the heads of this document
+ */
+function getHeads(doc) {
+    const state = _state(doc);
+    return state.heads || state.handle.getHeads();
+}
+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;
+}
+/**
+ * Modify a string
+ *
+ * @typeParam T - The type of the value contained in the document
+ * @param doc - The document to modify
+ * @param path - The path to the string to modify
+ * @param index - The position (as a {@link Cursor} or index) to edit.
+ *   If a cursor is used then the edit happens such that the cursor will
+ *   now point to the end of the newText, so you can continue to reuse
+ *   the same cursor for multiple calls to splice.
+ * @param del - The number of code units to delete, a positive number
+ *   deletes N characters after the cursor, a negative number deletes
+ *   N characters before the cursor.
+ * @param newText - The string to insert (if any).
+ */
+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 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 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 autoproduce(payload) {
+  return (doc) => applyPatches(doc, payload.patches);
+}
+
+const cache = /* @__PURE__ */ new WeakMap();
+function initial(handle) {
+  const template = {};
+  applyPatches(template, diff(handle.doc(), [], getHeads(handle.doc())));
+  return template;
 }
-function $(t, e, r) {
-  e = e.slice();
-  const o = x(t);
-  if (!o)
-    throw new RangeError(`invalid object for ${r}`);
-  return e.unshift(o), e.join("/");
-}
-function Ce(t) {
-  return (e) => q(e, t.patches);
-}
-const d = /* @__PURE__ */ new WeakMap();
-function xe(t) {
-  const e = {};
-  return q(e, ve(t.doc(), [], Ie(t.doc()))), e;
-}
-function ke(t) {
-  if (Y(() => {
-    const n = d.get(t);
-    n && (n.refs-- || n.cleanup());
-  }), d.has(t)) {
-    const n = d.get(t);
-    return n.refs++, n.store;
+function makeDocumentProjection(handle) {
+  onCleanup(() => {
+    const item = cache.get(handle);
+    if (!item) return;
+    if (!item.refs--) {
+      item.cleanup();
+    }
+  });
+  if (cache.has(handle)) {
+    const item = cache.get(handle);
+    item.refs++;
+    return item.store;
   }
-  const [e, r] = ee(xe(t));
-  d.set(t, {
+  const [doc, set] = createStore(initial(handle));
+  cache.set(handle, {
     refs: 0,
-    store: e,
+    store: doc,
     cleanup() {
-      t.off("change", o), t.off("delete", s), d.delete(t);
+      handle.off("change", patch);
+      handle.off("delete", ondelete);
+      cache.delete(handle);
     }
   });
-  function o(n) {
-    r(te(Ce(n)));
+  function patch(payload) {
+    set(produce(autoproduce(payload)));
   }
-  function s() {
-    r(re({}));
+  function ondelete() {
+    set(reconcile({}));
   }
-  return t.on("change", o), t.on("delete", s), e;
+  handle.on("change", patch);
+  handle.on("delete", ondelete);
+  return doc;
 }
-function $e(t) {
-  return G(() => {
-    const r = typeof t == "function" ? t() : t;
-    return r && ke(r);
+
+function createDocumentProjection(handle) {
+  const projection = createMemo(() => {
+    const unwrappedHandle = typeof handle == "function" ? handle() : handle;
+    return unwrappedHandle && makeDocumentProjection(unwrappedHandle);
   });
+  return projection;
 }
-const V = X(
+
+const RepoContext = createContext(
   null
-), H = ["ready", "deleted", "unavailable"], Le = ["deleted", "unavailable"];
-function De(t, e) {
-  const r = J(V);
-  if (!e?.repo && !r)
+);
+
+const readyStates = ["ready", "deleted", "unavailable"];
+const badStates = ["deleted", "unavailable"];
+function useDocHandle(url, options) {
+  const contextRepo = useContext(RepoContext);
+  if (!options?.repo && !contextRepo) {
     throw new Error("use outside <RepoContext> requires options.repo");
-  const o = e?.repo || r;
-  function s() {
-    if (e?.["~skipInitialValue"]) return;
-    const u = typeof t == "function" ? t() : t;
-    if (u)
-      try {
-        const a = new URL(u).pathname, f = o.handles[a];
-        if (f?.isReady())
-          return f;
-      } catch (a) {
-        console.error("Error parsing URL:", a);
+  }
+  const repo = options?.repo || contextRepo;
+  function getExistingHandle() {
+    if (options?.["~skipInitialValue"]) return void 0;
+    const unwrappedURL = typeof url == "function" ? url() : url;
+    if (!unwrappedURL) return void 0;
+    try {
+      const documentId = new URL(unwrappedURL).pathname;
+      const existingHandle = repo.handles[documentId];
+      if (existingHandle?.isReady()) {
+        return existingHandle;
       }
+    } catch (error) {
+      console.error("Error parsing URL:", error);
+    }
   }
-  const [n, { mutate: i }] = Z(
-    t,
-    async (u) => {
-      const a = await o.find(u, {
-        allowableStates: H
-      }), f = (c) => Promise.reject(new Error(`document not available: [${c}]`));
-      return a.isReady() ? a : a.inState(Le) ? f(a.state) : a.whenReady(H).then(() => a.isReady() ? a : f(a.state));
+  const [handle, { mutate }] = createResource(
+    url,
+    async (url2) => {
+      const handle2 = await repo.find(url2, {
+        allowableStates: readyStates
+      });
+      const reject = (state) => Promise.reject(new Error(`document not available: [${state}]`));
+      if (handle2.isReady()) {
+        return handle2;
+      } else if (handle2.inState(badStates)) {
+        return reject(handle2.state);
+      }
+      return handle2.whenReady(readyStates).then(() => {
+        if (handle2.isReady()) {
+          return handle2;
+        }
+        return reject(handle2.state);
+      });
     },
     {
-      initialValue: s()
+      initialValue: getExistingHandle()
     }
   );
-  return Q(() => {
-    (typeof t == "function" ? t() : t) || i();
-  }), n;
-}
-function Ue(t, e) {
-  const r = De(t, e);
-  return [$e(r), r];
-}
-function He() {
-  const t = J(V);
-  if (!t) throw new Error("Please wrap me in a <RepoContext value={repo}>");
-  return t;
-}
-export {
-  V as RepoContext,
-  Ce as autoproduce,
-  $e as createDocumentProjection,
-  ke as makeDocumentProjection,
-  De as useDocHandle,
-  Ue as useDocument,
-  He as useRepo
-};
+  createEffect(() => {
+    const unwrappedURL = typeof url == "function" ? url() : url;
+    if (!unwrappedURL) {
+      mutate();
+    }
+  });
+  return handle;
+}
+
+function useDocument(url, options) {
+  const handle = useDocHandle(url, options);
+  return [createDocumentProjection(handle), handle];
+}
+
+function useRepo() {
+  const repo = useContext(RepoContext);
+  if (!repo) throw new Error("Please wrap me in a <RepoContext value={repo}>");
+  return repo;
+}
+
+export { RepoContext, autoproduce, createDocumentProjection, makeDocumentProjection, useDocHandle, useDocument, useRepo };
+//# sourceMappingURL=index.js.map