@graffy/common 0.15.25 → 0.16.0-alpha.10

package/index.cjs

@@ -1,17 +1,11 @@
 "use strict";
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const isEqual = require("lodash/isEqual.js");
 const mergeIterators = require("merge-async-iterators");
 const stream = require("@graffy/stream");
-const isEqual = require("lodash/isEqual.js");
 const _interopDefaultLegacy = (e) => e && typeof e === "object" && "default" in e ? e : { default: e };
-const mergeIterators__default = /* @__PURE__ */ _interopDefaultLegacy(mergeIterators);
 const isEqual__default = /* @__PURE__ */ _interopDefaultLegacy(isEqual);
-function encode$7(query) {
-  return encodeURIComponent(JSON.stringify(query));
-}
-function decode$7(fields) {
-  return JSON.parse(decodeURIComponent(fields));
-}
+const mergeIterators__default = /* @__PURE__ */ _interopDefaultLegacy(mergeIterators);
 const textEncoder = new TextEncoder();
 const textDecoder = new TextDecoder("utf-8");
 function encode$6(string) {
@@ -33,7 +27,9 @@ function encode$5(number) {
   return new Uint8Array(buffer);
 }
 function decode$5(u8Arr) {
-  const { buffer, byteOffset, byteLength } = u8Arr;
+  const copy = new Uint8Array(8);
+  copy.set(u8Arr, 0);
+  const { buffer, byteOffset, byteLength } = copy;
   const view = new DataView(buffer, byteOffset, byteLength);
   const high = view.getUint8(0);
   if (high & 128) {
@@ -44,41 +40,93 @@ function decode$5(u8Arr) {
   }
   return view.getFloat64(0);
 }
-const alpha = "-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz";
-function getByte(view, offset) {
-  return offset < view.byteLength ? view.getUint8(offset) : 0;
+const MIN_KEY = new Uint8Array();
+const MAX_KEY = new Uint8Array([255]);
+function isMinKey(key) {
+  return key.length === 0;
 }
-function getChar(string, offset) {
-  return offset < string.length ? alpha.indexOf(string[offset]) : 0;
+function isMaxKey(key) {
+  return key.length === 1 && key[0] === 255;
 }
-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;
+function err(message, { cause = null, ...args } = {}) {
+  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) && !ArrayBuffer.isView(arg);
+}
+function cmp(a, b) {
+  const l = a.length < b.length ? a.length : b.length;
+  for (let i = 0; i < l; i++) {
+    if (a[i] < b[i])
+      return -1;
+    if (a[i] > b[i])
+      return 1;
   }
-  return str.substr(0, Math.ceil(view.byteLength * 4 / 3));
+  if (a.length < b.length)
+    return -1;
+  if (a.length > b.length)
+    return 1;
+  return 0;
 }
-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;
+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 new Uint8Array(buffer);
+  return currentFirst;
 }
+const stringifyDescriptor = {
+  value: function() {
+    var _a;
+    if ((this == null ? void 0 : this.length) === 0)
+      return "\xB7";
+    let str = "";
+    let bull = false;
+    (_a = this == null ? void 0 : this.forEach) == null ? void 0 : _a.call(this, (value, i) => {
+      if (value >= 32 && value <= 126) {
+        str += String.fromCharCode(value);
+        bull = true;
+      } else {
+        str += (bull ? "\xB7" : "") + ("0" + value.toString(16)).slice(-2) + (i < this.length - 1 ? "\xB7" : "");
+        bull = false;
+      }
+    });
+    return str;
+  }
+};
+function addStringify(buffer) {
+  Object.defineProperties(buffer, {
+    toJSON: stringifyDescriptor,
+    toString: stringifyDescriptor,
+    [Symbol.for("nodejs.util.inspect.custom")]: stringifyDescriptor
+  });
+  return buffer;
+}
+addStringify(MIN_KEY);
+addStringify(MAX_KEY);
 const END = 0;
 const NULL = 1;
 const FALSE = 2;
@@ -87,12 +135,9 @@ const NUM = 4;
 const STR = 5;
 const ARR = 6;
 const OBJ = 7;
+const EOK = 127;
 function encodeArray(array) {
-  return [
-    ARR,
-    ...array.flatMap((value) => encodeParts(value)),
-    END
-  ];
+  return [ARR, ...array.flatMap((value) => encodeParts(value)), END];
 }
 function encodeObject(object) {
   const keys = Object.keys(object).sort();
@@ -124,10 +169,21 @@ function encodeParts(value) {
     return encodeObject(value);
   return [NULL];
 }
-function encode$3(value) {
+function encode$4(value) {
   const parts = encodeParts(value);
   while (parts[parts.length - 1] === END)
     parts.pop();
+  const lastPart = parts[parts.length - 1];
+  if (typeof lastPart !== "number") {
+    let end = lastPart.length - 1;
+    while (end >= 0 && !lastPart[end])
+      end--;
+    if (lastPart[end] !== 255) {
+      parts[parts.length - 1] = lastPart.slice(0, end + 1);
+    } else {
+      parts.push(EOK);
+    }
+  }
   const length = parts.reduce(
     (sum, part) => sum + (typeof part === "number" ? 1 : part.length),
     0
@@ -143,12 +199,12 @@ function encode$3(value) {
       i += part.length;
     }
   }
-  return encode$4(buffer);
+  addStringify(buffer);
+  return buffer;
 }
 const nextKey = /* @__PURE__ */ new WeakMap();
-function decode$3(key) {
+function decode$4(buffer) {
   let i = 0;
-  const buffer = decode$4(key, 0);
   const stack = [[]];
   function readString() {
     let start = i;
@@ -182,6 +238,8 @@ function decode$3(key) {
     const type = buffer[i];
     const start = ++i;
     switch (type) {
+      case EOK:
+        return stack[0][0];
       case END:
         popToken();
         break;
@@ -214,87 +272,67 @@ function decode$3(key) {
   return stack[0][0];
 }
 function keyStep(key) {
-  if (key === "")
+  if (isMinKey(key))
     return { key, step: 1 };
-  if (key === "\uFFFF")
+  if (isMaxKey(key))
     return { key, step: -1 };
   const l = key.length - 1;
-  switch (key.charCodeAt(l)) {
+  let newKey;
+  let step;
+  switch (key[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
-      };
+      newKey = key.slice(0, l);
+      step = 1;
+      break;
+    case 255:
+      newKey = key.slice(0, l);
+      newKey[l - 1]++;
+      step = -1;
+      break;
     default:
-      return { key, step: 0 };
+      newKey = key;
+      step = 0;
   }
+  return { key: addStringify(newKey), step };
 }
 function keyBefore(key) {
-  if (key === "" || key === "\uFFFF" || key === "\0" || key === "\0\uFFFF") {
+  if (isMinKey(key) || isMaxKey(key))
     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";
+  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 (key === "\uFFFF" || key === "\0" || key === "\0\uFFFF") {
+  if (isMaxKey(key))
     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, { cause, ...args } = {}) {
-  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 };
+  let newKey;
+  if (key[l] === 255) {
+    newKey = key.slice(0, l);
+    newKey[l - 1]++;
   } else {
-    return keyStep(string);
+    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 };
+  const value = decode$4(key);
+  return { key: value, step };
 }
 const pageProps = {
   $all: 1,
@@ -316,13 +354,13 @@ function splitArgs(arg) {
     isEmpty(filter) ? void 0 : filter
   ];
 }
-function encode$2(arg) {
+function encode$3(arg) {
   if (!isPlainObject(arg))
-    return { key: maybeEncode(arg) };
+    return { key: encode$4(arg) };
   const [page, filter] = splitArgs(arg);
   errIf("page_and_filter", page && filter, arg);
   if (!page)
-    return { key: maybeEncode(filter || {}) };
+    return { key: encode$4(filter || {}) };
   const { $cursor, ...range } = page;
   const { $first, $all, $last, $after, $before, $since, $until } = range;
   const hasRange = !isEmpty(range);
@@ -332,17 +370,17 @@ function encode$2(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"] : [];
+  let [key, end] = hasRange ? [MIN_KEY, MAX_KEY] : [];
   if (isDef($cursor))
-    key = maybeEncode($cursor);
+    key = encode$4($cursor);
   if (isDef($after))
-    key = keyAfter(maybeEncode($after));
+    key = keyAfter(encode$4($after));
   if (isDef($before))
-    end = keyBefore(maybeEncode($before));
+    end = keyBefore(encode$4($before));
   if (isDef($since))
-    key = maybeEncode($since);
+    key = encode$4($since);
   if (isDef($until))
-    end = maybeEncode($until);
+    end = encode$4($until);
   if (isDef($last))
     [key, end] = [end, key];
   const node = { key };
@@ -352,35 +390,32 @@ function encode$2(arg) {
     node.limit = $first || $last;
   return node;
 }
-function decode$2(node) {
-  if (typeof node === "string")
-    return node;
+function decode$3(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))
+  const kParts = decodeBound(key);
+  if (!isDef(end) || cmp(key, end) === 0)
     return kParts.key;
-  const eParts = maybeDecode(end);
-  const [lower, upper] = key < end ? [kParts, eParts] : [eParts, kParts];
+  const eParts = decodeBound(end);
+  const reverse = cmp(key, end) > 0;
+  const [lower, upper] = reverse ? [eParts, kParts] : [kParts, eParts];
   const args = {};
   if (limit) {
-    args[key < end ? "$first" : "$last"] = limit;
-  } else if (lower.key === "" && upper.key === "\uFFFF") {
+    args[reverse ? "$last" : "$first"] = limit;
+  } else if (isMinKey(key) && isMaxKey(end) || isMinKey(end) && isMaxKey(key)) {
     args.$all = true;
   }
-  if (lower.key !== "") {
+  if (lower.key && !isMinKey(lower.key)) {
     args[lower.step === 1 ? "$after" : "$since"] = lower.key;
   }
-  if (upper.key !== "\uFFFF") {
+  if (upper.key && !isMaxKey(upper.key)) {
     args[upper.step === -1 ? "$before" : "$until"] = upper.key;
   }
   return args;
 }
 const PATH_SEPARATOR = ".";
-function encode$1(path) {
+function encode$2(path) {
   if (typeof path === "string") {
     if (!path.length || path === PATH_SEPARATOR)
       return [];
@@ -390,25 +425,25 @@ function encode$1(path) {
     throw Error("encodePath.invalid:" + JSON.stringify(path));
   }
   function encodeSegment(seg) {
-    if (typeof seg === "string")
+    if (ArrayBuffer.isView(seg))
       return seg;
-    const { key, end } = encode$2(seg);
-    if (end)
-      throw "encodePath.unexpected_range_key";
-    return key;
+    const node = encode$3(seg);
+    if (node.end)
+      return node;
+    return node.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);
+  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$1(path) {
+function decode$2(path) {
   if (!Array.isArray(path)) {
     throw Error("decodePath.invalid:" + JSON.stringify(path));
   }
-  return path.map((key) => decode$2({ key }));
+  return path.map((key) => decode$3({ key }));
 }
 function splitRef($ref) {
   if (!Array.isArray($ref))
@@ -428,16 +463,17 @@ let customAlphabet = (alphabet, defaultSize = 21) => {
     return id2;
   };
 };
+const alpha = "-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz";
 const id = customAlphabet(alpha, 20);
 function findFirst(children, target, first, last) {
   return find(
     children,
     ({ key, end }) => {
-      if (key === target || end && key < target && end >= target)
+      const keyCmp = cmp(key, target);
+      const endCmp = end && cmp(end, target);
+      if (end && keyCmp < 0 && endCmp >= 0)
         return 0;
-      if (key < target)
-        return -1;
-      return 1;
+      return keyCmp;
     },
     first,
     last
@@ -445,7 +481,7 @@ function findFirst(children, target, first, last) {
 }
 function findLast(children, end, first, last) {
   const ix = findFirst(children, end, first, last);
-  return children[ix] && children[ix].key <= end ? ix + 1 : ix;
+  return children[ix] && cmp(children[ix].key, end) <= 0 ? ix + 1 : ix;
 }
 function isRange(node) {
   return node && typeof node.end !== "undefined";
@@ -459,9 +495,6 @@ function isPrefix(node) {
 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;
 }
@@ -472,12 +505,12 @@ function add(base, diff) {
   let changed = false;
   let index = 0;
   for (const node of diff) {
-    const cmp = compare(node);
+    const cmp2 = compare(node);
     const nodeIsBranch = isBranch(node);
-    index = find(base, cmp, index);
+    index = find(base, cmp2, index);
     const item = base[index];
     const itemIsBranch = isBranch(item);
-    if (!item || cmp(item)) {
+    if (!item || cmp2(item)) {
       base.splice(index, 0, clone(node));
       changed = true;
       continue;
@@ -502,7 +535,7 @@ function add(base, diff) {
 }
 function compare(node) {
   return (item) => {
-    const v = compareValue(item.key, node.key) || compareValue(item.end, node.end) || compareValue(item.limit, node.limit);
+    const v = cmp(item.key, node.key) || compareValue(!!item.end, !!node.end) || item.end && cmp(item.end, node.end) || compareValue(item.limit, node.limit);
     return v;
   };
 }
@@ -546,9 +579,9 @@ function mergeRanges$1(base, node) {
   if (node.version < base.version)
     [node, base] = [base, node];
   return [
-    base.key < node.key && { ...base, end: keyBefore(node.key) },
+    cmp(base.key, node.key) < 0 && { ...base, end: keyBefore(node.key) },
     node,
-    base.end > node.end && { ...base, key: keyAfter(node.end) }
+    cmp(base.end, node.end) > 0 && { ...base, key: keyAfter(node.end) }
   ].filter(Boolean);
 }
 function insertNode$1(current, change, start = 0) {
@@ -557,7 +590,7 @@ function insertNode$1(current, change, start = 0) {
   const key = change.key;
   const index = findFirst(current, key, start);
   const node = current[index];
-  if (node && node.key <= key) {
+  if (node && cmp(node.key, key) <= 0) {
     return isRange(node) ? insertNodeIntoRange$1(current, index, change) : updateNode$1(current, index, change);
   } else {
     current.splice(index, 0, change);
@@ -571,9 +604,9 @@ function insertNodeIntoRange$1(current, index, change) {
   if (!newChange)
     return;
   const insertions = [
-    range.key < key && { ...range, end: keyBefore(key) },
+    cmp(range.key, key) < 0 && { ...range, end: keyBefore(key) },
     newChange,
-    range.end > key && { ...range, key: keyAfter(key) }
+    cmp(range.end, key) > 0 && { ...range, key: keyAfter(key) }
   ].filter(Boolean);
   current.splice(index, 1, ...insertions);
   return index + insertions.length - 1;
@@ -597,7 +630,7 @@ function updateNode$1(current, index, change) {
 function getNewer(node, base) {
   const { version } = base;
   if (isBranch(node)) {
-    const children = [{ key: "", end: "\uFFFF", version }];
+    const children = [{ key: MIN_KEY, end: MAX_KEY, version }];
     merge(children, node.children);
     return children.length === 1 ? null : { ...node, children };
   } else {
@@ -605,8 +638,13 @@ function getNewer(node, base) {
   }
 }
 const IS_VAL = Symbol("IS_VAL");
+function makeNode(seg, props2) {
+  if (ArrayBuffer.isView(seg))
+    return { key: seg, ...props2 };
+  return { ...seg, ...props2 };
+}
 function wrapValue(value, path, version = 0) {
-  const node = { ...encode$2(path[path.length - 1]), value, version };
+  const node = makeNode(path[path.length - 1], { value, version });
   return wrap([node], path.slice(0, -1), version);
 }
 function wrap(children, path, version = 0, prefix = false) {
@@ -616,16 +654,16 @@ function wrap(children, path, version = 0, prefix = false) {
     return children;
   let i = path.length - 1;
   if (!Array.isArray(children)) {
-    children = [{ ...encode$2(path[i--]), value: children, version }];
+    children = [makeNode(path[i--], { value: children, version })];
   } else {
     if (!children.length)
       return;
-    children = [{ ...encode$2(path[i--]), version, children }];
+    children = [makeNode(path[i--], { children, version })];
   }
   if (prefix)
     children[0].prefix = true;
   while (i >= 0)
-    children = [{ ...encode$2(path[i--]), version, children }];
+    children = [makeNode(path[i--], { children, version })];
   return children;
 }
 function unwrap(tree, path) {
@@ -634,12 +672,14 @@ function unwrap(tree, path) {
   let children = tree;
   let node = { children };
   for (let i = 0; i < path.length; i++) {
-    const { key } = encode$2(path[i]);
+    const key = path[i];
+    if (!ArrayBuffer.isView(key))
+      throw Error("unwrap.ranges_unsupported");
     children = node.children;
     if (!children)
       return null;
     node = children[findFirst(children, key)];
-    if (!node || node.key > key)
+    if (!node || cmp(node.key, key) > 0)
       return void 0;
     if (isRange(node))
       return null;
@@ -666,7 +706,7 @@ function remove(children, path) {
   const key = path[0];
   const ix = findFirst(children, key);
   const node = children[ix];
-  if (!node || node.key > key || isRange(node))
+  if (!node || cmp(node.key, key) > 0 || isRange(node))
     return children;
   if (path.length === 1) {
     return children.slice(0, ix).concat(children.slice(ix + 1));
@@ -721,12 +761,12 @@ function slice(graph, query, root) {
 function sliceNode(graph, query, result) {
   const { key, version } = query;
   const { root } = result;
-  if (!graph || graph.key > key || isOlder(graph, version)) {
+  if (!graph || cmp(graph.key, key) > 0 || isOlder(graph, version)) {
     result.addUnknown(query);
   } else if (isRange(graph)) {
     if (isBranch(query)) {
       const { known } = slice(
-        [{ key: "", end: "\uFFFF", version: graph.version }],
+        [{ key: MIN_KEY, end: MAX_KEY, version: graph.version }],
         query.children
       );
       result.addKnown({ key, version: graph.version, children: known });
@@ -757,7 +797,7 @@ function sliceNode(graph, query, result) {
     result.addKnown(graph);
   } else if (isBranch(query)) {
     const { known } = slice(
-      [{ key: "", end: "\uFFFF", version: graph.version }],
+      [{ key: MIN_KEY, end: MAX_KEY, version: graph.version }],
       query.children
     );
     result.addKnown({ key, version: graph.version, children: known });
@@ -767,8 +807,8 @@ function sliceNode(graph, query, result) {
 }
 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 && graph[0].children) {
+  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 });
@@ -776,10 +816,10 @@ function sliceRange(graph, query, result) {
       result.addUnknown({ ...query[0], children: unknown });
     return;
   }
-  if (key < end) {
-    for (let i = findFirst(graph, key); key <= end && limit > 0; i++) {
+  if (cmp(key, end) < 0) {
+    for (let i = findFirst(graph, key); cmp(key, end) <= 0 && limit > 0; i++) {
       const node = graph[i];
-      if (!node || key < node.key || isOlder(node, version))
+      if (!node || cmp(key, node.key) < 0 || isOlder(node, version))
         break;
       if (isRange(node)) {
         result.addKnown(getOverlap(node, key, end));
@@ -790,9 +830,9 @@ function sliceRange(graph, query, result) {
       key = keyAfter(node.end || node.key);
     }
   } else {
-    for (let i = findLast(graph, key) - 1; key >= end && limit > 0; i--) {
+    for (let i = findLast(graph, key) - 1; cmp(key, end) >= 0 && limit > 0; i--) {
       const node = graph[i];
-      if (!node || key > (node.end || node.key) || isOlder(node, version))
+      if (!node || cmp(key, node.end || node.key) > 0 || isOlder(node, version))
         break;
       if (isRange(node)) {
         result.addKnown(getOverlap(node, end, key));
@@ -803,18 +843,18 @@ function sliceRange(graph, query, result) {
       key = keyBefore(node.key);
     }
   }
-  if (limit && (step < 0 ? key > end : key < end)) {
+  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 (node.key >= key && node.end <= end)
+  if (cmp(node.key, key) >= 0 && cmp(node.end, end) <= 0)
     return node;
   return {
     ...node,
-    key: node.key > key ? node.key : key,
-    end: node.end < end ? node.end : end
+    key: cmp(node.key, key) > 0 ? node.key : key,
+    end: cmp(node.end, end) < 0 ? node.end : end
   };
 }
 function sieve(current, changes, result = []) {
@@ -828,7 +868,7 @@ 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] && current[keyIx].key <= key && current[keyIx].end >= end)) {
+  if (keyIx === endIx && !(current[keyIx] && cmp(current[keyIx].key, end) <= 0 && cmp(current[keyIx].end || current[keyIx].key, key) >= 0)) {
     return keyIx;
   }
   const appliedChange = [];
@@ -836,7 +876,7 @@ function insertRange(current, change, result, start = 0) {
   for (let i = keyIx; i < endIx; i++) {
     const node = current[i];
     if (isRange(node) && node.version >= 0) {
-      if (node.key > currentKey) {
+      if (cmp(node.key, currentKey) > 0) {
         appliedChange.push({
           key: currentKey,
           end: keyBefore(node.key),
@@ -854,11 +894,11 @@ function insertRange(current, change, result, start = 0) {
         currentKey = keyAfter(node.key);
       }
     }
-    if (currentKey >= change.end) {
+    if (cmp(currentKey, change.end) >= 0) {
       break;
     }
   }
-  if (currentKey <= change.end) {
+  if (cmp(currentKey, change.end) <= 0) {
     appliedChange.push({
       key: currentKey,
       end: change.end,
@@ -883,16 +923,16 @@ function mergeRanges(base, node) {
   if (node.version < base.version)
     [node, base] = [base, node];
   return [
-    base.key < node.key && { ...base, end: keyBefore(node.key) },
+    cmp(base.key, node.key) < 0 && { ...base, end: keyBefore(node.key) },
     node,
-    base.end > node.end && { ...base, key: keyAfter(node.end) }
+    cmp(base.end, node.end) > 0 && { ...base, key: keyAfter(node.end) }
   ].filter(Boolean);
 }
 function insertNode(current, change, result, start = 0) {
   const key = change.key;
   const index = findFirst(current, key, start);
   const node = current[index];
-  if (node && node.key <= key) {
+  if (node && cmp(node.key, key) <= 0) {
     return isRange(node) ? insertNodeIntoRange(current, index, change, result) : updateNode(current, index, change, result);
   } else {
     return index;
@@ -907,9 +947,9 @@ function insertNodeIntoRange(current, index, change, result) {
     return;
   result.push(newChange);
   const insertions = [
-    range.key < key && { ...range, end: keyBefore(key) },
+    cmp(range.key, key) < 0 && { ...range, end: keyBefore(key) },
     newNode,
-    range.end > key && { ...range, key: keyAfter(key) }
+    cmp(range.end, key) > 0 && { ...range, key: keyAfter(key) }
   ].filter(Boolean);
   current.splice(index, 1, ...insertions);
   return index + insertions.length - 1;
@@ -953,7 +993,7 @@ function isPathEqual(first, second) {
 }
 function getNewerNode(node, base) {
   if (isBranch(node)) {
-    const emptyNode = { key: "", end: "\uFFFF", version: base.version };
+    const emptyNode = { key: MIN_KEY, end: MAX_KEY, version: base.version };
     const children = [emptyNode];
     sieve(children, node.children);
     return children.length === 1 && children[0] === emptyNode ? null : { ...node, children };
@@ -971,9 +1011,10 @@ function getNewerChange(node, base) {
     return node.version >= base.version ? node : null;
   }
 }
-function setVersion(graph, version) {
+function setVersion(graph, version, onlyIfZero = false) {
   for (const node of graph) {
-    node.version = version;
+    if (!onlyIfZero || !node.version)
+      node.version = version;
     if (node.children)
       setVersion(node.children, version);
   }
@@ -984,7 +1025,7 @@ function getKnown(graph, version = 0) {
   for (const { key, end, children } of graph) {
     const node = { key, version };
     if (end) {
-      if (end !== key)
+      if (cmp(end, key) !== 0)
         node.end = end;
       node.value = 1;
     }
@@ -997,15 +1038,17 @@ function getKnown(graph, version = 0) {
   }
   return query;
 }
-function finalize(graph, query, version = Date.now()) {
-  let result = [{ key: "", end: "\uFFFF", version: 0 }];
+function finalize(graph, query, version = Date.now(), suppressSetVersion = false) {
+  let result = [{ key: MIN_KEY, end: MAX_KEY, version: 0 }];
   merge(result, graph);
   if (query)
     result = slice(result, query).known || [];
-  result = setVersion(result, version);
+  if (!suppressSetVersion)
+    result = setVersion(result, version);
   return result;
 }
-function decode(nodes = [], { isGraph } = {}) {
+const PRE_CHI_PUT = Symbol("PREFIX_CHILDREN_$PUT");
+function decode$1(nodes = [], { isGraph } = {}) {
   function decodeChildren(nodes2) {
     let result = [];
     let allStrs = true;
@@ -1020,20 +1063,22 @@ function decode(nodes = [], { isGraph } = {}) {
       result.push(...objects);
     }
     const putRanges = [];
+    const prefixChildPuts = [];
     let lastNode = null;
     function addPutRange({ key, end }) {
       if (lastNode) {
         if (lastNode.end) {
-          if (key === keyAfter(lastNode.end)) {
+          if (cmp(key, keyAfter(lastNode.end)) === 0) {
             lastNode.end = end || key;
-            return end && end !== key;
+            return end && cmp(end, key) !== 0;
           }
         } else {
-          if (key === keyAfter(lastNode.key))
+          if (cmp(key, keyAfter(lastNode.key)) === 0) {
             key = lastNode.key;
+          }
         }
       }
-      if (end && key !== end) {
+      if (end && cmp(key, end) !== 0) {
         lastNode = { key, end };
         putRanges.push(lastNode);
         return true;
@@ -1044,9 +1089,13 @@ function decode(nodes = [], { isGraph } = {}) {
     for (const node of nodes2) {
       if (isGraph && addPutRange(node))
         continue;
-      if (isPrefix(node))
-        pushResult(...decodePrefixNode(node));
-      else if (isGraph && isRange(node))
+      if (isPrefix(node)) {
+        const decodedChildren = decodePrefixNode(node);
+        if (PRE_CHI_PUT in decodedChildren) {
+          prefixChildPuts.push(...decodedChildren[PRE_CHI_PUT]);
+        }
+        pushResult(...decodedChildren);
+      } else if (isGraph && isRange(node))
         pushResult(decodeRangeNode(node));
       else if (isBranch(node))
         pushResult(decodeBranchNode(node));
@@ -1055,7 +1104,7 @@ function decode(nodes = [], { isGraph } = {}) {
       else
         pushResult(decodeLeafNode(node));
     }
-    if (allNums || allStrs) {
+    if (allStrs || allNums && putRanges.length === 1 && cmp(putRanges[0].key, 0) === 0 && cmp(putRanges[0].end, Infinity) === 0) {
       result = result.reduce(
         (collection, item) => {
           if (Array.isArray(item)) {
@@ -1076,26 +1125,28 @@ function decode(nodes = [], { isGraph } = {}) {
       );
     }
     if (isGraph && putRanges.length) {
-      if (putRanges[0].key === "" && putRanges[0].end === "\uFFFF") {
+      if (isMinKey(putRanges[0].key) && isMaxKey(putRanges[0].end)) {
         Object.defineProperty(result, "$put", { value: true });
       } else {
         Object.defineProperty(result, "$put", {
-          value: putRanges.map((rNode) => decode$2(rNode))
+          value: putRanges.map((rNode) => decode$3(rNode)).concat(prefixChildPuts)
         });
       }
+    } else if (prefixChildPuts.length) {
+      Object.defineProperty(result, "$put", { value: prefixChildPuts });
     }
     return result;
   }
   function decodePrefixNode(node) {
-    let args = decode$2(node);
-    if (args === "")
+    let args = decode$3(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 $ref = decode$2(node.path);
       const lastKey = $ref[$ref.length - 1];
       if (typeof lastKey === "string") {
         throw Error("decode.unencoded_prefix_ref: " + node.path);
@@ -1118,34 +1169,45 @@ function decode(nodes = [], { isGraph } = {}) {
       }
       child.$key = { ...args, ...child.$key };
     }
+    if (children.$put === true) {
+      children[PRE_CHI_PUT] = [{ ...args, $all: true }];
+    } else if (Array.isArray(children.$put)) {
+      children[PRE_CHI_PUT] = children.$put.map((rarg) => ({
+        ...args,
+        ...rarg
+      }));
+    } else if (isDef(children.$put)) {
+      children[PRE_CHI_PUT] = [{ ...args, ...children.$put }];
+    }
     return children;
   }
   function decodeBranchNode(node) {
     const child = decodeChildren(node.children);
-    child.$key = decode$2(node);
+    child.$key = decode$3(node);
     return child;
   }
   function decodeLeafNode(node) {
     const child = isGraph ? { $val: node.value } : {};
-    child.$key = decode$2(node);
+    child.$key = decode$3(node);
     return child;
   }
   function decodeRangeNode(node) {
-    if (node.key === node.end)
-      return { $key: decode$2({ key: node.key }) };
+    if (cmp(node.key, node.end) === 0) {
+      return { $key: decode$3({ key: node.key }) };
+    }
   }
   function decodeLinkNode(node) {
-    const linkObject = { $key: decode$2(node) };
-    Object.defineProperty(linkObject, "$ref", { value: decode$1(node.path) });
+    const linkObject = { $key: decode$3(node) };
+    Object.defineProperty(linkObject, "$ref", { value: decode$2(node.path) });
     return linkObject;
   }
   return decodeChildren(nodes);
 }
 function decodeGraph(graph) {
-  return decode(graph, { isGraph: true });
+  return decode$1(graph, { isGraph: true });
 }
 function decodeQuery(query) {
-  return decode(query, { isGraph: false });
+  return decode$1(query, { isGraph: false });
 }
 const REF = Symbol();
 const PRE = Symbol();
@@ -1159,25 +1221,27 @@ function decorate(rootGraph, rootQuery) {
       query = [query];
     let graph;
     if (query.$ref) {
-      const { $ref, ...props } = query;
+      const { $ref, ...props2 } = query;
       const [range, filter] = splitRef($ref);
-      const path = encode$1($ref);
+      const path = encode$2($ref);
       const targetPlumGraph = unwrap(rootGraph, path);
-      if (range)
-        targetPlumGraph[PRE] = filter;
-      graph = construct(
-        targetPlumGraph,
-        range ? { $key: range, ...props } : props
-      );
-      Object.defineProperty(graph, "$ref", { value: $ref });
+      if (targetPlumGraph) {
+        if (range)
+          targetPlumGraph[PRE] = filter;
+        graph = construct(
+          targetPlumGraph,
+          range ? { $key: range, ...props2 } : props2
+        );
+        Object.defineProperty(graph, "$ref", { value: $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 { $key, $chi, ...props } = item;
-        const subQuery = $chi || (isEmpty(props) ? 1 : props);
+        const { $key, $chi, ...props2 } = item;
+        const subQuery = $chi || (isEmpty(props2) ? 1 : props2);
         if (!isPlainObject($key) || !splitArgs($key)[0]) {
           return construct(descend(plumGraph, $key), subQuery);
         }
@@ -1189,10 +1253,10 @@ function decorate(rootGraph, rootQuery) {
         pageKey = $key;
         const children = slice2(plumGraph, $key);
         return children.filter((node) => !isRange(node)).map((node) => {
-          const $key2 = decode$2(node);
+          const $key2 = decode$3(node);
           const subResult = construct(getValue(node), subQuery);
           if (typeof subResult === "object") {
-            subResult.$key = children[PRE] ? { ...children[PRE], $cursor: $key2 } : $key2;
+            subResult.$key = children[PRE] && !isMinKey(children[PRE]) ? { ...children[PRE], $cursor: $key2 } : $key2;
           }
           return subResult;
         });
@@ -1220,13 +1284,13 @@ function decorate(rootGraph, rootQuery) {
     }
     if (plumGraph[REF]) {
       Object.defineProperty(graph, "$ref", {
-        value: decode$1(plumGraph[REF])
+        value: decode$2(plumGraph[REF])
       });
     }
     return graph;
   }
   function descend(children, $key) {
-    const { key } = encode$2($key);
+    const key = ArrayBuffer.isView($key) ? $key : encode$3($key).key;
     if (!Array.isArray(children))
       return null;
     const ix = findFirst(children, key);
@@ -1235,7 +1299,7 @@ function decorate(rootGraph, rootQuery) {
       return;
     if (isRange(node) && node.end >= key)
       return null;
-    if (node.key !== key)
+    if (cmp(node.key, key) !== 0)
       return;
     const result2 = getValue(node);
     if (node.prefix)
@@ -1257,14 +1321,14 @@ function decorate(rootGraph, rootQuery) {
     const [range, filter] = splitArgs($key);
     if (isDef(filter)) {
       children = descend(children, filter);
-    } else if (children[0].key === "" && children[0].prefix) {
-      children = descend(children, "");
+    } else if (isMinKey(children[0].key) && children[0].prefix) {
+      children = descend(children, MIN_KEY);
     }
-    const { key, end, limit = Infinity } = encode$2(range);
+    const { key, end, limit = Infinity } = encode$3(range);
     const ix = findFirst(children, key);
     let i = ix;
     let result2;
-    if (key < end) {
+    if (cmp(key, end) < 0) {
       for (let n = 0; i < children.length && n < limit; i++) {
         if (!isRange(children[i]))
           n++;
@@ -1309,90 +1373,228 @@ function addPageMeta(graph, args) {
   let $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 serialize(obj) {
-  return JSON.stringify(obj).replace(/\uffff/g, "\\uffff");
+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 deserialize(str) {
-  return JSON.parse(str);
+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 links = [];
-  function pushLink($ref, $ver, props, $val, $chi) {
+  function pushLink($ref, $ver, props2, $val, $chi) {
     const [range, _] = splitRef($ref);
-    let children = !isEmpty(props) ? makeNode(
-      range ? [{ $key: range, ...props }] : props,
+    let children = !isEmpty(props2) ? makeNode2(
+      range ? [{ $key: range, ...props2 }] : props2,
       void 0,
       $ver
-    ).children : isDef($chi) ? makeNode(
+    ).children : isDef($chi) ? makeNode2(
       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]);
+      links.push(wrap(children, encode$2($ref), $ver, !!range)[0]);
     }
   }
   const combine = isGraph ? merge : add;
-  function makeNode(object, key, ver) {
+  function makeNode2(object, key, ver, parentPuts = []) {
     var _a2;
     if (!isDef(object))
       return;
     if (typeof object === "object" && object && isEmpty(object))
       return;
-    const { $key, $ver, $ref, $val, $chi, $put, ...props } = object || {};
+    const { $key, $ver, $ref, $val, $chi, $put, ...props2 } = object || {};
+    if (typeof object === "object" && object && !Array.isArray(object)) {
+      object = Object.fromEntries(
+        Object.entries({ $key, $ver, $ref, $val, $chi, $put, ...props2 }).filter(
+          ([_, val]) => isDef(val)
+        )
+      );
+    }
     if (isDef($ver))
       ver = $ver;
     if (isPlainObject($key)) {
       const [page, filter] = splitArgs($key);
-      if (isGraph && page && !isDef(page.$cursor) && ($ref || $val || $chi || $put || !isEmpty(props))) {
-        const node2 = makeNode({ ...object, $key: filter || "" }, key, ver);
+      const foundPuts = parentPuts.filter(([_, putFilter]) => isEqual__default.default(filter, putFilter)).map(([range]) => range);
+      if (isGraph && page && !isDef(page.$cursor) && ($ref || $val || $chi || $put || !isEmpty(props2))) {
+        const node2 = makeNode2(
+          { ...object, $key: filter || {}, $put: foundPuts },
+          key,
+          ver
+        );
+        if (!filter)
+          node2.key = MIN_KEY;
         node2.prefix = true;
         return node2;
       }
       if ((!isDef(key) || Number.isInteger(key)) && page && (filter || isDef(page.$cursor))) {
-        const node2 = makeNode(
+        const node2 = makeNode2(
           {
-            $key: filter || "",
+            $key: filter || {},
             $chi: [
               { ...object, $key: isDef(page.$cursor) ? page.$cursor : page }
-            ]
+            ],
+            ...isGraph ? { $put: foundPuts } : {}
           },
           key,
           ver
         );
+        if (!filter)
+          node2.key = MIN_KEY;
         node2.prefix = true;
         return node2;
       }
     }
+    let putQuery = [], prefixPuts = [];
+    if (Array.isArray(object) && !object.some((it) => isDef(it == null ? void 0 : it.$key))) {
+      putQuery = [encode$3({ $since: 0, $until: Infinity })];
+    }
+    function classifyPut(put) {
+      const [range, filter] = splitArgs(put);
+      if (filter) {
+        prefixPuts.push([range, filter]);
+      } else {
+        putQuery.push(encode$3(put));
+      }
+    }
+    if ($put === true) {
+      putQuery = null;
+    } else if (Array.isArray($put)) {
+      $put.forEach(classifyPut);
+    } else if (isDef($put)) {
+      classifyPut($put);
+    }
     if (isDef($key) && (Number.isInteger(key) || !isDef(key)))
       key = $key;
-    const node = key === ROOT_KEY || !isDef(key) ? {} : encode$2(key);
+    const node = key === ROOT_KEY || !isDef(key) ? {} : encode$3(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);
+      node.children = [makeNode2(object, void 0, ver, prefixPuts)].filter(
+        Boolean
+      );
       return node;
     } else if ($ref) {
-      pushLink($ref, node.version, props, $val, $chi);
+      pushLink($ref, node.version, props2, $val, $chi);
       if (!isGraph)
         return;
-      node.path = encode$1($ref);
+      node.path = encode$2($ref);
     } else if ($val === true) {
-      node.value = props;
+      node.value = props2;
     } 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);
+      const children = $chi.map((obj) => makeNode2(obj, void 0, ver, prefixPuts)).filter(Boolean).sort((a, b) => cmp(a.key, b.key));
       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) => {
+      const children = object.map((obj, i) => makeNode2(obj, i, ver, prefixPuts)).filter(Boolean).reduce((acc, it) => {
         combine(acc, [it]);
         return acc;
       }, []);
@@ -1400,7 +1602,7 @@ function encode(value, { version, isGraph } = {}) {
         node.children = children;
       }
     } else {
-      const children = Object.keys(props).sort().map((key2) => makeNode(object[key2], key2, ver)).filter(Boolean);
+      const children = Object.keys(props2).sort().map((key2) => makeNode2(object[key2], key2, ver)).filter(Boolean);
       if (children.length) {
         node.children = children;
       } else if (isGraph) {
@@ -1414,19 +1616,13 @@ function encode(value, { version, isGraph } = {}) {
         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 (isGraph && (putQuery === null || putQuery.length)) {
+      node.children = finalize(
+        node.children || [],
+        putQuery,
+        node.version,
+        true
+      );
     }
     if (((_a2 = node.children) == null ? void 0 : _a2.length) || isDef(node.end) || isDef(node.value) || isDef(node.path)) {
       return node;
@@ -1434,14 +1630,14 @@ function encode(value, { version, isGraph } = {}) {
   }
   if (value == null ? void 0 : value.$key)
     value = [value];
-  let result = ((_a = makeNode(value, ROOT_KEY, version)) == null ? void 0 : _a.children) || [];
+  let result = ((_a = makeNode2(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 });
+  return setVersion(encode(obj, { version, isGraph: true }), version, true);
 }
 function encodeQuery(obj, version = 0) {
   return encode(obj, { version, isGraph: false });
@@ -1552,22 +1748,23 @@ function unwrapObject(object, path) {
   return object;
 }
 exports.IS_VAL = IS_VAL;
+exports.MAX_KEY = MAX_KEY;
+exports.MIN_KEY = MIN_KEY;
 exports.add = add;
+exports.addStringify = addStringify;
 exports.cloneObject = cloneObject;
-exports.decodeArgs = decode$2;
+exports.cmp = cmp;
+exports.decodeArgs = decode$3;
 exports.decodeGraph = decodeGraph;
-exports.decodePath = decode$1;
+exports.decodePath = decode$2;
 exports.decodeQuery = decodeQuery;
-exports.decodeUrl = decode$7;
-exports.decodeValue = decode$3;
+exports.decodeValue = decode$4;
 exports.decorate = decorate;
-exports.deserialize = deserialize;
-exports.encodeArgs = encode$2;
+exports.encodeArgs = encode$3;
 exports.encodeGraph = encodeGraph;
-exports.encodePath = encode$1;
+exports.encodePath = encode$2;
 exports.encodeQuery = encodeQuery;
-exports.encodeUrl = encode$7;
-exports.encodeValue = encode$3;
+exports.encodeValue = encode$4;
 exports.err = err;
 exports.errIf = errIf;
 exports.finalize = finalize;
@@ -1579,9 +1776,9 @@ exports.getNodeValue = getNodeValue;
 exports.isBranch = isBranch;
 exports.isDef = isDef;
 exports.isEmpty = isEmpty;
-exports.isEncoded = isEncoded;
-exports.isEncodedKey = isEncodedKey;
 exports.isLink = isLink;
+exports.isMaxKey = isMaxKey;
+exports.isMinKey = isMinKey;
 exports.isNewer = isNewer;
 exports.isOlder = isOlder;
 exports.isPlainObject = isPlainObject;
@@ -1595,13 +1792,14 @@ exports.makeWatcher = makeWatcher;
 exports.merge = merge;
 exports.mergeObject = mergeObject;
 exports.mergeStreams = mergeStreams;
+exports.pack = pack;
 exports.remove = remove;
-exports.serialize = serialize;
 exports.setVersion = setVersion;
 exports.sieve = sieve;
 exports.slice = slice;
 exports.splitArgs = splitArgs;
 exports.splitRef = splitRef;
+exports.unpack = unpack;
 exports.unwrap = unwrap;
 exports.unwrapObject = unwrapObject;
 exports.wrap = wrap;