zkjson 0.6.4 → 0.7.0

package/cjs/encoder-v1_5.js

@@ -0,0 +1,1731 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._encode = _encode;
+exports.compress = compress;
+exports.decode = decode;
+exports.decodePath = decodePath;
+exports.decodeQuery = decodeQuery;
+exports.decodeVal = decodeVal;
+exports.decompress = decompress;
+exports.encode = encode;
+exports.encodePath = encodePath;
+exports.encodeQuery = encodeQuery;
+exports.encodeVal = encodeVal;
+exports.flattenPath = flattenPath;
+exports.from128 = from128;
+exports.from128s = from128s;
+exports.fromIndex = void 0;
+exports.fromSignal = fromSignal;
+exports.fromUint8 = fromUint8;
+exports.get = void 0;
+exports.pad = pad;
+exports.query = exports.path = void 0;
+exports.to128 = to128;
+exports.to128s = to128s;
+exports.toIndex = void 0;
+exports.toSignal = toSignal;
+exports.toUint8 = toUint8;
+exports.val = void 0;
+var _ramda = require("ramda");
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+var ops = {
+  $eq: 10,
+  $ne: 11,
+  $gt: 12,
+  $gte: 13,
+  $lt: 14,
+  $lte: 15,
+  $in: 16,
+  $nin: 17,
+  $contains: 18,
+  $contains_any: 19,
+  $contains_all: 20,
+  $contains_none: 21
+};
+var opMap = {};
+for (var k in ops) opMap[ops[k]] = k;
+var base64Map = {
+  A: "00",
+  B: "01",
+  C: "02",
+  D: "03",
+  E: "04",
+  F: "05",
+  G: "06",
+  H: "07",
+  I: "08",
+  J: "09",
+  K: "10",
+  L: "11",
+  M: "12",
+  N: "13",
+  O: "14",
+  P: "15",
+  Q: "16",
+  R: "17",
+  S: "18",
+  T: "19",
+  U: "20",
+  V: "21",
+  W: "22",
+  X: "23",
+  Y: "24",
+  Z: "25",
+  a: "26",
+  b: "27",
+  c: "28",
+  d: "29",
+  e: "30",
+  f: "31",
+  g: "32",
+  h: "33",
+  i: "34",
+  j: "35",
+  k: "36",
+  l: "37",
+  m: "38",
+  n: "39",
+  o: "40",
+  p: "41",
+  q: "42",
+  r: "43",
+  s: "44",
+  t: "45",
+  u: "46",
+  v: "47",
+  w: "48",
+  x: "49",
+  y: "50",
+  z: "51",
+  0: "52",
+  1: "53",
+  2: "54",
+  3: "55",
+  4: "56",
+  5: "57",
+  6: "58",
+  7: "59",
+  8: "60",
+  9: "61",
+  "-": "62",
+  _: "63"
+};
+var strMap = {};
+for (var _k in base64Map) strMap[base64Map[_k]] = _k;
+function pad(arr) {
+  var max = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  arr = arr.map(function (n) {
+    return n.toString();
+  });
+  for (var i = arr.length; i < max; i++) {
+    arr.push("0");
+  }
+  return arr;
+}
+function encodePath(path) {
+  var parts = [];
+  var str = "";
+  var num = 0;
+  var _iterator = _createForOfIteratorHelper(path),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var s = _step.value;
+      if (num == 2 && !(s == "." || s == "[")) throw Error();
+      if (s == ".") {
+        if (num == 2) {
+          num = 0;
+        } else {
+          parts.push(str);
+          str = "";
+        }
+      } else if (s == "[") {
+        if (num != 2) {
+          if (str != "" || parts.length > 0) parts.push(str);
+          str = "";
+        }
+        num = 1;
+      } else if (s == "]") {
+        if (num != 1) throw Error();
+        num = 2;
+        if (str == "" || Number.isNaN(+str)) throw Error();
+        parts.push(+str);
+        str = "";
+      } else {
+        str += s;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  if (str != "") parts.push(str);
+  if (parts.length == 0) parts.push("");
+  var encoded = [parts.length];
+  for (var _i = 0, _parts = parts; _i < _parts.length; _i++) {
+    var p = _parts[_i];
+    if (typeof p == "number") {
+      encoded = encoded.concat([0, 0, p]);
+    } else {
+      var plen = [p.length];
+      if (p.length == 0) plen.push(1);
+      encoded = encoded.concat([].concat(plen, _toConsumableArray(p.split("").map(function (c) {
+        return c.charCodeAt(0);
+      }))));
+    }
+  }
+  return encoded;
+}
+function decodePath(path) {
+  var str = "";
+  var p = [];
+  var len = path.shift();
+  while (path.length > 0) {
+    var type = path.shift();
+    var _val2 = null;
+    if (type == 0) {
+      var type2 = path.shift();
+      if (type2 == 0) {
+        _val2 = [type2, path.shift()];
+      } else {
+        _val2 = [type2];
+      }
+    } else {
+      _val2 = [];
+      for (var _i2 = 0; _i2 < type; _i2++) {
+        _val2.push(path.shift());
+      }
+    }
+    p.push([type].concat(_toConsumableArray(_val2)));
+  }
+  var i = 0;
+  for (var _i3 = 0, _p = p; _i3 < _p.length; _i3++) {
+    var s = _p[_i3];
+    if (s[0] == 0 && s[1] == 0) str += "[".concat(s[2], "]");else if (s[0] == 0 && s[1] == 1) {
+      if (str != "") str += ".";
+    } else {
+      str += "".concat(i == 0 ? "" : ".").concat(s.slice(1).map(function (c) {
+        return String.fromCharCode(Number(c));
+      }).join(""));
+    }
+    i++;
+  }
+  return str;
+}
+function flattenPath(path) {
+  var p = _toConsumableArray(to128(path.length));
+  var _iterator2 = _createForOfIteratorHelper(path),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var v = _step2.value;
+      p = p.concat(v);
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  return p;
+}
+var u8 = /*#__PURE__*/_createClass(function u8() {
+  var size = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 100;
+  _classCallCheck(this, u8);
+  this.size = size;
+  this.chunks = [new Uint8Array(this.size)];
+  this.len = 0;
+});
+function _encode(v) {
+  var path = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  var vals = [];
+  if (typeof v == "number") vals.push([path, encodeVal(v)]);else if (typeof v == "boolean") vals.push([path, encodeVal(v)]);else if (v == null) vals.push([path, encodeVal(v)]);else if (typeof v == "string") vals.push([path, encodeVal(v)]);else if (Array.isArray(v)) {
+    var i = 0;
+    var _iterator3 = _createForOfIteratorHelper(v),
+      _step3;
+    try {
+      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+        var v2 = _step3.value;
+        var _iterator4 = _createForOfIteratorHelper(_encode(v2, [].concat(_toConsumableArray(path), [i]))),
+          _step4;
+        try {
+          for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+            var v3 = _step4.value;
+            vals.push(v3);
+          }
+        } catch (err) {
+          _iterator4.e(err);
+        } finally {
+          _iterator4.f();
+        }
+        i++;
+      }
+    } catch (err) {
+      _iterator3.e(err);
+    } finally {
+      _iterator3.f();
+    }
+  } else if (_typeof(v) == "object") {
+    for (var _k2 in v) {
+      var _iterator5 = _createForOfIteratorHelper(_encode(v[_k2], [].concat(_toConsumableArray(path), [_k2]))),
+        _step5;
+      try {
+        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+          var v4 = _step5.value;
+          vals.push(v4);
+        }
+      } catch (err) {
+        _iterator5.e(err);
+      } finally {
+        _iterator5.f();
+      }
+    }
+  }
+  return vals;
+}
+var filterDic = function filterDic(keys) {
+  return keys.filter(function (entry) {
+    return entry.count > 1;
+  });
+};
+function countKeys(keys) {
+  var keys2 = [];
+  var _iterator6 = _createForOfIteratorHelper(keys),
+    _step6;
+  try {
+    for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+      var v = _step6.value;
+      var i = 0;
+      var _iterator7 = _createForOfIteratorHelper(v),
+        _step7;
+      try {
+        for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+          var v2 = _step7.value;
+          var _key = v.slice(0, i + 1);
+          var exists = false;
+          var _iterator8 = _createForOfIteratorHelper(keys2),
+            _step8;
+          try {
+            for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+              var v3 = _step8.value;
+              if ((0, _ramda.equals)(_key, v3.key)) {
+                v3.count += 1;
+                exists = true;
+              }
+            }
+          } catch (err) {
+            _iterator8.e(err);
+          } finally {
+            _iterator8.f();
+          }
+          if (!exists) keys2.push({
+            key: _key,
+            count: 1
+          });
+          i++;
+        }
+      } catch (err) {
+        _iterator7.e(err);
+      } finally {
+        _iterator7.f();
+      }
+    }
+  } catch (err) {
+    _iterator6.e(err);
+  } finally {
+    _iterator6.f();
+  }
+  return keys2;
+}
+function sortKeys(keys) {
+  return keys.sort(function (a, b) {
+    if (b.count !== a.count) return b.count - a.count;
+    for (var i = 0; i < Math.min(a.key.length, b.key.length); i++) {
+      var aVal = a.key[i];
+      var bVal = b.key[i];
+      if (typeof aVal === "number" && typeof bVal === "string") return -1;
+      if (typeof aVal === "string" && typeof bVal === "number") return 1;
+      if (aVal < bVal) return -1;
+      if (aVal > bVal) return 1;
+    }
+    return a.key.length - b.key.length;
+  });
+}
+function buildDic(data) {
+  // --- Step 1. (Optional) Save original input order if needed.
+  data.forEach(function (entry, idx) {
+    return entry._origIdx = idx;
+  });
+
+  // --- Step 2. Sort the data in "dictionary order."
+  // Primary: by key array length (shorter arrays come first).
+  // Secondary: for keys of equal length, by the total character length (ascending)
+  //   so that, for example, ["jane"] (4 chars) comes before ["alice"] (5 chars).
+  // Tertiary: if still equal, compare element-by-element using natural order.
+  data.sort(function (a, b) {
+    var keyA = a.key;
+    var keyB = b.key;
+
+    // Primary: Compare array lengths.
+    if (keyA.length !== keyB.length) return keyA.length - keyB.length;
+
+    // Secondary: Compare total character lengths (ascending).
+    var totalA = keyA.reduce(function (acc, x) {
+      return acc + x.toString().length;
+    }, 0);
+    var totalB = keyB.reduce(function (acc, x) {
+      return acc + x.toString().length;
+    }, 0);
+    if (totalA !== totalB) return totalA - totalB;
+    // Tertiary: Compare element-by-element using natural order.
+    for (var i = 0; i < keyA.length; i++) {
+      var elA = keyA[i];
+      var elB = keyB[i];
+      if (_typeof(elA) === _typeof(elB)) {
+        if (typeof elA === "number") {
+          if (elA !== elB) return elA - elB;
+        } else if (typeof elA === "string") {
+          var cmp = elA.localeCompare(elB, undefined, {
+            numeric: true
+          });
+          if (cmp !== 0) return cmp;
+        } else {
+          // Fallback: compare string representations.
+          var _cmp = elA.toString().localeCompare(elB.toString(), undefined, {
+            numeric: true
+          });
+          if (_cmp !== 0) return _cmp;
+        }
+      } else {
+        // If types differ, compare string representations.
+        var _cmp2 = elA.toString().localeCompare(elB.toString(), undefined, {
+          numeric: true
+        });
+        if (_cmp2 !== 0) return _cmp2;
+      }
+    }
+    return 0;
+  });
+
+  // --- Step 3. Build the dictionary.
+  // Each dictionary entry will be stored as an object with:
+  // - original: the original key (an array)
+  // - compressed: the computed compressed representation.
+  var dict = [];
+
+  // Helper: For a given string, look for a previously defined simple key (an array of length 1).
+  function getPointerIndex(str) {
+    for (var i = 0; i < dict.length; i++) {
+      if (dict[i].original.length === 1 && dict[i].original[0] === str) return i;
+    }
+    return -1;
+  }
+
+  // Helper: Element-by-element compression.
+  // For each element in a composite key, if it is a string that already exists as a simple key,
+  // replace one or more consecutive occurrences with a pointer.
+  // A single occurrence becomes [dictIndex]; a group becomes [dictIndex, 0].
+  function compressElementByElement(key) {
+    var rep = [];
+    var i = 0;
+    while (i < key.length) {
+      var el = key[i];
+      if (typeof el === "string") {
+        var ptrIndex = getPointerIndex(el);
+        if (ptrIndex !== -1) {
+          var j = i;
+          while (j < key.length && key[j] === el) {
+            j++;
+          }
+          var groupLen = j - i;
+          rep.push(groupLen === 1 ? [ptrIndex] : [ptrIndex, 0]);
+          i = j;
+          continue;
+        }
+      }
+      rep.push(el);
+      i++;
+    }
+    return rep;
+  }
+
+  // Helper: Compute a "cost" for a given representation.
+  // Each literal (number or string) counts as 1; a pointer array counts as the number of numbers it holds.
+  function computeCost(rep) {
+    var cost = 0;
+    var _iterator9 = _createForOfIteratorHelper(rep),
+      _step9;
+    try {
+      for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+        var token = _step9.value;
+        cost += Array.isArray(token) ? token.length : 1;
+      }
+    } catch (err) {
+      _iterator9.e(err);
+    } finally {
+      _iterator9.f();
+    }
+    return cost;
+  }
+
+  // Helper: Full segmentation compression.
+  // Try to segment the entire key as a concatenation of one or more previously defined dictionary entries.
+  // Uses dynamic programming over the key array.
+  // Returns an object { cost, seg } where seg is an array of dictionary indices.
+  function segmentKey(key) {
+    var n = key.length;
+    var dp = Array(n + 1).fill(null);
+    dp[n] = {
+      cost: 0,
+      seg: []
+    };
+    for (var i = n - 1; i >= 0; i--) {
+      var best = null;
+      // Try every dictionary entry.
+      for (var d = 0; d < dict.length; d++) {
+        var candidate = dict[d].original;
+        var m = candidate.length;
+        if (i + m <= n) {
+          var match = true;
+          for (var _k3 = 0; _k3 < m; _k3++) {
+            if (key[i + _k3] !== candidate[_k3]) {
+              match = false;
+              break;
+            }
+          }
+          if (match && dp[i + m] !== null) {
+            var candidateCost = 1 + dp[i + m].cost; // cost 1 for using this pointer.
+            if (best === null || candidateCost < best.cost) {
+              best = {
+                cost: candidateCost,
+                seg: [d].concat(dp[i + m].seg)
+              };
+            }
+          }
+        }
+      }
+      dp[i] = best;
+    }
+    return dp[0];
+  }
+
+  // Process each entry (in the sorted, deterministic order).
+  var _iterator0 = _createForOfIteratorHelper(data),
+    _step0;
+  try {
+    for (_iterator0.s(); !(_step0 = _iterator0.n()).done;) {
+      var entry = _step0.value;
+      var key = entry.key;
+      var compressed = void 0;
+      if (key.length === 1) {
+        // For simple keys, copy as-is.
+        compressed = key.slice();
+      } else {
+        // Try element-by-element compression.
+        var repA = compressElementByElement(key);
+        var bestCost = computeCost(repA);
+        var bestRep = repA;
+
+        // Also try full segmentation over the entire key.
+        var segRes = segmentKey(key);
+        if (segRes !== null) {
+          var repB = [segRes.seg]; // Represent segmentation as a pointer.
+          var costB = segRes.cost;
+          if (costB < bestCost) {
+            bestCost = costB;
+            bestRep = repB;
+          }
+        }
+
+        // Now try partial segmentation: try segmenting a prefix and then appending the literal remainder.
+        var n = key.length;
+        for (var i = 1; i < n; i++) {
+          var prefixSeg = segmentKey(key.slice(0, i));
+          if (prefixSeg !== null) {
+            var literalPart = key.slice(i);
+            var candidateCost = prefixSeg.cost + computeCost(literalPart);
+            if (candidateCost < bestCost) {
+              bestCost = candidateCost;
+              // Build candidate representation: pointer for the segmented prefix followed by literal remainder.
+              bestRep = [prefixSeg.seg].concat(literalPart);
+            }
+          }
+        }
+        compressed = bestRep;
+      }
+      dict.push({
+        original: key,
+        compressed: compressed
+      });
+    }
+
+    // --- Step 4. Return the dictionary and key map.
+    // "dictionary" is an array of compressed keys.
+    // "keyMap" is the array of original keys (in the same, deterministic order).
+  } catch (err) {
+    _iterator0.e(err);
+  } finally {
+    _iterator0.f();
+  }
+  return {
+    dictionary: dict.map(function (entry) {
+      return entry.compressed.length === 1 && !(0, _ramda.is)(Array, entry.compressed[0]) ? entry.compressed[0] : entry.compressed;
+    }),
+    keyMap: dict.map(function (entry) {
+      return entry.original;
+    })
+  };
+}
+var genDic = (0, _ramda.compose)(buildDic, filterDic, sortKeys, countKeys, listKeys);
+function listKeys(v) {
+  var key = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  var keys = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  if (Array.isArray(v)) {
+    var i = 0;
+    var _iterator1 = _createForOfIteratorHelper(v),
+      _step1;
+    try {
+      for (_iterator1.s(); !(_step1 = _iterator1.n()).done;) {
+        var v2 = _step1.value;
+        listKeys(v2, (0, _ramda.append)(i, key), keys);
+        i++;
+      }
+    } catch (err) {
+      _iterator1.e(err);
+    } finally {
+      _iterator1.f();
+    }
+  } else if (_typeof(v) === "object" && v !== null) {
+    for (var _k4 in v) listKeys(v[_k4], (0, _ramda.append)(_k4, key), keys);
+  } else {
+    keys.push(key);
+  }
+  return keys;
+}
+function isPrefix(path, prefix) {
+  if (prefix.length > path.length) return false;
+  for (var i = 0; i < prefix.length; i++) {
+    if (!(0, _ramda.equals)(path[i], prefix[i])) return false;
+  }
+  return true;
+}
+function applyDicToPath(path, sortedDic) {
+  // Base case: if the path is empty, nothing to replace.
+  if (path.length === 0) return [];
+  // Iterate over the dictionary entries in descending order.
+  var _iterator10 = _createForOfIteratorHelper(sortedDic),
+    _step10;
+  try {
+    for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
+      var _step10$value = _step10.value,
+        entry = _step10$value.entry,
+        index = _step10$value.index;
+      if (isPrefix(path, entry)) {
+        // Found a match: remove the matched prefix.
+        var remainder = path.slice(entry.length);
+        // Recursively apply dictionary replacement on the remainder.
+        var replacedRemainder = applyDicToPath(remainder, sortedDic);
+        // If the remainder is completely replaced (i.e. replacedRemainder is a single dictionary reference array),
+        // then merge the current dictionary index with that.
+        if (replacedRemainder.length === 0) {
+          // No remainder: simply return the dictionary reference.
+          return [[index]];
+        }
+        if (Array.isArray(replacedRemainder[0])) {
+          // The first component is already a dictionary reference: merge the indices.
+          return [[index].concat(_toConsumableArray(replacedRemainder[0]))];
+        } else {
+          // Otherwise, return the dictionary reference for the prefix and then the literal remainder.
+          return [[index]].concat(replacedRemainder);
+        }
+      }
+    }
+    // If no dictionary entry applies, return the original literal path.
+  } catch (err) {
+    _iterator10.e(err);
+  } finally {
+    _iterator10.f();
+  }
+  return path;
+}
+function applyDic(arr, dic) {
+  // Build sorted dictionary entries in descending order by length.
+  var sortedDic = dic.map(function (entry, index) {
+    return {
+      entry: entry,
+      index: index
+    };
+  }).sort(function (a, b) {
+    return b.entry.length - a.entry.length;
+  });
+  // For each pair, apply dictionary replacement to the path.
+  return arr.map(function (pair) {
+    var newPath = applyDicToPath(pair[0], sortedDic);
+    return [newPath, pair[1]];
+  });
+}
+function encodePaths(data) {
+  var index = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  var i = 0;
+  var _iterator11 = _createForOfIteratorHelper(data),
+    _step11;
+  try {
+    for (_iterator11.s(); !(_step11 = _iterator11.n()).done;) {
+      var v = _step11.value;
+      var _path = [];
+      var _iterator12 = _createForOfIteratorHelper(v[0]),
+        _step12;
+      try {
+        for (_iterator12.s(); !(_step12 = _iterator12.n()).done;) {
+          var v2 = _step12.value;
+          if ((0, _ramda.is)(Number, v2)) {
+            _path.push([0, 0].concat(_toConsumableArray(to128(v2))));
+          } else if ((0, _ramda.is)(String, v2)) {
+            var key = v2.split("").map(function (c) {
+              return c.charCodeAt(0);
+            });
+            var _k5 = [];
+            push(_k5, [key.length].concat(_toConsumableArray(key.length == 0 ? [1] : key)));
+            _path.push(_k5);
+          } else if ((0, _ramda.is)(Array, v2)) {
+            if (v2.length === 1) _path.push([0, 3].concat(_toConsumableArray(to128(v2[0]))));else _path.push([0, 4].concat(_toConsumableArray(to128(v2.length)), _toConsumableArray(to128s(v2))));
+          }
+        }
+      } catch (err) {
+        _iterator12.e(err);
+      } finally {
+        _iterator12.f();
+      }
+      v[0] = _path;
+      if (index) v.push(i);
+      i++;
+    }
+  } catch (err) {
+    _iterator11.e(err);
+  } finally {
+    _iterator11.f();
+  }
+  return data;
+}
+function mapDic(dic, len) {
+  var _map = [];
+  while (dic.length > 0) {
+    var dlen = shift(dic);
+    var _elms = [];
+    while (dlen > 0) {
+      var type = dic.shift();
+      var elms = [];
+      if (type == 7) {
+        var slen = shift(dic);
+        elms.push(slen);
+        for (var i = 0; i < slen; i++) elms.push(shift(dic));
+        _elms.push(elms);
+      } else if (type == 3) {
+        elms = (0, _ramda.concat)(elms, [0, 0, shift(dic)]);
+        _elms.push(elms);
+      } else if (type == 9) {
+        var _iterator13 = _createForOfIteratorHelper(_map[shift(dic)]),
+          _step13;
+        try {
+          for (_iterator13.s(); !(_step13 = _iterator13.n()).done;) {
+            var v2 = _step13.value;
+            _elms.push(v2);
+          }
+        } catch (err) {
+          _iterator13.e(err);
+        } finally {
+          _iterator13.f();
+        }
+      }
+      dlen--;
+    }
+    _map.push(_elms);
+    if (_map.length === len) break;
+  }
+  return _map;
+}
+function encodeDic(dict) {
+  var enc = [];
+  var offsets = [];
+  var i = 0;
+  var _iterator14 = _createForOfIteratorHelper(dict),
+    _step14;
+  try {
+    for (_iterator14.s(); !(_step14 = _iterator14.n()).done;) {
+      var v = _step14.value;
+      var len = 1;
+      var elms = [];
+      if (!(0, _ramda.is)(String, v)) {
+        len = 0;
+        var _iterator15 = _createForOfIteratorHelper(v),
+          _step15;
+        try {
+          for (_iterator15.s(); !(_step15 = _iterator15.n()).done;) {
+            var v2 = _step15.value;
+            if ((0, _ramda.is)(Array, v2)) {
+              len += v2.length;
+              var _iterator16 = _createForOfIteratorHelper(v2),
+                _step16;
+              try {
+                for (_iterator16.s(); !(_step16 = _iterator16.n()).done;) {
+                  var v3 = _step16.value;
+                  push(elms, [9, v3]);
+                }
+              } catch (err) {
+                _iterator16.e(err);
+              } finally {
+                _iterator16.f();
+              }
+            } else {
+              len += 1;
+              if ((0, _ramda.is)(String, v2)) {
+                elms.push(7);
+                push(elms, v2.length);
+                push(elms, v2.split("").map(function (c) {
+                  return c.charCodeAt(0);
+                }));
+              } else {
+                push(elms, [3, v2]);
+              }
+            }
+          }
+        } catch (err) {
+          _iterator15.e(err);
+        } finally {
+          _iterator15.f();
+        }
+      } else {
+        elms.push(7);
+        push(elms, v.length);
+        push(elms, v.split("").map(function (c) {
+          return c.charCodeAt(0);
+        }));
+      }
+      var _elms = [].concat(_toConsumableArray(to128(len)), elms);
+      push(offsets, _elms.length);
+      enc = (0, _ramda.concat)(enc, _elms);
+      i++;
+    }
+  } catch (err) {
+    _iterator14.e(err);
+  } finally {
+    _iterator14.f();
+  }
+  return {
+    offsets: offsets,
+    enc: enc
+  };
+}
+var addDicPos = function addDicPos(ret) {
+  var dic_pos0 = to128(ret.length + 1);
+  var dic_pos = ret.length + dic_pos0.length;
+  var dic_pos2 = to128(dic_pos);
+  if (dic_pos0.length !== dic_pos2.length) dic_pos += 1;
+  unshift(ret, dic_pos); // if length > 256 offset changes
+};
+var sortEnc = function sortEnc(enc, sort) {
+  if (!sort) return null;else {
+    var _enc = (0, _ramda.clone)(enc);
+    _enc = encodePaths(_enc, true);
+    _enc.sort(function (a, b) {
+      var isUndefined = function isUndefined(v) {
+        return typeof v == "undefined";
+      };
+      var max = Math.max(a[0].length, b[0].length);
+      if (max > 0) {
+        for (var i = 1; i < max; i++) {
+          var exA = !isUndefined(a[0][i]);
+          var exB = !isUndefined(b[0][i]);
+          if (exA && !exB) return 1;
+          if (!exA && exB) return -1;
+          var max2 = Math.max(a[0][i].length, b[0][i].length);
+          if (max2 > 0) {
+            for (var i2 = 0; i2 < max2; i2++) {
+              var vA = a[0][i][i2];
+              var vB = b[0][i][i2];
+              var _exA = !isUndefined(vA);
+              var _exB = !isUndefined(vB);
+              if (_exA && !_exB) return 1;
+              if (!_exA && _exB) return -1;
+              if (vA > vB) return 1;
+              if (vA < vB) return -1;
+            }
+          }
+        }
+      }
+      return 0;
+    });
+    return _enc;
+  }
+};
+var getDic = function getDic(json, enc, dict) {
+  var dic = null;
+  var dic_offsets = null;
+  var diclen = 0;
+  if (dict) {
+    var dictionary = [];
+    var keyMap;
+    var _genDic = genDic(json);
+    dictionary = _genDic.dictionary;
+    keyMap = _genDic.keyMap;
+    if (dictionary.length > 0) {
+      ;
+      var _encodeDic = encodeDic(dictionary);
+      dic = _encodeDic.enc;
+      dic_offsets = _encodeDic.offsets;
+    }
+    if (dic) enc = applyDic(enc, keyMap);
+    diclen = dictionary.length;
+  }
+  return {
+    dic_offsets: dic_offsets,
+    diclen: diclen,
+    dic: dic,
+    enc: enc
+  };
+};
+function encode(json) {
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+    _ref$dict = _ref.dict,
+    dict = _ref$dict === void 0 ? true : _ref$dict,
+    _ref$offset = _ref.offset,
+    offset = _ref$offset === void 0 ? true : _ref$offset,
+    _ref$sort = _ref.sort,
+    sort = _ref$sort === void 0 ? true : _ref$sort;
+  var enc = _encode(json);
+  var _enc = sortEnc(enc, sort);
+  var _getDic = getDic(json, enc, dict),
+    dic_offsets = _getDic.dic_offsets,
+    diclen = _getDic.diclen,
+    dic = _getDic.dic,
+    enc3 = _getDic.enc;
+  enc = enc3;
+  enc = encodePaths(enc);
+  enc = sort ? _enc.map(function (v) {
+    return enc[v[2]];
+  }) : enc;
+
+  // build encode
+  var ret = (0, _ramda.concat)(dic !== null && dic !== void 0 ? dic : [], enc.reduce(function (arr, v) {
+    return arr.concat([].concat(_toConsumableArray(flattenPath(v[0])), _toConsumableArray(v[1])));
+  }, []));
+  addDicPos(ret);
+  if (offset) {
+    // add dictionary offsets
+    if (diclen > 0) {
+      push(ret, diclen);
+      var _iterator17 = _createForOfIteratorHelper(dic_offsets),
+        _step17;
+      try {
+        for (_iterator17.s(); !(_step17 = _iterator17.n()).done;) {
+          var v = _step17.value;
+          push(ret, v);
+        }
+      } catch (err) {
+        _iterator17.e(err);
+      } finally {
+        _iterator17.f();
+      }
+    } else ret.push(0);
+
+    // add offset table
+    var _iterator18 = _createForOfIteratorHelper(enc),
+      _step18;
+    try {
+      for (_iterator18.s(); !(_step18 = _iterator18.n()).done;) {
+        var _v = _step18.value;
+        push(ret, (0, _ramda.flatten)(_v[0]).length + (0, _ramda.flatten)(_v[1]).length + 1);
+      }
+    } catch (err) {
+      _iterator18.e(err);
+    } finally {
+      _iterator18.f();
+    }
+  }
+  return ret;
+}
+function _decode(arr) {
+  var vals = [];
+  var dic = [];
+  var len = arr.length;
+  var _shift = shift(arr, true),
+    _shift2 = _slicedToArray(_shift, 2),
+    offset = _shift2[0],
+    offset_len = _shift2[1];
+  var isDic = arr[offset - offset_len];
+  if (isDic > 0) dic = mapDic(arr, isDic);
+  while (len - offset + 1 < arr.length) {
+    var keylen = arr.shift(); // key length
+    var keys = [];
+    var _val3 = null;
+    while (keylen > 0) {
+      var plen2 = shift(arr);
+      if (plen2 == 0) {
+        var plen3 = arr.shift(); // 02 is not used shift 3,4
+        if (plen3 == 1) {
+          // bare (01)
+          keys.push([plen2, plen3]);
+        } else if (plen3 == 0) {
+          // array (00)
+          keys.push([plen2, plen3, shift(arr)]);
+        } else if (plen3 == 3) {
+          // ref (03)
+          var _keys = dic[shift(arr)];
+          var _iterator19 = _createForOfIteratorHelper(_keys),
+            _step19;
+          try {
+            for (_iterator19.s(); !(_step19 = _iterator19.n()).done;) {
+              var _k6 = _step19.value;
+              keys.push(_k6);
+            }
+          } catch (err) {
+            _iterator19.e(err);
+          } finally {
+            _iterator19.f();
+          }
+        } else if (plen3 == 4) {
+          // multi refs (04)
+          var key = [];
+          var plen4 = shift(arr);
+          for (var i2 = 0; i2 < plen4; i2++) {
+            var _keys2 = dic[shift(arr)];
+            var _iterator20 = _createForOfIteratorHelper(_keys2),
+              _step20;
+            try {
+              for (_iterator20.s(); !(_step20 = _iterator20.n()).done;) {
+                var _k7 = _step20.value;
+                keys.push(_k7);
+              }
+            } catch (err) {
+              _iterator20.e(err);
+            } finally {
+              _iterator20.f();
+            }
+          }
+        }
+      } else if (plen2 != 0) {
+        // string
+        var _key2 = [];
+        move(arr, _key2, plen2);
+        keys.push([plen2].concat(_key2));
+      }
+      keylen--;
+    }
+    var type = arr.shift();
+    _val3 = [type];
+    if (type == 5 || type == 6) {
+      move(arr, _val3);
+      _val3.push(arr.shift());
+    } else if (type == 3 || type == 4) {
+      move(arr, _val3);
+    } else if (type == 7) {
+      move(arr, _val3);
+      var strlen = _val3[_val3.length - 1];
+      move(arr, _val3, strlen);
+    }
+    vals.push([keys, _val3]);
+  }
+  return vals;
+}
+
+// 0: null, 1: true, 2: false, 3: positive integer, 4: negative integer, 5: positive float, 6: negative float, 7: string, 8: object, 9: ref
+
+function encodeVal(v) {
+  var _vals = new u8();
+  var vals = [];
+  if (typeof v == "number" || typeof v == "bigint") {
+    var _int = Number.isInteger(v);
+    var moved = 0;
+    var num = v;
+    while (num % 1 != 0) {
+      num *= 10;
+      moved += 1;
+    }
+    var type = 3;
+    if (v >= 0) {
+      if (moved > 0) type = 5;
+    } else {
+      if (moved > 0) type = 6;else type = 4;
+    }
+    vals.push(type);
+    if (moved > 0) vals.push(moved);
+    push(vals, v < 0 ? -num : num);
+  } else if (typeof v == "boolean") vals.push(v ? 1 : 2);else if (v == null) vals = [0];else if (typeof v == "string") {
+    vals = [7];
+    push(vals, v.length);
+    var _iterator21 = _createForOfIteratorHelper(v.split("")),
+      _step21;
+    try {
+      for (_iterator21.s(); !(_step21 = _iterator21.n()).done;) {
+        var v2 = _step21.value;
+        push(vals, v2.charCodeAt(0));
+      }
+    } catch (err) {
+      _iterator21.e(err);
+    } finally {
+      _iterator21.f();
+    }
+  } else vals = [8].concat(_toConsumableArray(encode(v)));
+  return vals;
+}
+function decodeVal(arr) {
+  if (!(0, _ramda.is)(Array, arr)) return;
+  var type = arr[0];
+  var _val = arr[1];
+  var val = null;
+  if (type == 0) {
+    val = null;
+  } else if (type == 1) {
+    val = true;
+  } else if (type == 2) {
+    val = false;
+  } else if (type == 3) {
+    val = arr[1];
+  } else if (type == 4) {
+    val = arr[1] * -1;
+  } else if (type == 5) {
+    val = arr[2];
+    for (var i = 0; i < arr[1]; i++) {
+      val /= 10;
+    }
+  } else if (type == 6) {
+    val = arr[2] * -1;
+    for (var _i4 = 0; _i4 < arr[1]; _i4++) {
+      val /= 10;
+    }
+  } else if (type == 7) {
+    var _arr = arr.slice(2);
+    val = _arr.map(function (c) {
+      return String.fromCharCode(Number(c));
+    }).join("");
+  } else if (type == 8) {
+    val = decode(arr.slice(1));
+  }
+  return val;
+}
+function decode(_arr) {
+  var _decoded$, _decoded$2;
+  var arr = Array.from(_arr);
+  var decoded = _decode(arr);
+  var json = ((_decoded$ = decoded[0]) === null || _decoded$ === void 0 || (_decoded$ = _decoded$[0]) === null || _decoded$ === void 0 || (_decoded$ = _decoded$[0]) === null || _decoded$ === void 0 ? void 0 : _decoded$[0]) == 0 && ((_decoded$2 = decoded[0]) === null || _decoded$2 === void 0 || (_decoded$2 = _decoded$2[0]) === null || _decoded$2 === void 0 || (_decoded$2 = _decoded$2[0]) === null || _decoded$2 === void 0 ? void 0 : _decoded$2[1]) == 0 ? [] : {};
+  var _iterator22 = _createForOfIteratorHelper(decoded),
+    _step22;
+  try {
+    for (_iterator22.s(); !(_step22 = _iterator22.n()).done;) {
+      var v = _step22.value;
+      var keys = v[0].map(function (v2) {
+        if (v2[0] == 0) {
+          if (v2[1] == 1) return "";
+          return v2[2];
+        } else {
+          return v2.slice(1).map(function (c) {
+            return String.fromCharCode(Number(c));
+          }).join("");
+        }
+      });
+      if (keys.length == 0) json = decodeVal(v[1]);else {
+        var obj = json;
+        var i = 0;
+        var _iterator23 = _createForOfIteratorHelper(keys),
+          _step23;
+        try {
+          for (_iterator23.s(); !(_step23 = _iterator23.n()).done;) {
+            var _k8 = _step23.value;
+            if (typeof _k8 == "number") {
+              if (typeof keys[i + 1] == "undefined") {
+                obj[_k8] = decodeVal(v[1]);
+              } else {
+                if (typeof obj[_k8] == "undefined") {
+                  if (typeof keys[i + 1] == "string") {
+                    obj[_k8] = {};
+                  } else {
+                    obj[_k8] = [];
+                  }
+                }
+              }
+            } else {
+              if (typeof obj[_k8] == "undefined") {
+                if (typeof keys[i + 1] == "undefined") {
+                  obj[_k8] = decodeVal(v[1]);
+                } else if (typeof keys[i + 1] == "string") {
+                  obj[_k8] = {};
+                } else {
+                  obj[_k8] = [];
+                }
+              }
+            }
+            obj = obj[_k8];
+            i++;
+          }
+        } catch (err) {
+          _iterator23.e(err);
+        } finally {
+          _iterator23.f();
+        }
+      }
+    }
+  } catch (err) {
+    _iterator22.e(err);
+  } finally {
+    _iterator22.f();
+  }
+  return json;
+}
+var toIndex = exports.toIndex = function toIndex(str) {
+  return "1" + str.split("").map(function (s) {
+    return base64Map[s];
+  }).join("");
+};
+var fromIndex = exports.fromIndex = function fromIndex(id) {
+  var _id = id.toString().split("");
+  _id.shift();
+  return (0, _ramda.splitEvery)(2, _id).map(function (s) {
+    return strMap[s.join("")];
+  }).join("");
+};
+function toSignal(arr) {
+  var uint_len = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 75;
+  var _arr = (0, _ramda.flatten)(arr.map(function (n) {
+    var str = (0, _ramda.splitEvery)(8, n.toString().split(""));
+    var i = 0;
+    str = str.map(function (s) {
+      var len = i == str.length - 1 ? s.length : 9;
+      i++;
+      return len.toString() + s.join("");
+    });
+    return str;
+  }));
+  var _arr2 = [];
+  var one = 0;
+  var i = 0;
+  var start = null;
+  if (!uint_len) uint_len = _arr * 100;
+  var _iterator24 = _createForOfIteratorHelper(_arr),
+    _step24;
+  try {
+    for (_iterator24.s(); !(_step24 = _iterator24.n()).done;) {
+      var _v3 = _step24.value;
+      _arr2.push(_v3);
+      if (_v3.length - 1 == 1) {
+        if (start == null) start = i;
+        one += _v3.length - 1;
+        if (one == 9) {
+          _arr2[start] = "0".concat(one).concat(_arr2[start][1]);
+          for (var _i7 = start + 1; _i7 <= i; _i7++) _arr2[_i7] = "".concat(_arr2[_i7][1]);
+          one = 0;
+          start = null;
+        }
+      } else {
+        if (one > 2) {
+          _arr2[start] = "0".concat(one).concat(_arr2[start][1]);
+          for (var _i8 = start + 1; _i8 < i; _i8++) _arr2[_i8] = "".concat(_arr2[_i8][1]);
+        }
+        one = 0;
+        start = null;
+      }
+      i++;
+    }
+  } catch (err) {
+    _iterator24.e(err);
+  } finally {
+    _iterator24.f();
+  }
+  if (one > 2) {
+    _arr2[start] = "0".concat(one).concat(_arr2[start][1]);
+    for (var i2 = start + 1; i2 <= i - 1; i2++) _arr2[i2] = "".concat(_arr2[i2][1]);
+  }
+  var _arr3 = [];
+  var chain = null;
+  var cur = 0;
+  var num = "";
+  for (var _i5 = 0, _arr4 = _arr2; _i5 < _arr4.length; _i5++) {
+    var v = _arr4[_i5];
+    if (chain == null && +v[0] == 0) {
+      chain = +v[1];
+      cur = 1;
+      num = v;
+    } else if (chain != null) {
+      num += v;
+      cur++;
+      if (chain == cur) {
+        _arr3.push(num);
+        chain = null;
+        num = "";
+        cur = 0;
+      }
+    } else {
+      _arr3.push(v);
+    }
+  }
+  if (chain != null) _arr3.push(num);
+  var arrs2 = [];
+  var len2 = 0;
+  var str2 = "";
+  for (var _i6 = 0, _arr5 = _arr3; _i6 < _arr5.length; _i6++) {
+    var _v2 = _arr5[_i6];
+    if (len2 + _v2.length > uint_len) {
+      arrs2.push("1" + str2);
+      if (+_v2[0] == 0) {
+        var len3 = uint_len - len2;
+        if (len3 == 2 || len3 == 3) {
+          arrs2[arrs2.length - 1] += "1".concat(_v2[2]);
+          var new_len = +_v2[1] - 1;
+          if (new_len == 2) {
+            _v2 = "1".concat(_v2[3], "1").concat(_v2[4]);
+          } else {
+            _v2 = "0".concat(new_len).concat(_v2.slice(3));
+          }
+        } else if (len3 > 3) {
+          var _new_len = +_v2[1] - 2;
+          var old_len = 2;
+          if (len3 == 4) {
+            arrs2[arrs2.length - 1] += "1".concat(_v2[2], "1").concat(_v2[3]);
+          } else {
+            old_len = len3 - 2;
+            _new_len = +_v2[1] - old_len;
+            arrs2[arrs2.length - 1] += "0".concat(old_len).concat(_v2.slice(2, 2 + old_len));
+          }
+          if (_new_len == 1) {
+            _v2 = "1".concat(_v2[old_len + 2]);
+          } else if (_new_len == 2) {
+            _v2 = "1".concat(_v2[old_len + 2], "1").concat(_v2[old_len + 3]);
+          } else {
+            _v2 = "0".concat(_new_len).concat(_v2.slice(old_len + 2));
+          }
+        }
+      }
+      len2 = 0;
+      str2 = "";
+    }
+    len2 += _v2.length;
+    str2 += _v2;
+  }
+  if (str2 != "") arrs2.push("1" + str2);
+  return arrs2;
+}
+function fromSignal(arr) {
+  var _arr = [];
+  var prev = "";
+  var _iterator25 = _createForOfIteratorHelper(arr),
+    _step25;
+  try {
+    for (_iterator25.s(); !(_step25 = _iterator25.n()).done;) {
+      var s = _step25.value;
+      s = s.slice(1);
+      var str = s.split("");
+      while (str.length > 0) {
+        var len = +str.shift();
+        if (len == 0) {
+          var len2 = +str.shift();
+          for (var i2 = 0; i2 < len2; i2++) {
+            _arr.push(+str[i2]);
+          }
+          str = str.slice(len2);
+        } else if (len == 9) {
+          prev += str.slice(0, 8).join("");
+          str = str.slice(8);
+        } else {
+          var nums = str.slice(0, len).join("");
+          str = str.slice(len);
+          _arr.push(+(prev + nums));
+          prev = "";
+        }
+      }
+    }
+  } catch (err) {
+    _iterator25.e(err);
+  } finally {
+    _iterator25.f();
+  }
+  return _arr;
+}
+var path = exports.path = function path(p) {
+  return toSignal(encodePath(p));
+};
+var val = exports.val = function val(v) {
+  return toSignal(encodeVal(v));
+};
+var query = exports.query = function query(v) {
+  return toSignal(encodeQuery(v));
+};
+function encodeQuery(v) {
+  if (!Array.isArray(v)) throw Error("query must be an array");
+  var op = v[0];
+  if ((0, _ramda.isNil)(ops[op])) throw Error("query not supported: ".concat(op));
+  return [ops[op]].concat(_toConsumableArray(encodeVal(v[1])));
+}
+function decodeQuery(v) {
+  var op = opMap[v[0]];
+  if ((0, _ramda.isNil)(op)) throw Error("op doens't exist");
+  return [op, decodeVal(v.slice(1))];
+}
+function toUint8(sig) {
+  var num = BigInt(sig);
+  var byteArray = [];
+  while (num > 0) {
+    byteArray.push(Number(num % 256n));
+    num /= 256n;
+  }
+  return new Uint8Array(byteArray.reverse());
+}
+function compress(arr) {
+  var sig = toSignal(arr, false);
+  return toUint8(sig);
+}
+function decompress(arr) {
+  var str = fromUint8(arr);
+  return fromSignal([str]);
+}
+function fromUint8(arr) {
+  var num = 0n;
+  var _iterator26 = _createForOfIteratorHelper(arr),
+    _step26;
+  try {
+    for (_iterator26.s(); !(_step26 = _iterator26.n()).done;) {
+      var _byte = _step26.value;
+      num = num * 256n + BigInt(_byte);
+    }
+  } catch (err) {
+    _iterator26.e(err);
+  } finally {
+    _iterator26.f();
+  }
+  return num.toString();
+}
+var get = exports.get = function get(data, path) {
+  return decodeVal(getraw(data, encodePath(path)));
+};
+function getraw(_data, path) {
+  var data = Array.from(_data);
+  var dic = [];
+  var _view = view(data),
+    _view2 = _slicedToArray(_view, 2),
+    offset = _view2[0],
+    offset_len = _view2[1]; // only view
+  var isDic = data[offset];
+  if (isDic > 0) dic = mapDic(data.slice(offset_len), isDic); // handle this
+  var cur = offset + 1;
+  var offsets = {
+    dic: [],
+    data: []
+  };
+  var p = offset_len;
+  if (isDic > 0) {
+    offsets.dic[0] = offset_len;
+    for (var i2 = 0; i2 < isDic; i2++) {
+      var _view3 = view(data, cur),
+        _view4 = _slicedToArray(_view3, 2),
+        o = _view4[0],
+        len = _view4[1];
+      p += o;
+      cur += len;
+      offsets.dic.push(p);
+    }
+  } else offsets.data[0] = 0;
+  while (cur < data.length) {
+    offsets.data.push(p);
+    var _view5 = view(data, cur),
+      _view6 = _slicedToArray(_view5, 2),
+      _o = _view6[0],
+      _len2 = _view6[1];
+    p += _o;
+    cur += _len2;
+  }
+  for (var i3 = 0; i3 < offsets.data.length; i3++) {
+    var c = offsets.data[i3]; // cursor
+    var pc = 0; // keep track of path cursor
+    var _view7 = view(data, c),
+      _view8 = _slicedToArray(_view7, 2),
+      klen = _view8[0],
+      _len3 = _view8[1];
+    c += _len3;
+    pc++;
+    var ok = true;
+    var _loop = function _loop() {
+        var _view9 = view(data, c),
+          _view0 = _slicedToArray(_view9, 2),
+          type = _view0[0],
+          len = _view0[1];
+        c += len;
+        if (type === 0) {
+          var _view1 = view(data, c),
+            _view10 = _slicedToArray(_view1, 2),
+            subtype = _view10[0],
+            sublen = _view10[1];
+          c += sublen;
+          if (subtype === 3) {
+            // no check
+            var _view11 = view(data, c),
+              _view12 = _slicedToArray(_view11, 2),
+              ref = _view12[0],
+              reflen = _view12[1];
+            c += reflen;
+            var d = offsets.dic[ref];
+            var _getDic3 = function _getDic2(x) {
+              var _view13 = view(data, x),
+                _view14 = _slicedToArray(_view13, 2),
+                _len = _view14[0],
+                len = _view14[1];
+              x += len;
+              var res = [];
+              for (var i = 0; i < _len; i++) {
+                var _view15 = view(data, x),
+                  _view16 = _slicedToArray(_view15, 2),
+                  dtype = _view16[0],
+                  _len4 = _view16[1];
+                x += _len4;
+                if (dtype === 9) {
+                  res = (0, _ramda.concat)(res, _getDic3(offsets.dic[data[x++]]));
+                } else if (dtype === 7) {
+                  var _view17 = view(data, x),
+                    _view18 = _slicedToArray(_view17, 2),
+                    slen = _view18[0],
+                    _len5 = _view18[1];
+                  x += _len5;
+                  res.push(slen);
+                  for (var _i0 = 0; _i0 < slen; _i0++) {
+                    var _view19 = view(data, x),
+                      _view20 = _slicedToArray(_view19, 2),
+                      y = _view20[0],
+                      _len6 = _view20[1];
+                    x += _len6;
+                    res.push(y);
+                  }
+                } else {
+                  res.push(0);
+                  res.push(0);
+                  var _view21 = view(data, x),
+                    _view22 = _slicedToArray(_view21, 2),
+                    _y = _view22[0],
+                    _len7 = _view22[1];
+                  x += _len7;
+                  res.push(_y);
+                }
+              }
+              return res;
+            };
+            var _dic = _getDic3(d);
+            var _iterator27 = _createForOfIteratorHelper(_dic),
+              _step27;
+            try {
+              for (_iterator27.s(); !(_step27 = _iterator27.n()).done;) {
+                var v3 = _step27.value;
+                if (path[pc++] !== v3) {
+                  ok = false;
+                  break;
+                }
+              }
+            } catch (err) {
+              _iterator27.e(err);
+            } finally {
+              _iterator27.f();
+            }
+          } else if (subtype === 0) {
+            // check
+            if (path[pc++] !== type) {
+              ok = false;
+              return 0; // break
+            }
+            if (path[pc++] !== subtype) {
+              ok = false;
+              return 0; // break
+            }
+            var _view23 = view(data, c),
+              _view24 = _slicedToArray(_view23, 2),
+              y = _view24[0],
+              _len8 = _view24[1];
+            c += _len8;
+            if (path[pc++] !== y) {
+              ok = false;
+              return 0; // break
+            }
+          }
+        } else {
+          // this is string
+          var slen = type;
+          if (path[pc++] !== slen) {
+            ok = false;
+            return 0; // break
+          }
+          for (var _i1 = 0; _i1 < slen; _i1++) {
+            var _view25 = view(data, c),
+              _view26 = _slicedToArray(_view25, 2),
+              _y2 = _view26[0],
+              _len9 = _view26[1];
+            c += _len9;
+            if (path[pc++] !== _y2) {
+              ok = false;
+              break;
+            }
+          }
+        }
+      },
+      _ret;
+    for (var _i9 = 0; _i9 < klen; _i9++) {
+      _ret = _loop();
+      if (_ret === 0) break;
+    }
+    if (!ok) continue;
+    if (pc === path.length) {
+      return from128s(data.slice(c, offsets.data[i3 + 1])).arr;
+      break;
+    }
+  }
+  return;
+}
+function to128(number) {
+  var encoded = [];
+  while (number >= 128) {
+    encoded.push(number & 0x7f | 0x80);
+    number >>= 7;
+  }
+  encoded.push(number);
+  return encoded;
+}
+function from128(bytes) {
+  var value = 0;
+  var shift = 0;
+  var _iterator28 = _createForOfIteratorHelper(bytes),
+    _step28;
+  try {
+    for (_iterator28.s(); !(_step28 = _iterator28.n()).done;) {
+      var _byte2 = _step28.value;
+      value |= (_byte2 & 0x7f) << shift;
+      if ((_byte2 & 0x80) === 0) break;
+      shift += 7;
+    }
+  } catch (err) {
+    _iterator28.e(err);
+  } finally {
+    _iterator28.f();
+  }
+  return value;
+}
+function from128s(bytes, limit) {
+  var result = [];
+  var i = 0;
+  while (i < bytes.length && (limit === undefined || result.length < limit)) {
+    var chunk = [];
+    // Collect bytes for one LH128-encoded number.
+    while (i < bytes.length) {
+      chunk.push(bytes[i]);
+      if ((bytes[i] & 0x80) === 0) {
+        i++; // move past the terminating byte
+        break;
+      }
+      i++;
+    }
+    result.push(from128(chunk));
+  }
+  return {
+    arr: result,
+    len: i
+  };
+}
+function to128s(numbers) {
+  var result = [];
+  var _iterator29 = _createForOfIteratorHelper(numbers),
+    _step29;
+  try {
+    for (_iterator29.s(); !(_step29 = _iterator29.n()).done;) {
+      var num = _step29.value;
+      result.push.apply(result, _toConsumableArray(to128(num)));
+    }
+  } catch (err) {
+    _iterator29.e(err);
+  } finally {
+    _iterator29.f();
+  }
+  return result;
+}
+var shift = function shift(arr) {
+  var len = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  var res = from128s(arr, 1);
+  arr.splice(0, res.len);
+  return len ? [res.arr[0], res.len] : res.arr[0];
+};
+var view = function view(arr) {
+  var start = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  var res = from128s(arr.slice(start), 1);
+  return [res.arr[0], res.len];
+};
+var move = function move(arr) {
+  var val = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  var limit = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
+  var res = from128s(arr, limit);
+  var _iterator30 = _createForOfIteratorHelper(res.arr),
+    _step30;
+  try {
+    for (_iterator30.s(); !(_step30 = _iterator30.n()).done;) {
+      var v = _step30.value;
+      val.push(v);
+    }
+  } catch (err) {
+    _iterator30.e(err);
+  } finally {
+    _iterator30.f();
+  }
+  arr.splice(0, res.len);
+};
+var push = function push(vals, _num) {
+  if ((0, _ramda.is)(Array, _num)) {
+    var _iterator31 = _createForOfIteratorHelper(_num),
+      _step31;
+    try {
+      for (_iterator31.s(); !(_step31 = _iterator31.n()).done;) {
+        var v = _step31.value;
+        vals.splice.apply(vals, [vals.length, 0].concat(_toConsumableArray(to128(v))));
+      }
+    } catch (err) {
+      _iterator31.e(err);
+    } finally {
+      _iterator31.f();
+    }
+  } else {
+    vals.splice.apply(vals, [vals.length, 0].concat(_toConsumableArray(to128(_num))));
+  }
+};
+var unshift = function unshift(vals, _num) {
+  var addedCount = 0;
+  if ((0, _ramda.is)(Array, _num)) {
+    var encodedBytes = [];
+    var _iterator32 = _createForOfIteratorHelper(_num),
+      _step32;
+    try {
+      for (_iterator32.s(); !(_step32 = _iterator32.n()).done;) {
+        var v = _step32.value;
+        encodedBytes = encodedBytes.concat(to128(v));
+      }
+    } catch (err) {
+      _iterator32.e(err);
+    } finally {
+      _iterator32.f();
+    }
+    addedCount = encodedBytes.length;
+    vals.splice.apply(vals, [0, 0].concat(_toConsumableArray(encodedBytes)));
+  } else {
+    var encoded = to128(_num);
+    addedCount = encoded.length;
+    vals.splice.apply(vals, [0, 0].concat(_toConsumableArray(encoded)));
+  }
+  return addedCount;
+};