@automerge/automerge-repo-solid-primitives 2.2.0

package/dist/index.js

@@ -0,0 +1,912 @@
+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);
+  }
+}
+function ae(t, e, r, o, s) {
+  return new ue(t, e, r, o, s);
+}
+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;
+  }
+}
+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`);
+  }
+}
+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(""));
+  }
+}
+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)
+        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;
+        }
+      });
+      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);
+        }
+        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;
+        }
+      };
+    },
+    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;
+        }
+      };
+    },
+    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;
+      }
+    },
+    findIndex(n) {
+      let i = 0;
+      for (const u of this) {
+        if (n(u, i))
+          return i;
+        i += 1;
+      }
+      return -1;
+    },
+    includes(n) {
+      return this.find((i) => i === n) !== void 0;
+    },
+    join(n) {
+      return this.toArray().join(n);
+    },
+    reduce(n, i) {
+      return this.toArray().reduce(n, i);
+    },
+    reduceRight(n, i) {
+      return this.toArray().reduceRight(n, i);
+    },
+    lastIndexOf(n, i = 1 / 0) {
+      return this.toArray().lastIndexOf(n, i);
+    },
+    slice(n, i) {
+      return this.toArray().slice(n, i);
+    },
+    some(n) {
+      let i = 0;
+      for (const u of this) {
+        if (n(u, i))
+          return !0;
+        i += 1;
+      }
+      return !1;
+    },
+    [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;
+    },
+    get(s) {
+      return this[s];
+    },
+    toString() {
+      return e.text(r).replace(//g, "");
+    },
+    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();
+    },
+    indexOf(s, n = 0) {
+      return e.text(r).indexOf(s, n);
+    },
+    insertAt(s, ...n) {
+      n.every((i) => typeof i == "string") ? e.splice(r, s, 0, n.join("")) : C(t).insertAt(s, ...n);
+    }
+  };
+}
+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);
+    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;
+  }
+}
+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 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,
+        // 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}`);
+  }
+}
+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 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 $(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;
+  }
+  const [e, r] = ee(xe(t));
+  d.set(t, {
+    refs: 0,
+    store: e,
+    cleanup() {
+      t.off("change", o), t.off("delete", s), d.delete(t);
+    }
+  });
+  function o(n) {
+    r(te(Ce(n)));
+  }
+  function s() {
+    r(re({}));
+  }
+  return t.on("change", o), t.on("delete", s), e;
+}
+function $e(t) {
+  return G(() => {
+    const r = typeof t == "function" ? t() : t;
+    return r && ke(r);
+  });
+}
+const V = X(
+  null
+), H = ["ready", "deleted", "unavailable"], Le = ["deleted", "unavailable"];
+function De(t, e) {
+  const r = J(V);
+  if (!e?.repo && !r)
+    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 [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));
+    },
+    {
+      initialValue: s()
+    }
+  );
+  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
+};