@graffy/common 0.15.8-alpha.2 → 0.15.8

package/index.cjs

@@ -0,0 +1,1561 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports[Symbol.toStringTag] = "Module";
+var nonSecure = require("nanoid/non-secure");
+var mergeIterators = require("merge-async-iterators");
+var stream = require("@graffy/stream");
+var isEqual = require("lodash/isEqual.js");
+function _interopDefaultLegacy(e) {
+  return e && typeof e === "object" && "default" in e ? e : { "default": e };
+}
+var mergeIterators__default = /* @__PURE__ */ _interopDefaultLegacy(mergeIterators);
+var isEqual__default = /* @__PURE__ */ _interopDefaultLegacy(isEqual);
+function encode$7(query) {
+  return encodeURIComponent(JSON.stringify(query));
+}
+function decode$7(fields) {
+  return JSON.parse(decodeURIComponent(fields));
+}
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder("utf-8");
+function encode$6(string) {
+  return textEncoder.encode(string);
+}
+function decode$6(u8Arr) {
+  return textDecoder.decode(u8Arr);
+}
+function encode$5(number) {
+  const buffer = new ArrayBuffer(8);
+  const view = new DataView(buffer);
+  view.setFloat64(0, number);
+  if (number < 0) {
+    view.setUint32(0, ~view.getUint32(0) >>> 0);
+    view.setUint32(4, ~view.getUint32(4) >>> 0);
+  } else {
+    view.setUint8(0, view.getUint8(0) | 128);
+  }
+  return new Uint8Array(buffer);
+}
+function decode$5(u8Arr) {
+  const { buffer, byteOffset, byteLength } = u8Arr;
+  const view = new DataView(buffer, byteOffset, byteLength);
+  const high = view.getUint8(0);
+  if (high & 128) {
+    view.setUint8(0, high & 127);
+  } else {
+    view.setUint32(0, ~view.getUint32(0) >>> 0);
+    view.setUint32(4, ~view.getUint32(4) >>> 0);
+  }
+  return view.getFloat64(0);
+}
+var alpha = "-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz";
+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$4(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.substr(0, Math.ceil(view.byteLength * 4 / 3));
+}
+function decode$4(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 new Uint8Array(buffer);
+}
+const END = 0;
+const NULL = 1;
+const FALSE = 2;
+const TRUE = 3;
+const NUM = 4;
+const STR = 5;
+const ARR = 6;
+const OBJ = 7;
+function encodeArray(array) {
+  return [
+    ARR,
+    ...array.flatMap((value) => encodeParts(value)),
+    END
+  ];
+}
+function encodeObject(object) {
+  const keys = Object.keys(object).sort();
+  return [
+    OBJ,
+    ...keys.flatMap((key) => [
+      STR,
+      encode$6(key),
+      END,
+      ...encodeParts(object[key])
+    ]),
+    END
+  ];
+}
+function encodeParts(value) {
+  if (value === null)
+    return [NULL];
+  if (value === false)
+    return [FALSE];
+  if (value === true)
+    return [TRUE];
+  if (typeof value === "number")
+    return [NUM, encode$5(value)];
+  if (typeof value === "string")
+    return [STR, encode$6(value), END];
+  if (Array.isArray(value))
+    return encodeArray(value);
+  if (typeof value === "object")
+    return encodeObject(value);
+  return [NULL];
+}
+function encode$3(value) {
+  const parts = encodeParts(value);
+  while (parts[parts.length - 1] === END)
+    parts.pop();
+  const length = parts.reduce((sum, part) => sum + (typeof part === "number" ? 1 : part.length), 0);
+  const buffer = new Uint8Array(length);
+  let i = 0;
+  for (const part of parts) {
+    if (typeof part === "number") {
+      buffer[i] = part;
+      i++;
+    } else {
+      buffer.set(part, i);
+      i += part.length;
+    }
+  }
+  return encode$4(buffer);
+}
+const nextKey = new WeakMap();
+function decode$3(key) {
+  let i = 0;
+  const buffer = decode$4(key, 0);
+  const stack = [[]];
+  function readString() {
+    let start = i;
+    while (i < buffer.length && buffer[i] !== END)
+      i++;
+    const str = decode$6(buffer.subarray(start, i));
+    i++;
+    return str;
+  }
+  function pushToken(type, value) {
+    const current = stack[stack.length - 1];
+    if (type === ARR || type === OBJ)
+      stack.push(value);
+    if (!current)
+      return;
+    if (Array.isArray(current)) {
+      current.push(value);
+    } else {
+      if (nextKey.has(current)) {
+        current[nextKey.get(current)] = value;
+        nextKey.delete(current);
+      } else {
+        nextKey.set(current, value);
+      }
+    }
+  }
+  function popToken() {
+    stack.pop();
+  }
+  while (i < buffer.length) {
+    const type = buffer[i];
+    const start = ++i;
+    switch (type) {
+      case END:
+        popToken();
+        break;
+      case NULL:
+        pushToken(type, null);
+        break;
+      case FALSE:
+        pushToken(type, false);
+        break;
+      case TRUE:
+        pushToken(type, true);
+        break;
+      case NUM:
+        i += 8;
+        pushToken(type, decode$5(buffer.subarray(start, i)));
+        break;
+      case STR:
+        pushToken(type, readString());
+        break;
+      case ARR:
+        pushToken(type, []);
+        break;
+      case OBJ:
+        pushToken(type, {});
+        break;
+      default:
+        throw new Error("Invalid byte " + type + " at " + start);
+    }
+  }
+  return stack[0][0];
+}
+function keyStep(key) {
+  if (key === "")
+    return { key, step: 1 };
+  if (key === "\uFFFF")
+    return { key, step: -1 };
+  const l = key.length - 1;
+  switch (key.charCodeAt(l)) {
+    case 0:
+      return { key: key.substr(0, l), step: 1 };
+    case 65535:
+      return {
+        key: key.substr(0, l - 1) + String.fromCharCode(key.charCodeAt(l - 1) + 1),
+        step: -1
+      };
+    default:
+      return { key, step: 0 };
+  }
+}
+function keyBefore(key) {
+  if (key === "" || key === "\uFFFF" || key === "\0" || key === "\0\uFFFF") {
+    return key;
+  }
+  const l = key.length - 1;
+  return key.charCodeAt(l) === 0 ? key.substr(0, l) : key.substr(0, l) + String.fromCharCode(key.charCodeAt(l) - 1) + "\uFFFF";
+}
+function keyAfter(key) {
+  if (key === "" || key === "\uFFFF" || key === "\0" || key === "\0\uFFFF") {
+    return key;
+  }
+  const l = key.length - 1;
+  return key.charCodeAt(l) === 65535 ? key.substr(0, l - 1) + String.fromCharCode(key.charCodeAt(l - 1) + 1) : key + "\0";
+}
+function err(message, _a = {}) {
+  var _b = _a, { cause } = _b, args = __objRest(_b, ["cause"]);
+  const e = new Error(message + (args ? " " + JSON.stringify(args) : ""));
+  e.cause = cause;
+  throw e;
+}
+function errIf(message, condition, args) {
+  if (condition)
+    err(message, args);
+}
+function isEmpty(object) {
+  for (const _ in object)
+    return false;
+  return true;
+}
+function isDef(value) {
+  return typeof value !== "undefined";
+}
+function isPlainObject(arg) {
+  return typeof arg === "object" && arg && !Array.isArray(arg);
+}
+function isEncodedKey(str) {
+  return str[0] === "\0";
+}
+function find(items, compare2, first = 0, last = items.length) {
+  let currentFirst = first;
+  let currentLast = last;
+  while (currentFirst < currentLast) {
+    const ix = (currentFirst + currentLast) / 2 | 0;
+    const d = compare2(items[ix]);
+    if (d < 0) {
+      currentFirst = ix + 1;
+    } else if (d > 0) {
+      currentLast = ix;
+    } else {
+      return ix;
+    }
+  }
+  return currentFirst;
+}
+function maybeEncode(value) {
+  return typeof value === "string" ? value : "\0" + encode$3(value);
+}
+function maybeDecode(string) {
+  if (isEncodedKey(string)) {
+    const { key, step } = keyStep(string.slice(1));
+    const value = key === "" || key === "\uFFFF" ? key : decode$3(key);
+    return { key: value, step };
+  } else {
+    return keyStep(string);
+  }
+}
+const pageProps = {
+  $all: 1,
+  $first: 1,
+  $last: 1,
+  $after: 1,
+  $before: 1,
+  $since: 1,
+  $until: 1,
+  $cursor: 1
+};
+function splitArgs(arg) {
+  const page = {};
+  const filter = {};
+  for (const p in arg)
+    (p in pageProps ? page : filter)[p] = arg[p];
+  return [
+    isEmpty(page) ? void 0 : page,
+    isEmpty(filter) ? void 0 : filter
+  ];
+}
+function encode$2(arg) {
+  if (!isPlainObject(arg))
+    return { key: maybeEncode(arg) };
+  const [page, filter] = splitArgs(arg);
+  errIf("page_and_filter", page && filter, arg);
+  if (!page)
+    return { key: maybeEncode(filter || {}) };
+  const _a = page, { $cursor } = _a, range = __objRest(_a, ["$cursor"]);
+  const { $first, $all, $last, $after, $before, $since, $until } = range;
+  const hasRange = !isEmpty(range);
+  errIf("first_and_last", isDef($first) && isDef($last), arg);
+  errIf("all_and_last", isDef($all) && isDef($last), arg);
+  errIf("all_and_first", isDef($first) && isDef($all), arg);
+  errIf("after_and_since", isDef($after) && isDef($since), arg);
+  errIf("before_and_until", isDef($before) && isDef($until), arg);
+  errIf("cursor_and_range_arg", isDef($cursor) && hasRange, arg);
+  let [key, end] = hasRange ? ["", "\uFFFF"] : [];
+  if (isDef($cursor))
+    key = maybeEncode($cursor);
+  if (isDef($after))
+    key = keyAfter(maybeEncode($after));
+  if (isDef($before))
+    end = keyBefore(maybeEncode($before));
+  if (isDef($since))
+    key = maybeEncode($since);
+  if (isDef($until))
+    end = maybeEncode($until);
+  if (isDef($last))
+    [key, end] = [end, key];
+  const node = { key };
+  if (isDef(end))
+    node.end = end;
+  if ($first || $last)
+    node.limit = $first || $last;
+  return node;
+}
+function decode$2(node) {
+  if (typeof node === "string")
+    return node;
+  const { key, end, limit } = node;
+  if (!isEncodedKey(key) && (!isDef(end) || end === key))
+    return key;
+  errIf("no_key", !isDef(key));
+  errIf("limit_without_end", isDef(limit) && !isDef(end));
+  const kParts = maybeDecode(key);
+  if (!isDef(end))
+    return kParts.key;
+  const eParts = maybeDecode(end);
+  const [lower, upper] = key < end ? [kParts, eParts] : [eParts, kParts];
+  const args = {};
+  if (limit) {
+    args[key < end ? "$first" : "$last"] = limit;
+  } else if (lower.key === "" && upper.key === "\uFFFF") {
+    args.$all = true;
+  }
+  if (lower.key !== "") {
+    args[lower.step === 1 ? "$after" : "$since"] = lower.key;
+  }
+  if (upper.key !== "\uFFFF") {
+    args[upper.step === -1 ? "$before" : "$until"] = upper.key;
+  }
+  return args;
+}
+const PATH_SEPARATOR = ".";
+function encode$1(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 (typeof seg === "string")
+      return seg;
+    const { key, end } = encode$2(seg);
+    if (end)
+      throw "encodePath.unexpected_range_key";
+    return key;
+  }
+  if (!isPlainObject(path[path.length - 1]))
+    return path.map(encodeSegment);
+  const [page, filter = {}] = splitArgs(path[path.length - 1]);
+  if (!page)
+    return path.map(encodeSegment);
+  return path.slice(0, -1).concat([filter]).map(encodeSegment);
+}
+function decode$1(path) {
+  if (!Array.isArray(path)) {
+    throw Error("decodePath.invalid:" + JSON.stringify(path));
+  }
+  return path.map((key) => decode$2({ key }));
+}
+function splitRef($ref) {
+  if (!Array.isArray($ref))
+    return [];
+  const tail = $ref[$ref.length - 1];
+  if (!isPlainObject(tail))
+    return [];
+  return splitArgs(tail);
+}
+var id = nonSecure.customAlphabet(alpha, 20);
+function findFirst(children, target) {
+  return find(children, ({ key, end }) => {
+    if (key === target || end && key < target && end >= target)
+      return 0;
+    if (key < target)
+      return -1;
+    return 1;
+  });
+}
+function findLast(children, end, first, last) {
+  const ix = findFirst(children, end);
+  return children[ix] && children[ix].key <= end ? ix + 1 : ix;
+}
+function isRange(node) {
+  return node && typeof node.end !== "undefined";
+}
+function isBranch(node) {
+  return node && typeof node.children !== "undefined";
+}
+function isPrefix(node) {
+  return node && node.prefix;
+}
+function isLink(node) {
+  return node && typeof node.path !== "undefined";
+}
+function isEncoded(node) {
+  return node && node.key[0] === "\0";
+}
+function isOlder(node, version) {
+  return typeof node.version !== "undefined" && node.version < version;
+}
+function isNewer(node, version) {
+  return typeof node.version !== "undefined" && node.version > version;
+}
+function add(base, diff) {
+  let changed = false;
+  let index = 0;
+  for (const node of diff) {
+    const cmp = compare(node);
+    const nodeIsBranch = isBranch(node);
+    index = find(base, cmp, index);
+    const item = base[index];
+    const itemIsBranch = isBranch(item);
+    if (!item || cmp(item)) {
+      base.splice(index, 0, clone(node));
+      changed = true;
+      continue;
+    }
+    if (nodeIsBranch && itemIsBranch) {
+      changed = add(item.children, node.children) || changed;
+    } else if (nodeIsBranch || itemIsBranch) {
+      throw new Error("add.branch_leaf_mismatch");
+    } else {
+      item.value += node.value;
+    }
+    const size = itemIsBranch ? item.children.length : item.value;
+    if (!size) {
+      base.splice(index, 1);
+      changed = true;
+    }
+  }
+  return changed;
+}
+function compare(node) {
+  return (item) => {
+    const v = compareValue(item.key, node.key) || compareValue(item.end, node.end) || compareValue(item.limit, node.limit);
+    return v;
+  };
+}
+function compareValue(a, b) {
+  if (a === b)
+    return 0;
+  return a < b ? -1 : 1;
+}
+function clone(node) {
+  const copy = __spreadValues({}, node);
+  if (node.children)
+    copy.children = node.children.map((child) => clone(child));
+  return copy;
+}
+function merge(current, changes) {
+  let index = 0;
+  for (const change of changes) {
+    index = isRange(change) ? insertRange$1(current, change, index) : insertNode$1(current, change, index);
+  }
+  return current;
+}
+function insertRange$1(current, change, start = 0) {
+  const { key, end } = change;
+  const keyIx = findFirst(current, key);
+  const endIx = findLast(current, end);
+  const insertions = [change];
+  for (let i = keyIx; i < endIx; i++) {
+    const node = current[i];
+    if (isRange(node)) {
+      insertions.push(...mergeRanges$1(insertions.pop(), node));
+    } else {
+      insertNode$1(insertions, node, insertions.length - 1);
+    }
+  }
+  current.splice(keyIx, endIx - keyIx, ...insertions);
+  return keyIx + insertions.length;
+}
+function mergeRanges$1(base, node) {
+  if (node.version < base.version)
+    [node, base] = [base, node];
+  return [
+    base.key < node.key && __spreadProps(__spreadValues({}, base), { end: keyBefore(node.key) }),
+    node,
+    base.end > node.end && __spreadProps(__spreadValues({}, base), { key: keyAfter(node.end) })
+  ].filter(Boolean);
+}
+function insertNode$1(current, change, start = 0) {
+  if (!current)
+    throw new Error("merge.insertNode: " + current);
+  const key = change.key;
+  const index = findFirst(current, key);
+  const node = current[index];
+  if (node && node.key <= key) {
+    return isRange(node) ? insertNodeIntoRange$1(current, index, change) : updateNode$1(current, index, change);
+  } else {
+    current.splice(index, 0, change);
+    return index + 1;
+  }
+}
+function insertNodeIntoRange$1(current, index, change) {
+  const key = change.key;
+  const range = current[index];
+  const newChange = getNewer(change, range);
+  if (!newChange)
+    return;
+  const insertions = [
+    range.key < key && __spreadProps(__spreadValues({}, range), { end: keyBefore(key) }),
+    newChange,
+    range.end > key && __spreadProps(__spreadValues({}, range), { key: keyAfter(key) })
+  ].filter(Boolean);
+  current.splice(index, 1, ...insertions);
+  return index + insertions.length;
+}
+function updateNode$1(current, index, change) {
+  const node = current[index];
+  if (isBranch(change) && isBranch(node)) {
+    merge(node.children, change.children);
+  } else if (isBranch(node)) {
+    const newNode = getNewer(node, change);
+    current[index] = newNode || change;
+  } else {
+    const newChange = getNewer(change, node);
+    if (newChange)
+      current[index] = newChange;
+  }
+  if (change.prefix)
+    current[index].prefix = true;
+  return index + 1;
+}
+function getNewer(node, base) {
+  const { version } = base;
+  if (isBranch(node)) {
+    const children = [{ key: "", end: "\uFFFF", version }];
+    merge(children, node.children);
+    return children.length === 1 ? null : __spreadProps(__spreadValues({}, node), { children });
+  } else {
+    return node.version >= version ? node : null;
+  }
+}
+const IS_VAL = Symbol("IS_VAL");
+function wrapValue(value, path, version = 0) {
+  const node = __spreadProps(__spreadValues({}, encode$2(path[path.length - 1])), { value, version });
+  return wrap([node], path.slice(0, -1), version);
+}
+function wrap(children, path, version = 0, prefix = false) {
+  if (!Array.isArray(path))
+    throw Error("wrap.path_not_array " + path);
+  if (!path.length)
+    return children;
+  let i = path.length - 1;
+  if (!Array.isArray(children)) {
+    children = [__spreadProps(__spreadValues({}, encode$2(path[i--])), { value: children, version })];
+  } else {
+    if (!children.length)
+      return;
+    children = [__spreadProps(__spreadValues({}, encode$2(path[i--])), { version, children })];
+  }
+  if (prefix)
+    children[0].prefix = true;
+  while (i >= 0)
+    children = [__spreadProps(__spreadValues({}, encode$2(path[i--])), { version, children })];
+  return children;
+}
+function unwrap(children, path) {
+  if (!Array.isArray(path))
+    throw Error("unwrap.path_not_array " + path);
+  let node = { children };
+  for (let i = 0; i < path.length; i++) {
+    const { key } = encode$2(path[i]);
+    children = node.children;
+    if (!children)
+      return null;
+    node = children[findFirst(children, key)];
+    if (!node || node.key > key)
+      return void 0;
+    if (isRange(node))
+      return null;
+  }
+  return getNodeValue(node);
+}
+function getNodeValue(node) {
+  if (node.children)
+    return node.children;
+  if (node.value && typeof node.value === "object") {
+    node.value[IS_VAL] = true;
+  }
+  return node.value;
+}
+function remove(children, path) {
+  if (!Array.isArray(path))
+    throw Error("del.path_not_array " + path);
+  if (!children)
+    return null;
+  if (!path.length)
+    return [];
+  const key = path[0];
+  const ix = findFirst(children, key);
+  const node = children[ix];
+  if (!node || node.key > key || isRange(node))
+    return children;
+  if (path.length === 1) {
+    return children.slice(0, ix).concat(children.slice(ix + 1));
+  }
+  if (!isBranch(node))
+    return children;
+  const filteredChildren = remove(node.children, path.slice(1));
+  if (filteredChildren === path.children)
+    return children;
+  const filteredNode = filteredChildren.length ? __spreadProps(__spreadValues({}, 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 slice(graph, query, root) {
+  let 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;
+  }
+  delete result.root;
+  return result;
+}
+function sliceNode(graph, query, result) {
+  const { key, version } = query;
+  const { root } = result;
+  if (!graph || graph.key > key || isOlder(graph, version)) {
+    result.addUnknown(query);
+  } else if (isRange(graph)) {
+    if (isBranch(query)) {
+      const { known } = slice([{ key: "", end: "\uFFFF", 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(__spreadProps(__spreadValues({}, graph), { children: known }));
+    if (unknown)
+      result.addUnknown(__spreadProps(__spreadValues({}, 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: "", end: "\uFFFF", 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 = Infinity, version } = query;
+  const step = key < end ? 1 : -1;
+  if (graph[0].key === "" && graph[0].prefix) {
+    sliceNode(graph[0], query, result);
+    return;
+  }
+  if (key < end) {
+    for (let i = findFirst(graph, key); key <= end && limit > 0; i++) {
+      const node = graph[i];
+      if (!node || key < node.key || isOlder(node, version))
+        break;
+      if (isRange(node)) {
+        result.addKnown(getOverlap(node, key, end));
+      } else {
+        sliceNode(node, __spreadProps(__spreadValues({}, query), { key }), result);
+        limit--;
+      }
+      key = keyAfter(node.end || node.key);
+    }
+  } else {
+    for (let i = findLast(graph, key) - 1; key >= end && limit > 0; i--) {
+      const node = graph[i];
+      if (!node || key > (node.end || node.key) || isOlder(node, version))
+        break;
+      if (isRange(node)) {
+        result.addKnown(getOverlap(node, end, key));
+      } else {
+        sliceNode(node, __spreadProps(__spreadValues({}, query), { key }), result);
+        limit--;
+      }
+      key = keyBefore(node.key);
+    }
+  }
+  if (limit && (step < 0 ? key > end : key < end)) {
+    const unknown = __spreadProps(__spreadValues({}, query), { key, end, limit });
+    result.addUnknown(unknown);
+  }
+}
+function getOverlap(node, key, end) {
+  if (node.key >= key && node.end <= end)
+    return node;
+  return __spreadProps(__spreadValues({}, node), {
+    key: node.key > key ? node.key : key,
+    end: node.end < end ? 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);
+  const endIx = findLast(current, end);
+  if (keyIx === endIx && !(current[keyIx] && current[keyIx].key <= key && current[keyIx].end >= end)) {
+    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 (node.key > currentKey) {
+        appliedChange.push({
+          key: currentKey,
+          end: keyBefore(node.key),
+          version: change.version
+        });
+      }
+      currentKey = keyAfter(node.end);
+    } else {
+      if (getNewerChange(node, change)) {
+        appliedChange.push({
+          key: currentKey,
+          end: keyBefore(node.key),
+          version: change.version
+        });
+        currentKey = keyAfter(node.key);
+      }
+    }
+    if (currentKey >= change.end) {
+      break;
+    }
+  }
+  if (currentKey <= change.end) {
+    appliedChange.push({
+      key: currentKey,
+      end: change.end,
+      version: change.version
+    });
+  }
+  if (appliedChange.length)
+    result.push(...appliedChange);
+  const insertions = [change];
+  for (let i = keyIx; i < endIx; i++) {
+    const node = current[i];
+    if (isRange(node)) {
+      insertions.push(...mergeRanges(insertions.pop(), node));
+    } else {
+      insertNode(insertions, node, [], insertions.length - 1);
+    }
+  }
+  current.splice(keyIx, endIx - keyIx, ...insertions);
+  return keyIx + insertions.length;
+}
+function mergeRanges(base, node) {
+  if (node.version < base.version)
+    [node, base] = [base, node];
+  return [
+    base.key < node.key && __spreadProps(__spreadValues({}, base), { end: keyBefore(node.key) }),
+    node,
+    base.end > node.end && __spreadProps(__spreadValues({}, base), { key: keyAfter(node.end) })
+  ].filter(Boolean);
+}
+function insertNode(current, change, result, start = 0) {
+  const key = change.key;
+  const index = findFirst(current, key);
+  const node = current[index];
+  if (node && node.key <= key) {
+    return isRange(node) ? insertNodeIntoRange(current, index, change, result) : updateNode(current, index, change, result);
+  } else {
+    return index;
+  }
+}
+function insertNodeIntoRange(current, index, change, result) {
+  const key = change.key;
+  const range = current[index];
+  const newChange = getNewerChange(change, range);
+  const newNode = getNewerNode(change, range);
+  if (!newChange)
+    return;
+  result.push(newChange);
+  const insertions = [
+    range.key < key && __spreadProps(__spreadValues({}, range), { end: keyBefore(key) }),
+    newNode,
+    range.end > key && __spreadProps(__spreadValues({}, range), { key: keyAfter(key) })
+  ].filter(Boolean);
+  current.splice(index, 1, ...insertions);
+  return index + insertions.length;
+}
+function updateNode(current, index, change, result) {
+  const node = current[index];
+  if (isBranch(change) && isBranch(node)) {
+    const nextResult = [];
+    node.version = change.version;
+    sieve(node.children, change.children, nextResult);
+    if (nextResult.length)
+      result.push(__spreadProps(__spreadValues({}, change), { children: nextResult }));
+  } else if (isBranch(node)) {
+    const newNode = getNewerNode(node, change);
+    current[index] = newNode || change;
+    if (!newNode)
+      result.push(change);
+  } else {
+    const newChange = getNewerChange(change, node);
+    const newNode = getNewerNode(change, node);
+    if (newNode)
+      current[index] = newNode;
+    if (newChange && (change.value !== node.value || !isPathEqual(change.path, node.path))) {
+      result.push(newChange);
+    }
+  }
+  return index + 1;
+}
+function isPathEqual(first, second) {
+  if (!first && !second)
+    return true;
+  if (!first || !second)
+    return false;
+  if (first.length !== second.length)
+    return false;
+  for (let i = 0; i < first.length; i++) {
+    if (first[i] !== second[i])
+      return false;
+  }
+  return true;
+}
+function getNewerNode(node, base) {
+  if (isBranch(node)) {
+    const emptyNode = { key: "", end: "\uFFFF", version: base.version };
+    const children = [emptyNode];
+    sieve(children, node.children);
+    return children.length === 1 && children[0] === emptyNode ? null : __spreadProps(__spreadValues({}, node), { children });
+  } else {
+    return node.version >= base.version ? node : null;
+  }
+}
+function getNewerChange(node, base) {
+  if (isBranch(node)) {
+    const children = node.children.filter((child) => getNewerChange(child, base));
+    return children.length && __spreadProps(__spreadValues({}, node), { children });
+  } else {
+    return node.version >= base.version ? node : null;
+  }
+}
+function setVersion(graph, version) {
+  for (const node of graph) {
+    node.version = version;
+    if (node.children)
+      setVersion(node.children, version);
+  }
+  return graph;
+}
+function getKnown(graph, version = 0) {
+  const query = [];
+  for (const { key, end, children } of graph) {
+    const node = { key, version };
+    if (end) {
+      if (end !== key)
+        node.end = end;
+      node.value = 1;
+    }
+    if (children) {
+      node.children = getKnown(children);
+    } else {
+      node.value = 1;
+    }
+    query.push(node);
+  }
+  return query;
+}
+function finalize(graph, query, version = Date.now()) {
+  let result = [{ key: "", end: "\uFFFF", version: 0 }];
+  if (query)
+    result = slice(result, query).known || [];
+  result = setVersion(merge(result, graph), version);
+  return result;
+}
+function decode(nodes = [], { isGraph } = {}) {
+  function decodeChildren(nodes2) {
+    let result = [];
+    let allStrs = true;
+    let allNums = true;
+    function pushResult(...objects) {
+      for (const object of objects) {
+        if (isDef(object) && !Number.isInteger(object.$key))
+          allNums = false;
+        if (isDef(object) && typeof object.$key !== "string")
+          allStrs = false;
+      }
+      result.push(...objects);
+    }
+    const putRanges = [];
+    let lastNode = null;
+    function addPutRange({ key, end }) {
+      if (lastNode) {
+        if (lastNode.end) {
+          if (key === keyAfter(lastNode.end)) {
+            lastNode.end = end || key;
+            return end && end !== key;
+          }
+        } else {
+          if (key === keyAfter(lastNode.key))
+            key = lastNode.key;
+        }
+      }
+      if (end && key !== end) {
+        lastNode = { key, end };
+        putRanges.push(lastNode);
+        return true;
+      }
+      lastNode = { key };
+      return false;
+    }
+    for (const node of nodes2) {
+      if (isGraph && addPutRange(node))
+        continue;
+      if (isPrefix(node))
+        pushResult(...decodePrefixNode(node));
+      else if (isGraph && isRange(node))
+        pushResult(decodeRangeNode(node));
+      else if (isBranch(node))
+        pushResult(decodeBranchNode(node));
+      else if (isLink(node))
+        pushResult(decodeLinkNode(node));
+      else
+        pushResult(decodeLeafNode(node));
+    }
+    if (allNums || allStrs) {
+      result = result.reduce((collection, item) => {
+        if (Array.isArray(item)) {
+          collection[item.$key] = item;
+          delete item.$key;
+          return collection;
+        }
+        const _a = item, { $key, $val } = _a, rest = __objRest(_a, ["$key", "$val"]);
+        if (typeof $val === "object")
+          $val.$val = true;
+        collection[$key] = isDef($val) ? $val : !isEmpty(rest) ? rest : isGraph ? null : true;
+        return collection;
+      }, allStrs ? {} : []);
+    }
+    if (isGraph && putRanges.length) {
+      if (putRanges.length === 1 && putRanges[0].key === "" && putRanges[0].end === "\uFFFF") {
+        result.$put = true;
+      } else {
+        result.$put = putRanges.map((rNode) => decode$2(rNode));
+      }
+    }
+    return result;
+  }
+  function decodePrefixNode(node) {
+    let args = decode$2(node);
+    if (args === "")
+      args = {};
+    if (typeof args === "string") {
+      throw Error("decode.unencoded_prefix: " + args);
+    }
+    if (isLink(node)) {
+      args.$all = true;
+      const $ref = decode$1(node.path);
+      const lastKey = $ref[$ref.length - 1];
+      if (typeof lastKey === "string") {
+        throw Error("decode.unencoded_prefix_ref: " + node.path);
+      }
+      lastKey.$all = true;
+      return [{ $key: args, $ref }];
+    }
+    const children = decodeChildren(node.children);
+    if (!Array.isArray(children)) {
+      throw Error("decode.prefix_without_encoded_child_keys:" + node.key);
+    }
+    for (const child of children) {
+      if (typeof child.$key === "string") {
+        throw Error("decode.prefix_with_unencoded_child_key:" + child.$key);
+      }
+      if (!splitArgs(child.$key)[0]) {
+        child.$key = { $cursor: child.$key };
+      }
+      child.$key = __spreadValues(__spreadValues({}, args), child.$key);
+    }
+    return children;
+  }
+  function decodeBranchNode(node) {
+    const child = decodeChildren(node.children);
+    child.$key = decode$2(node);
+    return child;
+  }
+  function decodeLeafNode(node) {
+    const child = isGraph ? { $val: node.value } : {};
+    child.$key = decode$2(node);
+    return child;
+  }
+  function decodeRangeNode(node) {
+    if (node.key === node.end)
+      return { $key: decode$2({ key: node.key }) };
+  }
+  function decodeLinkNode(node) {
+    return { $key: decode$2(node), $ref: decode$1(node.path) };
+  }
+  return decodeChildren(nodes);
+}
+function decodeGraph(graph) {
+  return decode(graph, { isGraph: true });
+}
+function decodeQuery(query) {
+  return decode(query, { isGraph: false });
+}
+const REF = Symbol();
+const PRE = Symbol();
+function decorate(rootGraph, rootQuery) {
+  function construct(plumGraph, query) {
+    if (plumGraph === null)
+      return null;
+    if (!isDef(plumGraph))
+      plumGraph = [];
+    if (query.$key)
+      query = [query];
+    let graph;
+    if (query.$ref) {
+      const _a = query, { $ref } = _a, props = __objRest(_a, ["$ref"]);
+      const [range, filter] = splitRef($ref);
+      const path = encode$1($ref);
+      const targetPlumGraph = unwrap(rootGraph, path);
+      if (range)
+        targetPlumGraph[PRE] = filter;
+      graph = construct(targetPlumGraph, range ? __spreadValues({ $key: range }, props) : props);
+      graph.$ref = $ref;
+    } else if (Array.isArray(query)) {
+      let pageKey;
+      graph = query.flatMap((item, i) => {
+        if (!(item == null ? void 0 : item.$key)) {
+          return construct(descend(plumGraph, i), item);
+        }
+        const _a2 = item, { $key, $chi } = _a2, props = __objRest(_a2, ["$key", "$chi"]);
+        const subQuery = $chi || (isEmpty(props) ? 1 : props);
+        if (!isPlainObject($key) || !splitArgs($key)[0]) {
+          return construct(descend(plumGraph, $key), subQuery);
+        }
+        if (pageKey) {
+          throw Error("decorate.multi_range_query:" + JSON.stringify({ $key, pageKey }));
+        }
+        pageKey = $key;
+        const children = slice2(plumGraph, $key);
+        return children.filter((node) => !isRange(node)).map((node) => {
+          const $key2 = decode$2(node);
+          const subResult = construct(getValue(node), subQuery);
+          if (typeof subResult === "object") {
+            subResult.$key = children[PRE] ? __spreadProps(__spreadValues({}, children[PRE]), { $cursor: $key2 }) : $key2;
+          }
+          return subResult;
+        });
+      });
+      addPageMeta(graph, pageKey);
+    } else if (typeof query === "object") {
+      graph = {};
+      for (const prop in query) {
+        graph[prop] = construct(descend(plumGraph, prop), query[prop]);
+      }
+    } else if (query) {
+      if (Array.isArray(plumGraph) && !plumGraph.length) {
+        graph = void 0;
+      } else if (typeof plumGraph !== "object" || !plumGraph) {
+        graph = plumGraph;
+      } else if (plumGraph[IS_VAL]) {
+        graph = Array.isArray(plumGraph) ? plumGraph.slice(0) : __spreadValues({}, plumGraph);
+        graph.$val = true;
+      } else if (Array.isArray(plumGraph)) {
+        graph = decodeGraph(plumGraph);
+      } else {
+        throw Error("decorate.unexpected_graph", plumGraph);
+      }
+    }
+    if (plumGraph[REF])
+      graph.$ref = decode$1(plumGraph[REF]);
+    return graph;
+  }
+  function descend(children, $key) {
+    const { key } = encode$2($key);
+    if (!Array.isArray(children))
+      return null;
+    const ix = findFirst(children, key);
+    const node = children[ix];
+    if (!node)
+      return;
+    if (isRange(node) && node.end >= key)
+      return null;
+    if (node.key !== key)
+      return;
+    const result2 = getValue(node);
+    if (node.prefix)
+      result2[PRE] = $key;
+    return result2;
+  }
+  function getValue(node) {
+    let result2;
+    if (node.path) {
+      result2 = unwrap(rootGraph, node.path);
+      if (typeof result2 === "object")
+        result2[REF] = node.path;
+    } else {
+      result2 = getNodeValue(node);
+    }
+    return result2;
+  }
+  function slice2(children, $key) {
+    const [range, filter] = splitArgs($key);
+    if (isDef(filter)) {
+      children = descend(children, filter);
+    } else if (children[0].key === "" && children[0].prefix) {
+      children = descend(children, "");
+    }
+    const { key, end, limit = Infinity } = encode$2(range);
+    const ix = findFirst(children, key);
+    let i = ix;
+    let result2;
+    if (key < end) {
+      for (let n = 0; i < children.length && n < limit; i++) {
+        if (!isRange(children[i]))
+          n++;
+      }
+      result2 = children.slice(ix, i);
+    } else {
+      for (let n = 0; i >= 0 && n < limit; i--) {
+        if (!isRange(children[i]))
+          n++;
+      }
+      result2 = children.slice(i + 1, ix + 1);
+    }
+    if (children[REF])
+      result2[REF] = children[REF];
+    if (children[PRE])
+      result2[PRE] = children[PRE];
+    return result2;
+  }
+  const result = construct(rootGraph, rootQuery);
+  return result;
+}
+function addPageMeta(graph, args) {
+  if (args.$all) {
+    Object.assign(graph, { $page: args, $prev: null, $next: null });
+    return;
+  }
+  const [_a, ..._b] = splitArgs(args), _c = _a, { $first, $last } = _c, bounds = __objRest(_c, ["$first", "$last"]), [filter] = _b;
+  const count = $first || $last;
+  const $page = __spreadProps(__spreadValues(__spreadValues({}, filter), bounds), { $all: true });
+  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;
+      delete $page.$before;
+    } else {
+      const boundKey = graph[0].$key;
+      $page.$since = isDef(boundKey == null ? void 0 : boundKey.$cursor) ? boundKey.$cursor : boundKey;
+      delete $page.$after;
+    }
+  }
+  const $prev = isDef($page.$after) ? __spreadProps(__spreadValues({}, filter), { $last: count, $until: $page.$after }) : isDef($page.$since) ? __spreadProps(__spreadValues({}, filter), { $last: count, $before: $page.$since }) : null;
+  let $next = isDef($page.$before) ? __spreadProps(__spreadValues({}, filter), { $first: count, $since: $page.$before }) : isDef($page.$until) ? __spreadProps(__spreadValues({}, filter), { $first: count, $after: $page.$until }) : null;
+  Object.assign(graph, { $page, $next, $prev });
+}
+function serialize(obj) {
+  return JSON.stringify(obj).replace(/\uffff/g, "\\uffff");
+}
+function deserialize(str) {
+  return JSON.parse(str);
+}
+const ROOT_KEY = Symbol();
+function encode(value, { version, isGraph } = {}) {
+  var _a;
+  const links = [];
+  function pushLink($ref, $ver, props, $val, $chi) {
+    const [range, _] = splitRef($ref);
+    let children = !isEmpty(props) ? makeNode(range ? [__spreadValues({ $key: range }, props)] : props, void 0, $ver).children : isDef($chi) ? makeNode(range ? [{ $key: range, $chi }] : $chi, void 0, $ver).children : isDef($val) ? $val : isGraph ? void 0 : 1;
+    if (children) {
+      links.push(wrap(children, encode$1($ref), $ver, !!range)[0]);
+    }
+  }
+  const combine = isGraph ? merge : add;
+  function makeNode(object, key, ver) {
+    var _c;
+    if (!isDef(object))
+      return;
+    if (typeof object === "object" && object && isEmpty(object))
+      return;
+    const _a2 = object || {}, { $key, $ver } = _a2, data = __objRest(_a2, ["$key", "$ver"]);
+    const _b = data, { $ref, $val, $chi, $put } = _b, props = __objRest(_b, ["$ref", "$val", "$chi", "$put"]);
+    if (isDef($ver))
+      ver = $ver;
+    if (isPlainObject($key)) {
+      const [page, filter] = splitArgs($key);
+      if (isGraph && page && !isDef(page.$cursor) && !isEmpty(data)) {
+        const node2 = makeNode(__spreadProps(__spreadValues({}, object), { $key: filter || "" }), key, ver);
+        node2.prefix = true;
+        return node2;
+      }
+      if ((!isDef(key) || Number.isInteger(key)) && page && filter) {
+        const node2 = makeNode({
+          $key: filter,
+          $chi: [
+            __spreadProps(__spreadValues({}, object), { $key: isDef(page.$cursor) ? page.$cursor : page })
+          ]
+        }, key, ver);
+        node2.prefix = true;
+        return node2;
+      }
+    }
+    if (isDef($key) && (Number.isInteger(key) || !isDef(key)))
+      key = $key;
+    const node = key === ROOT_KEY || !isDef(key) ? {} : encode$2(key);
+    node.version = ver;
+    if (object === null) {
+      node.end = node.key;
+    } else if (isDef($key) && isDef(key) && key !== $key) {
+      node.children = [makeNode(object, void 0, ver)].filter(Boolean);
+    } else if ($ref) {
+      pushLink($ref, node.version, props, $val, $chi);
+      if (!isGraph)
+        return;
+      node.path = encode$1($ref);
+    } else if ($val === true) {
+      node.value = props;
+    } else if (isDef($val)) {
+      node.value = $val;
+    } else if (typeof object !== "object") {
+      node.value = isGraph || typeof object === "number" ? object : 1;
+    } else if (isDef($chi)) {
+      const children = $chi.map((obj) => makeNode(obj, void 0, ver)).filter(Boolean).sort((a, b) => a.key <= b.key ? -1 : 1);
+      if (children.length) {
+        node.children = children;
+      }
+    } else if (Array.isArray(object)) {
+      const children = object.map((obj, i) => makeNode(obj, i, ver)).filter(Boolean).reduce((acc, it) => {
+        combine(acc, [it]);
+        return acc;
+      }, []);
+      if (children.length) {
+        node.children = children;
+      }
+    } else {
+      const children = Object.keys(props).sort().map((key2) => makeNode(object[key2], key2, ver)).filter(Boolean);
+      if (children.length) {
+        node.children = children;
+      } else if (isGraph) {
+        if (node.key && !node.end)
+          node.end = node.key;
+      } else {
+        node.value = 1;
+      }
+    }
+    let putQuery;
+    if (Array.isArray(object) && !object.some((it) => isDef(it == null ? void 0 : it.$key))) {
+      putQuery = [encode$2({ $since: 0, $until: Infinity })];
+    }
+    if ($put === true) {
+      putQuery = null;
+    } else if (Array.isArray($put)) {
+      putQuery = $put.map((arg) => encode$2(arg));
+    } else if (isDef($put)) {
+      putQuery = [encode$2($put)];
+    }
+    if (isGraph && isDef(putQuery)) {
+      node.children = finalize(node.children || [], putQuery, node.version);
+    }
+    if (((_c = node.children) == null ? void 0 : _c.length) || isDef(node.end) || isDef(node.value) || isDef(node.path)) {
+      return node;
+    }
+  }
+  if (value == null ? void 0 : value.$key)
+    value = [value];
+  let result = ((_a = makeNode(value, ROOT_KEY, version)) == null ? void 0 : _a.children) || [];
+  while (links.length) {
+    combine(result, [links.pop()]);
+  }
+  return result;
+}
+function encodeGraph(obj, version = Date.now()) {
+  return encode(obj, { version, isGraph: true });
+}
+function encodeQuery(obj, version = 0) {
+  return encode(obj, { version, isGraph: false });
+}
+async function* mergeStreams(...streams) {
+  const firstValues = (await Promise.all(streams.map((stream2) => stream2.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 {
+    let merged = [];
+    for (const value of firstValues)
+      merge(merged, value);
+    yield merged;
+  }
+  yield* mergeIterators__default["default"](streams);
+}
+function makeWatcher() {
+  const listeners = new Set();
+  function write(change) {
+    for (const push of listeners)
+      push(change);
+  }
+  function watch(...args) {
+    return stream.makeStream((push, _end) => {
+      listeners.add(push);
+      if (args.length)
+        Promise.resolve(args[0]).then(push);
+      return () => listeners.delete(push);
+    });
+  }
+  return { write, watch };
+}
+function mergeObject(base, change) {
+  if (typeof change !== "object" || typeof base !== "object" || !base || !change) {
+    return change;
+  }
+  for (const prop in change) {
+    if (prop in base) {
+      const value = mergeObject(base[prop], change[prop]);
+      if (value === null) {
+        delete base[prop];
+      } else {
+        base[prop] = value;
+      }
+    } else {
+      base[prop] = change[prop];
+    }
+  }
+  return isEmpty(base) ? null : base;
+}
+function cloneObject(object) {
+  if (typeof object !== "object" || !object) {
+    return object;
+  }
+  const clone2 = {};
+  for (const prop in object) {
+    const value = cloneObject(object[prop]);
+    if (value === null)
+      continue;
+    clone2[prop] = value;
+  }
+  return isEmpty(clone2) ? null : clone2;
+}
+function wrapObject(object, path) {
+  if (!Array.isArray(path))
+    throw Error("wrapObject.path_not_array " + path);
+  for (let i = path.length - 1; i >= 0; i--) {
+    const $key = path[i];
+    if (typeof $key === "string") {
+      object = { [$key]: object };
+    } else if (Array.isArray(object)) {
+      object = [{ $key, $chi: object }];
+    } else {
+      object = [__spreadValues({ $key }, object)];
+    }
+  }
+  return object;
+}
+function unwrapObject(object, path) {
+  if (!Array.isArray(path))
+    throw Error("unwrapObject.path_not_array " + path);
+  for (let i = 0; i < path.length; i++) {
+    if (!object || typeof object !== "object")
+      return;
+    const $key = path[i];
+    if (typeof $key === "string") {
+      if (Array.isArray(object)) {
+        throw Error("unwrapObject.string_key_array:" + $key);
+      }
+      object = object[$key];
+    } else {
+      if (!Array.isArray(object)) {
+        throw Error("unwrapObject.arg_key_object:" + JSON.stringify($key));
+      }
+      const [page, filter] = splitArgs($key);
+      if (page && !page.$cursor) {
+        return object;
+      } else {
+        const target = (page == null ? void 0 : page.$cursor) ? __spreadProps(__spreadValues({}, filter), { $cursor: page.$cursor }) : filter;
+        object = object.find(({ $key: $key2 }) => isEqual__default["default"]($key2, target));
+      }
+    }
+  }
+  return object;
+}
+exports.IS_VAL = IS_VAL;
+exports.add = add;
+exports.cloneObject = cloneObject;
+exports.decodeArgs = decode$2;
+exports.decodeGraph = decodeGraph;
+exports.decodePath = decode$1;
+exports.decodeQuery = decodeQuery;
+exports.decodeUrl = decode$7;
+exports.decodeValue = decode$3;
+exports.decorate = decorate;
+exports.deserialize = deserialize;
+exports.encodeArgs = encode$2;
+exports.encodeGraph = encodeGraph;
+exports.encodePath = encode$1;
+exports.encodeQuery = encodeQuery;
+exports.encodeUrl = encode$7;
+exports.encodeValue = encode$3;
+exports.err = err;
+exports.errIf = errIf;
+exports.finalize = finalize;
+exports.find = find;
+exports.findFirst = findFirst;
+exports.findLast = findLast;
+exports.getKnown = getKnown;
+exports.getNodeValue = getNodeValue;
+exports.isBranch = isBranch;
+exports.isDef = isDef;
+exports.isEmpty = isEmpty;
+exports.isEncoded = isEncoded;
+exports.isEncodedKey = isEncodedKey;
+exports.isLink = isLink;
+exports.isNewer = isNewer;
+exports.isOlder = isOlder;
+exports.isPlainObject = isPlainObject;
+exports.isPrefix = isPrefix;
+exports.isRange = isRange;
+exports.keyAfter = keyAfter;
+exports.keyBefore = keyBefore;
+exports.keyStep = keyStep;
+exports.makeId = id;
+exports.makeWatcher = makeWatcher;
+exports.merge = merge;
+exports.mergeObject = mergeObject;
+exports.mergeStreams = mergeStreams;
+exports.remove = remove;
+exports.serialize = serialize;
+exports.setVersion = setVersion;
+exports.sieve = sieve;
+exports.slice = slice;
+exports.splitArgs = splitArgs;
+exports.splitRef = splitRef;
+exports.unwrap = unwrap;
+exports.unwrapObject = unwrapObject;
+exports.wrap = wrap;
+exports.wrapObject = wrapObject;
+exports.wrapValue = wrapValue;