@graffy/common 0.17.8-alpha.2 → 0.17.8

package/index.mjs

@@ -1,7 +1,7 @@
 import debug from "debug";
 import isEqual from "lodash/isEqual.js";
-import mergeIterators from "merge-async-iterators";
 import { makeStream } from "@graffy/stream";
+import mergeIterators from "merge-async-iterators";
 const isDebugMode = debug("graffy*").enabled;
 const MIN_KEY = new Uint8Array();
 const MAX_KEY = new Uint8Array([255]);
@@ -62,11 +62,10 @@ function find(items, compare2, first = 0, last = items.length) {
   return currentFirst;
 }
 function stringify() {
-  var _a;
-  if ((this == null ? void 0 : this.length) === 0) return "·";
+  if (this?.length === 0) return "·";
   let str = "";
   let bull = false;
-  (_a = this == null ? void 0 : this.forEach) == null ? void 0 : _a.call(this, (value, i) => {
+  this?.forEach?.((value, i) => {
     if (value >= 32 && value <= 126) {
       str += String.fromCharCode(value);
       bull = true;
@@ -77,7 +76,7 @@ function stringify() {
   });
   return str;
 }
-const inspectSymbol = Symbol.for("nodejs.util.inspect.custom");
+const inspectSymbol = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
 function addStringify(buffer) {
   if (!isDebugMode) return buffer;
   if ("toJSON" in buffer || inspectSymbol in buffer) return buffer;
@@ -88,6 +87,60 @@ function addStringify(buffer) {
 }
 addStringify(MIN_KEY);
 addStringify(MAX_KEY);
+function keyStep(key) {
+  if (isMinKey(key)) return { key, step: 1 };
+  if (isMaxKey(key)) return { key, step: -1 };
+  const l = key.length - 1;
+  let newKey;
+  let step;
+  switch (key[l]) {
+    case 0:
+      newKey = key.slice(0, l);
+      addStringify(newKey);
+      step = 1;
+      break;
+    case 255:
+      newKey = key.slice(0, l);
+      addStringify(newKey);
+      newKey[l - 1]++;
+      step = -1;
+      break;
+    default:
+      newKey = key;
+      step = 0;
+  }
+  return { key: newKey, step };
+}
+function keyBefore(key) {
+  if (isMinKey(key) || isMaxKey(key)) return key;
+  const l = key.length - 1;
+  let newKey;
+  if (key[l] === 0) {
+    newKey = key.slice(0, l);
+  } else {
+    newKey = new Uint8Array(l + 2);
+    newKey.set(key, 0);
+    newKey[l]--;
+    newKey[l + 1] = 255;
+  }
+  addStringify(newKey);
+  return newKey;
+}
+function keyAfter(key) {
+  if (isMaxKey(key)) return key;
+  const l = key.length - 1;
+  let newKey;
+  if (key[l] === 255) {
+    newKey = key.slice(0, l);
+    newKey[l - 1]++;
+  } else {
+    newKey = new Uint8Array(l + 2);
+    newKey.set(key, 0);
+    newKey[l + 1] = 0;
+  }
+  addStringify(newKey);
+  return newKey;
+}
 function TwosComplement(view) {
   const lo = -view.getUint32(4) >>> 0;
   const carry = lo ? 0 : -1;
@@ -259,60 +312,6 @@ function decode$4(buffer) {
   }
   return stack[0][0];
 }
-function keyStep(key) {
-  if (isMinKey(key)) return { key, step: 1 };
-  if (isMaxKey(key)) return { key, step: -1 };
-  const l = key.length - 1;
-  let newKey;
-  let step;
-  switch (key[l]) {
-    case 0:
-      newKey = key.slice(0, l);
-      addStringify(newKey);
-      step = 1;
-      break;
-    case 255:
-      newKey = key.slice(0, l);
-      addStringify(newKey);
-      newKey[l - 1]++;
-      step = -1;
-      break;
-    default:
-      newKey = key;
-      step = 0;
-  }
-  return { key: newKey, step };
-}
-function keyBefore(key) {
-  if (isMinKey(key) || isMaxKey(key)) return key;
-  const l = key.length - 1;
-  let newKey;
-  if (key[l] === 0) {
-    newKey = key.slice(0, l);
-  } else {
-    newKey = new Uint8Array(l + 2);
-    newKey.set(key, 0);
-    newKey[l]--;
-    newKey[l + 1] = 255;
-  }
-  addStringify(newKey);
-  return newKey;
-}
-function keyAfter(key) {
-  if (isMaxKey(key)) return key;
-  const l = key.length - 1;
-  let newKey;
-  if (key[l] === 255) {
-    newKey = key.slice(0, l);
-    newKey[l - 1]++;
-  } else {
-    newKey = new Uint8Array(l + 2);
-    newKey.set(key, 0);
-    newKey[l + 1] = 0;
-  }
-  addStringify(newKey);
-  return newKey;
-}
 function decodeBound(bound) {
   const { key, step } = keyStep(bound);
   if (isMinKey(key) || isMaxKey(key)) return { step };
@@ -387,51 +386,6 @@ function decode$3(node) {
   }
   return args;
 }
-const PATH_SEPARATOR = ".";
-function encode$2(path) {
-  if (typeof path === "string") {
-    if (!path.length || path === PATH_SEPARATOR) return [];
-    path = path.split(PATH_SEPARATOR);
-  }
-  if (!Array.isArray(path)) {
-    throw Error(`encodePath.invalid:${JSON.stringify(path)}`);
-  }
-  function encodeSegment(seg) {
-    if (ArrayBuffer.isView(seg)) return seg;
-    const node = encode$3(seg);
-    if (node.end) return node;
-    return node.key;
-  }
-  if (isPlainObject(path[path.length - 1])) {
-    const [page, filter] = splitArgs(path[path.length - 1]);
-    if (page) path = path.slice(0, -1).concat([filter || MIN_KEY]);
-  }
-  return path.map(encodeSegment);
-}
-function decode$2(path) {
-  if (!Array.isArray(path)) {
-    throw Error(`decodePath.invalid:${JSON.stringify(path)}`);
-  }
-  return path.map((key) => decode$3({ key }));
-}
-function splitRef($ref) {
-  if (!Array.isArray($ref)) return [];
-  const tail = $ref[$ref.length - 1];
-  if (!isPlainObject(tail)) return [];
-  return splitArgs(tail);
-}
-let customAlphabet = (alphabet, defaultSize = 21) => {
-  return (size = defaultSize) => {
-    let id2 = "";
-    let i = size | 0;
-    while (i--) {
-      id2 += alphabet[Math.random() * alphabet.length | 0];
-    }
-    return id2;
-  };
-};
-const alpha = "-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz";
-const id = customAlphabet(alpha, 20);
 function findFirst(children, target, first, last) {
   return find(
     children,
@@ -456,7 +410,7 @@ function isBranch(node) {
   return node && typeof node.children !== "undefined";
 }
 function isPrefix(node) {
-  return node == null ? void 0 : node.prefix;
+  return node?.prefix;
 }
 function isLink(node) {
   return node && typeof node.path !== "undefined";
@@ -514,6 +468,30 @@ function clone(node) {
   if (node.children) copy.children = node.children.map((child) => clone(child));
   return copy;
 }
+function finalize(graph, query, version = Date.now()) {
+  let result = [{ key: MIN_KEY, end: MAX_KEY, version: 0 }];
+  merge(result, graph);
+  if (query) result = slice(result, query).known || [];
+  if (version !== false) result = setVersion(result, version, true);
+  return result;
+}
+function getKnown(graph, version = 0) {
+  const query = [];
+  for (const { key, end, children } of graph) {
+    const node = { key, version };
+    if (end) {
+      if (cmp(end, key) !== 0) node.end = end;
+      node.value = 1;
+    }
+    if (children) {
+      node.children = getKnown(children);
+    } else {
+      node.value = 1;
+    }
+    query.push(node);
+  }
+  return query;
+}
 function merge(current, changes) {
   let index = 0;
   if (typeof changes === "undefined") return current;
@@ -593,7 +571,7 @@ function getNewer(node, base) {
   }
   return node.version >= version ? node : null;
 }
-const IS_VAL = Symbol("IS_VAL");
+const IS_VAL = /* @__PURE__ */ Symbol("IS_VAL");
 function makeNode(seg, props2) {
   if (ArrayBuffer.isView(seg)) return { key: seg, ...props2 };
   return { ...seg, ...props2 };
@@ -656,164 +634,40 @@ function remove(children, path) {
   const filteredNode = filteredChildren.length ? { ...node, children: filteredChildren } : [];
   return children.slice(0, ix).concat(filteredNode, children.slice(ix + 1));
 }
-class Result {
-  constructor(root) {
-    this.root = root || this;
-  }
-  addKnown(node) {
-    this.known = this.known || [];
-    merge(this.known, [node]);
-  }
-  addUnknown(node) {
-    this.unknown = this.unknown || [];
-    this.unknown.push(node);
-  }
-  addLinked(children) {
-    if (this.root !== this) return this.root.addLinked(children);
-    this.linked = this.linked || [];
-    add(this.linked, children);
+function setVersion(graph, version, onlyIfZero = false) {
+  for (const node of graph) {
+    if (!(onlyIfZero && node.version)) node.version = version;
+    if (node.children) setVersion(node.children, version, onlyIfZero);
   }
+  return graph;
 }
-function slice(graph, query, root) {
-  const result = new Result(root);
-  let currentQuery = query;
-  while (currentQuery) {
-    let index = 0;
-    for (const queryNode of currentQuery) {
-      if (isRange(queryNode)) {
-        sliceRange(graph, queryNode, result);
-      } else {
-        const key = queryNode.key;
-        index = findFirst(graph, key);
-        sliceNode(graph[index], queryNode, result);
-      }
-    }
-    currentQuery = root ? void 0 : result.linked;
-    delete result.linked;
+function sieve(current, changes, result = []) {
+  let index = 0;
+  for (const change of changes) {
+    index = isRange(change) ? insertRange(current, change, result, index) : insertNode(current, change, result, index);
   }
-  delete result.root;
   return result;
 }
-function sliceNode(graph, query, result) {
-  const { key, version } = query;
-  const { root } = result;
-  if (!graph || cmp(graph.key, key) > 0 || isOlder(graph, version)) {
-    result.addUnknown(query);
-  } else if (isRange(graph)) {
-    if (isBranch(query)) {
-      const { known } = slice(
-        [{ key: MIN_KEY, end: MAX_KEY, version: graph.version }],
-        query.children
-      );
-      result.addKnown({ key, version: graph.version, children: known });
-    } else {
-      result.addKnown({ key, end: key, version: graph.version });
-    }
-  } else if (isBranch(graph) && isBranch(query)) {
-    const { known, unknown } = slice(graph.children, query.children, root);
-    if (known) result.addKnown({ ...graph, children: known });
-    if (unknown) result.addUnknown({ ...query, children: unknown });
-  } else if (isLink(graph)) {
-    result.addKnown(graph);
-    if (graph.prefix && isRange(query)) {
-      result.addLinked(wrap([query], graph.path, version, true));
-    } else {
-      result.addLinked(
-        wrap(
-          query.children || query.value,
-          graph.path,
-          version,
-          graph.prefix || query.prefix
-        )
-      );
-    }
-  } else if (isBranch(graph)) {
-    result.addKnown(graph);
-  } else if (isBranch(query)) {
-    const { known } = slice(
-      [{ key: MIN_KEY, end: MAX_KEY, version: graph.version }],
-      query.children
-    );
-    result.addKnown({ key, version: graph.version, children: known });
-  } else {
-    result.addKnown(graph);
-  }
-}
-function sliceRange(graph, query, result) {
-  let { key, end, limit = Number.POSITIVE_INFINITY, version } = query;
-  const step = cmp(key, end) < 0 ? 1 : -1;
-  if (isMinKey(graph[0].key) && graph[0].prefix && graph[0].children) {
-    const { known, unknown } = slice(graph[0].children, [query], result.root);
-    if (known) result.addKnown({ ...graph[0], children: known });
-    if (unknown) result.addUnknown({ ...query[0], children: unknown });
-    return;
-  }
-  if (cmp(key, end) < 0) {
-    for (let i = findFirst(graph, key); cmp(key, end) <= 0 && limit > 0; i++) {
-      const node = graph[i];
-      if (!node || cmp(key, node.key) < 0 || isOlder(node, version)) break;
-      if (isRange(node)) {
-        result.addKnown(getOverlap(node, key, end));
-      } else {
-        sliceNode(node, { ...query, key }, result);
-        limit--;
-      }
-      key = keyAfter(node.end || node.key);
-    }
-  } else {
-    for (let i = findLast(graph, key) - 1; cmp(key, end) >= 0 && limit > 0; i--) {
-      const node = graph[i];
-      if (!node || cmp(key, node.end || node.key) > 0 || isOlder(node, version))
-        break;
-      if (isRange(node)) {
-        result.addKnown(getOverlap(node, end, key));
-      } else {
-        sliceNode(node, { ...query, key }, result);
-        limit--;
-      }
-      key = keyBefore(node.key);
-    }
-  }
-  if (limit && (step < 0 ? cmp(key, end) > 0 : cmp(key, end) < 0)) {
-    const unknown = { ...query, key, end, limit };
-    result.addUnknown(unknown);
-  }
-}
-function getOverlap(node, key, end) {
-  if (cmp(node.key, key) >= 0 && cmp(node.end, end) <= 0) return node;
-  return {
-    ...node,
-    key: cmp(node.key, key) > 0 ? node.key : key,
-    end: cmp(node.end, end) < 0 ? node.end : end
-  };
-}
-function sieve(current, changes, result = []) {
-  let index = 0;
-  for (const change of changes) {
-    index = isRange(change) ? insertRange(current, change, result, index) : insertNode(current, change, result, index);
-  }
-  return result;
-}
-function insertRange(current, change, result, start = 0) {
-  const { key, end } = change;
-  const keyIx = findFirst(current, key, start);
-  const endIx = findLast(current, end, keyIx);
-  if (keyIx === endIx && !(current[keyIx] && cmp(current[keyIx].key, end) <= 0 && cmp(current[keyIx].end || current[keyIx].key, key) >= 0)) {
-    return keyIx;
-  }
-  const appliedChange = [];
-  let currentKey = change.key;
-  for (let i = keyIx; i < endIx; i++) {
-    const node = current[i];
-    if (isRange(node) && node.version >= 0) {
-      if (cmp(node.key, currentKey) > 0) {
-        appliedChange.push({
-          key: currentKey,
-          end: keyBefore(node.key),
-          version: change.version
-        });
-      }
-      currentKey = keyAfter(node.end);
+function insertRange(current, change, result, start = 0) {
+  const { key, end } = change;
+  const keyIx = findFirst(current, key, start);
+  const endIx = findLast(current, end, keyIx);
+  if (keyIx === endIx && !(current[keyIx] && cmp(current[keyIx].key, end) <= 0 && cmp(current[keyIx].end || current[keyIx].key, key) >= 0)) {
+    return keyIx;
+  }
+  const appliedChange = [];
+  let currentKey = change.key;
+  for (let i = keyIx; i < endIx; i++) {
+    const node = current[i];
+    if (isRange(node) && node.version >= 0) {
+      if (cmp(node.key, currentKey) > 0) {
+        appliedChange.push({
+          key: currentKey,
+          end: keyBefore(node.key),
+          version: change.version
+        });
+      }
+      currentKey = keyAfter(node.end);
     } else {
       if (getNewerChange(node, change)) {
         appliedChange.push({
@@ -928,38 +782,171 @@ function getNewerChange(node, base) {
   }
   return node.version >= base.version ? node : null;
 }
-function setVersion(graph, version, onlyIfZero = false) {
-  for (const node of graph) {
-    if (!(onlyIfZero && node.version)) node.version = version;
-    if (node.children) setVersion(node.children, version, onlyIfZero);
+class Result {
+  constructor(root) {
+    this.root = root || this;
+  }
+  addKnown(node) {
+    this.known = this.known || [];
+    merge(this.known, [node]);
+  }
+  addUnknown(node) {
+    this.unknown = this.unknown || [];
+    this.unknown.push(node);
+  }
+  addLinked(children) {
+    if (this.root !== this) return this.root.addLinked(children);
+    this.linked = this.linked || [];
+    add(this.linked, children);
   }
-  return graph;
 }
-function getKnown(graph, version = 0) {
-  const query = [];
-  for (const { key, end, children } of graph) {
-    const node = { key, version };
-    if (end) {
-      if (cmp(end, key) !== 0) node.end = end;
-      node.value = 1;
+function slice(graph, query, root) {
+  const result = new Result(root);
+  let currentQuery = query;
+  while (currentQuery) {
+    let index = 0;
+    for (const queryNode of currentQuery) {
+      if (isRange(queryNode)) {
+        sliceRange(graph, queryNode, result);
+      } else {
+        const key = queryNode.key;
+        index = findFirst(graph, key);
+        sliceNode(graph[index], queryNode, result);
+      }
     }
-    if (children) {
-      node.children = getKnown(children);
+    currentQuery = root ? void 0 : result.linked;
+    delete result.linked;
+  }
+  delete result.root;
+  return result;
+}
+function sliceNode(graph, query, result) {
+  const { key, version } = query;
+  const { root } = result;
+  if (!graph || cmp(graph.key, key) > 0 || isOlder(graph, version)) {
+    result.addUnknown(query);
+  } else if (isRange(graph)) {
+    if (isBranch(query)) {
+      const { known } = slice(
+        [{ key: MIN_KEY, end: MAX_KEY, version: graph.version }],
+        query.children
+      );
+      result.addKnown({ key, version: graph.version, children: known });
     } else {
-      node.value = 1;
+      result.addKnown({ key, end: key, version: graph.version });
     }
-    query.push(node);
+  } else if (isBranch(graph) && isBranch(query)) {
+    const { known, unknown } = slice(graph.children, query.children, root);
+    if (known) result.addKnown({ ...graph, children: known });
+    if (unknown) result.addUnknown({ ...query, children: unknown });
+  } else if (isLink(graph)) {
+    result.addKnown(graph);
+    if (graph.prefix && isRange(query)) {
+      result.addLinked(wrap([query], graph.path, version, true));
+    } else {
+      result.addLinked(
+        wrap(
+          query.children || query.value,
+          graph.path,
+          version,
+          graph.prefix || query.prefix
+        )
+      );
+    }
+  } else if (isBranch(graph)) {
+    result.addKnown(graph);
+  } else if (isBranch(query)) {
+    const { known } = slice(
+      [{ key: MIN_KEY, end: MAX_KEY, version: graph.version }],
+      query.children
+    );
+    result.addKnown({ key, version: graph.version, children: known });
+  } else {
+    result.addKnown(graph);
+  }
+}
+function sliceRange(graph, query, result) {
+  let { key, end, limit = Number.POSITIVE_INFINITY, version } = query;
+  const step = cmp(key, end) < 0 ? 1 : -1;
+  if (isMinKey(graph[0].key) && graph[0].prefix && graph[0].children) {
+    const { known, unknown } = slice(graph[0].children, [query], result.root);
+    if (known) result.addKnown({ ...graph[0], children: known });
+    if (unknown) result.addUnknown({ ...query[0], children: unknown });
+    return;
+  }
+  if (cmp(key, end) < 0) {
+    for (let i = findFirst(graph, key); cmp(key, end) <= 0 && limit > 0; i++) {
+      const node = graph[i];
+      if (!node || cmp(key, node.key) < 0 || isOlder(node, version)) break;
+      if (isRange(node)) {
+        result.addKnown(getOverlap(node, key, end));
+      } else {
+        sliceNode(node, { ...query, key }, result);
+        limit--;
+      }
+      key = keyAfter(node.end || node.key);
+    }
+  } else {
+    for (let i = findLast(graph, key) - 1; cmp(key, end) >= 0 && limit > 0; i--) {
+      const node = graph[i];
+      if (!node || cmp(key, node.end || node.key) > 0 || isOlder(node, version))
+        break;
+      if (isRange(node)) {
+        result.addKnown(getOverlap(node, end, key));
+      } else {
+        sliceNode(node, { ...query, key }, result);
+        limit--;
+      }
+      key = keyBefore(node.key);
+    }
+  }
+  if (limit && (step < 0 ? cmp(key, end) > 0 : cmp(key, end) < 0)) {
+    const unknown = { ...query, key, end, limit };
+    result.addUnknown(unknown);
+  }
+}
+function getOverlap(node, key, end) {
+  if (cmp(node.key, key) >= 0 && cmp(node.end, end) <= 0) return node;
+  return {
+    ...node,
+    key: cmp(node.key, key) > 0 ? node.key : key,
+    end: cmp(node.end, end) < 0 ? node.end : end
+  };
+}
+const PATH_SEPARATOR = ".";
+function encode$2(path) {
+  if (typeof path === "string") {
+    if (!path.length || path === PATH_SEPARATOR) return [];
+    path = path.split(PATH_SEPARATOR);
+  }
+  if (!Array.isArray(path)) {
+    throw Error(`encodePath.invalid:${JSON.stringify(path)}`);
+  }
+  function encodeSegment(seg) {
+    if (ArrayBuffer.isView(seg)) return seg;
+    const node = encode$3(seg);
+    if (node.end) return node;
+    return node.key;
+  }
+  if (isPlainObject(path[path.length - 1])) {
+    const [page, filter] = splitArgs(path[path.length - 1]);
+    if (page) path = path.slice(0, -1).concat([filter || MIN_KEY]);
+  }
+  return path.map(encodeSegment);
+}
+function decode$2(path) {
+  if (!Array.isArray(path)) {
+    throw Error(`decodePath.invalid:${JSON.stringify(path)}`);
   }
-  return query;
+  return path.map((key) => decode$3({ key }));
 }
-function finalize(graph, query, version = Date.now()) {
-  let result = [{ key: MIN_KEY, end: MAX_KEY, version: 0 }];
-  merge(result, graph);
-  if (query) result = slice(result, query).known || [];
-  if (version !== false) result = setVersion(result, version, true);
-  return result;
+function splitRef($ref) {
+  if (!Array.isArray($ref)) return [];
+  const tail = $ref[$ref.length - 1];
+  if (!isPlainObject(tail)) return [];
+  return splitArgs(tail);
 }
-const PRE_CHI_PUT = Symbol("PREFIX_CHILDREN_$PUT");
+const PRE_CHI_PUT = /* @__PURE__ */ Symbol("PREFIX_CHILDREN_$PUT");
 function decode$1(nodes = [], { isGraph } = {}) {
   function decodeChildren(nodes2) {
     let result = [];
@@ -1116,8 +1103,8 @@ function decodeGraph(graph) {
 function decodeQuery(query) {
   return decode$1(query, { isGraph: false });
 }
-const REF = Symbol();
-const PRE = Symbol();
+const REF = /* @__PURE__ */ Symbol();
+const PRE = /* @__PURE__ */ Symbol();
 function decorate(rootGraph, rootQuery) {
   function construct(plumGraph, query) {
     if (plumGraph === null) return null;
@@ -1140,7 +1127,7 @@ function decorate(rootGraph, rootQuery) {
     } else if (Array.isArray(query)) {
       let pageKey;
       graph = query.flatMap((item, i) => {
-        if (!(item == null ? void 0 : item.$key)) {
+        if (!item?.$key) {
           return construct(descend(plumGraph, i), item);
         }
         const { $key, $chi, ...props2 } = item;
@@ -1259,11 +1246,11 @@ function addPageMeta(graph, args) {
   if (graph.length === count) {
     if ($first) {
       const boundKey = graph[graph.length - 1].$key;
-      $page.$until = isDef(boundKey == null ? void 0 : boundKey.$cursor) ? boundKey.$cursor : boundKey;
+      $page.$until = isDef(boundKey?.$cursor) ? boundKey.$cursor : boundKey;
       delete $page.$before;
     } else {
       const boundKey = graph[0].$key;
-      $page.$since = isDef(boundKey == null ? void 0 : boundKey.$cursor) ? boundKey.$cursor : boundKey;
+      $page.$since = isDef(boundKey?.$cursor) ? boundKey.$cursor : boundKey;
       delete $page.$after;
     }
   }
@@ -1271,102 +1258,8 @@ function addPageMeta(graph, args) {
   const $next = isDef($page.$before) ? { ...filter, $first: count, $since: $page.$before } : isDef($page.$until) ? { ...filter, $first: count, $after: $page.$until } : null;
   Object.assign(graph, { $page, $next, $prev });
 }
-function getByte(view, offset) {
-  return offset < view.byteLength ? view.getUint8(offset) : 0;
-}
-function getChar(string, offset) {
-  return offset < string.length ? alpha.indexOf(string[offset]) : 0;
-}
-function encode$1(u8Arr) {
-  const { buffer, byteOffset, byteLength } = u8Arr;
-  const view = new DataView(buffer, byteOffset, byteLength);
-  let str = "";
-  for (let i = 0; i < view.byteLength; i += 3) {
-    let value = (getByte(view, i) << 16) + (getByte(view, i + 1) << 8) + getByte(view, i + 2);
-    let gstr = "";
-    for (let j = 0; j < 4; j++) {
-      gstr = alpha[value & 63] + gstr;
-      value = value >> 6 | 0;
-    }
-    str += gstr;
-  }
-  return str.substring(0, Math.ceil(view.byteLength * 4 / 3));
-}
-function decode(string, start = 0) {
-  const buffer = new ArrayBuffer(Math.floor((string.length - start) * 3 / 4));
-  const view = new DataView(buffer);
-  for (let i = start; i < string.length; i += 4) {
-    let value = (getChar(string, i) << 18) + (getChar(string, i + 1) << 12) + (getChar(string, i + 2) << 6) + getChar(string, i + 3);
-    for (let j = i * 3 / 4 + 2; j >= i * 3 / 4; j--) {
-      if (j < view.byteLength) view.setUint8(j, value & 255);
-      value = value >> 8 | 0;
-    }
-  }
-  return addStringify(new Uint8Array(buffer));
-}
-const props = [
-  "end",
-  "version",
-  "limit",
-  "value",
-  "path",
-  "prefix",
-  "children"
-];
-function serializeKey(key) {
-  if (key[0] === STR) {
-    const last = key[key.length - 1];
-    if (last !== 0 && last !== 255) {
-      return decode$4(key);
-    }
-  }
-  return `\0${encode$1(key)}`;
-}
-function deserializeKey(key) {
-  if (key[0] === "\0") return decode(key.slice(1));
-  return encode$4(key);
-}
-function pack(children, parentVersion) {
-  if (!Array.isArray(children)) return children;
-  const array = children.map(
-    (node) => props.reduce(
-      (array2, prop, i) => {
-        if (!(prop in node)) return array2;
-        let value = node[prop];
-        if (prop === "version" && value === parentVersion) return array2;
-        if (prop === "children") value = pack(value, node.version);
-        if (prop === "end") value = serializeKey(value);
-        if (prop === "path") value = value.map(serializeKey);
-        array2[1] |= 1 << i;
-        array2.push(value);
-        return array2;
-      },
-      [serializeKey(node.key), 0]
-    )
-  );
-  return array;
-}
-function unpack(children, parentVersion) {
-  if (!Array.isArray(children)) return children;
-  const node = children.map(
-    ([key, type, ...values]) => props.reduce(
-      (node2, prop, i) => {
-        if (!(type & 1 << i)) return node2;
-        let value = values.shift();
-        if (prop === "children") value = unpack(value, node2.version);
-        if (prop === "end") value = deserializeKey(value);
-        if (prop === "path") value = value.map(deserializeKey);
-        node2[prop] = value;
-        return node2;
-      },
-      { key: deserializeKey(key), version: parentVersion }
-    )
-  );
-  return node;
-}
-const ROOT_KEY = Symbol();
-function encode(value, { version, isGraph } = {}) {
-  var _a;
+const ROOT_KEY = /* @__PURE__ */ Symbol();
+function encode$1(value, { version, isGraph } = {}) {
   const links = [];
   function pushLink($ref, $ver, props2, $val, $chi) {
     const [range, _] = splitRef($ref);
@@ -1378,7 +1271,6 @@ function encode(value, { version, isGraph } = {}) {
   }
   const combine = isGraph ? merge : add;
   function makeNode2(object, key, ver, parentPuts = []) {
-    var _a2;
     if (!isDef(object)) return;
     const { $key, $ver, $ref, $val, $chi, $put, ...props2 } = object || {};
     if (typeof object === "object" && object && !Array.isArray(object)) {
@@ -1423,7 +1315,7 @@ function encode(value, { version, isGraph } = {}) {
     }
     let putRange = [];
     const prefixPuts = [];
-    if (Array.isArray(object) && !isDef($put) && !isDef($val) && !object.some((it) => isDef(it == null ? void 0 : it.$key))) {
+    if (Array.isArray(object) && !isDef($put) && !isDef($val) && !object.some((it) => isDef(it?.$key))) {
       putRange = [encode$3({ $since: 0, $until: Number.POSITIVE_INFINITY })];
     }
     function classifyPut(put) {
@@ -1497,53 +1389,130 @@ function encode(value, { version, isGraph } = {}) {
     }
     if (
       // (key === ROOT_KEY || isDef(node.key)) &&
-      ((_a2 = node.children) == null ? void 0 : _a2.length) || isDef(node.end) || isDef(node.value) || isDef(node.path)
+      node.children?.length || isDef(node.end) || isDef(node.value) || isDef(node.path)
     ) {
       return node;
     }
   }
-  if (value == null ? void 0 : value.$key) value = [value];
-  const result = ((_a = makeNode2(value, ROOT_KEY, version)) == null ? void 0 : _a.children) || [];
+  if (value?.$key) value = [value];
+  const result = makeNode2(value, ROOT_KEY, version)?.children || [];
   while (links.length) {
     combine(result, [links.pop()]);
   }
   return result;
 }
 function encodeGraph(obj, version = Date.now()) {
-  const encoded = encode(obj, { version, isGraph: true });
+  const encoded = encode$1(obj, { version, isGraph: true });
   const versioned = setVersion(encoded, version, true);
   return versioned;
 }
 function encodeQuery(obj, version = 0) {
-  return encode(obj, { version, isGraph: false });
+  return encode$1(obj, { version, isGraph: false });
 }
-async function* mergeStreams(...streams) {
-  const firstValues = (await Promise.all(streams.map((stream) => stream.next()))).map((iter) => iter.value);
-  if (firstValues.some((value) => typeof value === "undefined")) {
-    yield void 0;
-    for (const value of firstValues) {
-      if (typeof value !== "undefined") yield value;
+let customAlphabet = (alphabet, defaultSize = 21) => {
+  return (size = defaultSize) => {
+    let id2 = "";
+    let i = size | 0;
+    while (i--) {
+      id2 += alphabet[Math.random() * alphabet.length | 0];
     }
-  } else {
-    const merged = [];
-    for (const value of firstValues) merge(merged, value);
-    yield merged;
+    return id2;
+  };
+};
+const alpha = "-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz";
+const id = customAlphabet(alpha, 20);
+function getByte(view, offset) {
+  return offset < view.byteLength ? view.getUint8(offset) : 0;
+}
+function getChar(string, offset) {
+  return offset < string.length ? alpha.indexOf(string[offset]) : 0;
+}
+function encode(u8Arr) {
+  const { buffer, byteOffset, byteLength } = u8Arr;
+  const view = new DataView(buffer, byteOffset, byteLength);
+  let str = "";
+  for (let i = 0; i < view.byteLength; i += 3) {
+    let value = (getByte(view, i) << 16) + (getByte(view, i + 1) << 8) + getByte(view, i + 2);
+    let gstr = "";
+    for (let j = 0; j < 4; j++) {
+      gstr = alpha[value & 63] + gstr;
+      value = value >> 6 | 0;
+    }
+    str += gstr;
   }
-  yield* mergeIterators(streams);
+  return str.substring(0, Math.ceil(view.byteLength * 4 / 3));
 }
-function makeWatcher() {
-  const listeners = /* @__PURE__ */ new Set();
-  function write(change) {
-    for (const push of listeners) push(change);
+function decode(string, start = 0) {
+  const buffer = new ArrayBuffer(Math.floor((string.length - start) * 3 / 4));
+  const view = new DataView(buffer);
+  for (let i = start; i < string.length; i += 4) {
+    let value = (getChar(string, i) << 18) + (getChar(string, i + 1) << 12) + (getChar(string, i + 2) << 6) + getChar(string, i + 3);
+    for (let j = i * 3 / 4 + 2; j >= i * 3 / 4; j--) {
+      if (j < view.byteLength) view.setUint8(j, value & 255);
+      value = value >> 8 | 0;
+    }
   }
-  function watch(...args) {
-    return makeStream((push, _end) => {
-      listeners.add(push);
-      if (args.length) Promise.resolve(args[0]).then(push);
-      return () => listeners.delete(push);
-    });
+  return addStringify(new Uint8Array(buffer));
+}
+const props = [
+  "end",
+  "version",
+  "limit",
+  "value",
+  "path",
+  "prefix",
+  "children"
+];
+function serializeKey(key) {
+  if (key[0] === STR) {
+    const last = key[key.length - 1];
+    if (last !== 0 && last !== 255) {
+      return decode$4(key);
+    }
   }
-  return { write, watch };
+  return `\0${encode(key)}`;
+}
+function deserializeKey(key) {
+  if (key[0] === "\0") return decode(key.slice(1));
+  return encode$4(key);
+}
+function pack(children, parentVersion) {
+  if (!Array.isArray(children)) return children;
+  const array = children.map(
+    (node) => props.reduce(
+      (array2, prop, i) => {
+        if (!(prop in node)) return array2;
+        let value = node[prop];
+        if (prop === "version" && value === parentVersion) return array2;
+        if (prop === "children") value = pack(value, node.version);
+        if (prop === "end") value = serializeKey(value);
+        if (prop === "path") value = value.map(serializeKey);
+        array2[1] |= 1 << i;
+        array2.push(value);
+        return array2;
+      },
+      [serializeKey(node.key), 0]
+    )
+  );
+  return array;
+}
+function unpack(children, parentVersion) {
+  if (!Array.isArray(children)) return children;
+  const node = children.map(
+    ([key, type, ...values]) => props.reduce(
+      (node2, prop, i) => {
+        if (!(type & 1 << i)) return node2;
+        let value = values.shift();
+        if (prop === "children") value = unpack(value, node2.version);
+        if (prop === "end") value = deserializeKey(value);
+        if (prop === "path") value = value.map(deserializeKey);
+        node2[prop] = value;
+        return node2;
+      },
+      { key: deserializeKey(key), version: parentVersion }
+    )
+  );
+  return node;
 }
 function mergeObject(base, change) {
   if (typeof change !== "object" || typeof base !== "object" || !base || !change) {
@@ -1607,12 +1576,40 @@ function unwrapObject(object, path) {
       if (page && !page.$cursor) {
         return object;
       }
-      const target = (page == null ? void 0 : page.$cursor) ? { ...filter, $cursor: page.$cursor } : filter;
+      const target = page?.$cursor ? { ...filter, $cursor: page.$cursor } : filter;
       object = object.find(({ $key: $key2 }) => isEqual($key2, target));
     }
   }
   return object;
 }
+function makeWatcher() {
+  const listeners = /* @__PURE__ */ new Set();
+  function write(change) {
+    for (const push of listeners) push(change);
+  }
+  function watch(...args) {
+    return makeStream((push, _end) => {
+      listeners.add(push);
+      if (args.length) Promise.resolve(args[0]).then(push);
+      return () => listeners.delete(push);
+    });
+  }
+  return { write, watch };
+}
+async function* mergeStreams(...streams) {
+  const firstValues = (await Promise.all(streams.map((stream) => stream.next()))).map((iter) => iter.value);
+  if (firstValues.some((value) => typeof value === "undefined")) {
+    yield void 0;
+    for (const value of firstValues) {
+      if (typeof value !== "undefined") yield value;
+    }
+  } else {
+    const merged = [];
+    for (const value of firstValues) merge(merged, value);
+    yield merged;
+  }
+  yield* mergeIterators(streams);
+}
 export {
   IS_VAL,
   MAX_KEY,