zkjson 0.6.3 → 0.7.0

package/cjs/encoder.js

@@ -0,0 +1,668 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._encode = _encode;
+exports.decode = decode;
+exports.decodePath = decodePath;
+exports.decodeQuery = decodeQuery;
+exports.decodeVal = decodeVal;
+exports.encode = encode;
+exports.encodePath = encodePath;
+exports.encodeQuery = encodeQuery;
+exports.encodeVal = encodeVal;
+exports.flattenPath = flattenPath;
+exports.fromIndex = fromIndex;
+exports.fromSignal = fromSignal;
+exports.pad = pad;
+exports.query = exports.path = void 0;
+exports.toIndex = toIndex;
+exports.toSignal = toSignal;
+exports.val = void 0;
+var _ramda = require("ramda");
+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 _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 = [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;
+}
+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), [[0, 0, 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 key = _k2.split("").map(function (c) {
+        return c.charCodeAt(0);
+      });
+      var _iterator5 = _createForOfIteratorHelper(_encode(v[_k2], [].concat(_toConsumableArray(path), [[key.length].concat(_toConsumableArray(key.length == 0 ? [1] : key))]))),
+        _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;
+}
+function encode(json) {
+  var flattened = _encode(json);
+  flattened.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 = 0; 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 flattened.reduce(function (arr, v) {
+    return arr.concat([].concat(_toConsumableArray(flattenPath(v[0])), _toConsumableArray(v[1])));
+  }, []);
+}
+function _decode(arr) {
+  var vals = [];
+  while (arr.length > 0) {
+    var plen = arr.shift();
+    var keys = [];
+    var _val3 = null;
+    while (plen > 0) {
+      var plen2 = arr.shift();
+      if (plen2 == 0) {
+        var plen3 = arr.shift();
+        if (plen3 == 1) {
+          keys.push([plen2, plen3]);
+        } else {
+          keys.push([plen2, plen3, arr.shift()]);
+        }
+      } else if (plen2 != 0) {
+        var _plen = plen2;
+        var key = [];
+        for (var i2 = 0; i2 < _plen; i2++) key.push(arr.shift());
+        keys.push([plen2].concat(key));
+      }
+      plen--;
+    }
+    var type = arr.shift();
+    _val3 = [type];
+    if (type == 2) {
+      _val3.push(arr.shift());
+      _val3.push(arr.shift());
+      _val3.push(arr.shift());
+    } else if (type == 1) {
+      _val3.push(arr.shift());
+    } else if (type == 3) {
+      var strlen = arr.shift();
+      _val3.push(strlen);
+      for (var _i4 = 0; _i4 < strlen; _i4++) _val3.push(arr.shift());
+    }
+    vals.push([keys, _val3]);
+  }
+  return vals;
+}
+function encodeVal(v) {
+  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;
+    }
+    vals = v < 0 ? [2, 0, moved, -num] : [2, 1, moved, num];
+  } else if (typeof v == "boolean") {
+    vals = [1, v ? 1 : 0];
+  } else if (v == null) {
+    vals = [0];
+  } else if (typeof v == "string") {
+    vals = [3, v.length].concat(_toConsumableArray(v.split("").map(function (c) {
+      return c.charCodeAt(0);
+    })));
+  } else {
+    vals = [4].concat(_toConsumableArray(encode(v)));
+  }
+  return vals;
+}
+function decodeVal(arr) {
+  var type = arr[0];
+  var _val = arr[1];
+  var val = null;
+  if (type == 0) {
+    val = null;
+  } else if (type == 1) {
+    val = arr[1] ? true : false;
+  } else if (type == 2) {
+    val = (arr[1] == 0 ? -1 : 1) * arr[3];
+    for (var i = 0; i < arr[2]; i++) {
+      val /= 10;
+    }
+  } else if (type == 3) {
+    val = arr.slice(2).map(function (c) {
+      return String.fromCharCode(Number(c));
+    }).join("");
+  } else if (type == 4) {
+    val = decode(arr.slice(1));
+  }
+  return val;
+}
+function decode(arr) {
+  var _decoded$, _decoded$2;
+  var decoded = _decode((0, _ramda.clone)(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 _iterator6 = _createForOfIteratorHelper(decoded),
+    _step6;
+  try {
+    for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+      var v = _step6.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 _iterator7 = _createForOfIteratorHelper(keys),
+          _step7;
+        try {
+          for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+            var _k3 = _step7.value;
+            if (typeof _k3 == "number") {
+              if (typeof keys[i + 1] == "undefined") {
+                obj[_k3] = decodeVal(v[1]);
+              } else {
+                if (typeof obj[_k3] == "undefined") {
+                  if (typeof keys[i + 1] == "string") {
+                    obj[_k3] = {};
+                  } else {
+                    obj[_k3] = [];
+                  }
+                }
+              }
+            } else {
+              if (typeof obj[_k3] == "undefined") {
+                if (typeof keys[i + 1] == "undefined") {
+                  obj[_k3] = decodeVal(v[1]);
+                } else if (typeof keys[i + 1] == "string") {
+                  obj[_k3] = {};
+                } else {
+                  obj[_k3] = [];
+                }
+              }
+            }
+            obj = obj[_k3];
+            i++;
+          }
+        } catch (err) {
+          _iterator7.e(err);
+        } finally {
+          _iterator7.f();
+        }
+      }
+    }
+  } catch (err) {
+    _iterator6.e(err);
+  } finally {
+    _iterator6.f();
+  }
+  return json;
+}
+function toIndex(rawStr) {
+  var b64url = Buffer.from(rawStr, "utf8").toString("base64url");
+  var bi = BigInt("0x" + Buffer.from(b64url, "base64url").toString("hex"));
+  return bi.toString(10);
+}
+function fromIndex(idxStr) {
+  var bi = BigInt(idxStr);
+  var hex = bi.toString(16);
+  if (hex.length % 2) hex = "0" + hex;
+  var buf = Buffer.from(hex, "hex");
+  var b64url = buf.toString("base64url");
+  return Buffer.from(b64url, "base64url").toString("utf8");
+}
+function toSignal(arr) {
+  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;
+  var _iterator8 = _createForOfIteratorHelper(_arr),
+    _step8;
+  try {
+    for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+      var _v2 = _step8.value;
+      _arr2.push(_v2);
+      if (_v2.length - 1 == 1) {
+        if (start == null) start = i;
+        one += _v2.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) {
+    _iterator8.e(err);
+  } finally {
+    _iterator8.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 _v = _arr5[_i6];
+    if (len2 + _v.length > 75) {
+      arrs2.push("1" + str2);
+      if (+_v[0] == 0) {
+        var len3 = 75 - len2;
+        if (len3 == 2 || len3 == 3) {
+          arrs2[arrs2.length - 1] += "1".concat(_v[2]);
+          var new_len = +_v[1] - 1;
+          if (new_len == 2) {
+            _v = "1".concat(_v[3], "1").concat(_v[4]);
+          } else {
+            _v = "0".concat(new_len).concat(_v.slice(3));
+          }
+        } else if (len3 > 3) {
+          var _new_len = +_v[1] - 2;
+          var old_len = 2;
+          if (len3 == 4) {
+            arrs2[arrs2.length - 1] += "1".concat(_v[2], "1").concat(_v[3]);
+          } else {
+            old_len = len3 - 2;
+            _new_len = +_v[1] - old_len;
+            arrs2[arrs2.length - 1] += "0".concat(old_len).concat(_v.slice(2, 2 + old_len));
+          }
+          if (_new_len == 1) {
+            _v = "1".concat(_v[old_len + 2]);
+          } else if (_new_len == 2) {
+            _v = "1".concat(_v[old_len + 2], "1").concat(_v[old_len + 3]);
+          } else {
+            _v = "0".concat(_new_len).concat(_v.slice(old_len + 2));
+          }
+        }
+      }
+      len2 = 0;
+      str2 = "";
+    }
+    len2 += _v.length;
+    str2 += _v;
+  }
+  if (str2 != "") arrs2.push("1" + str2);
+  return arrs2;
+}
+function fromSignal(arr) {
+  var _arr = [];
+  var prev = "";
+  var _iterator9 = _createForOfIteratorHelper(arr),
+    _step9;
+  try {
+    for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+      var s = _step9.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) {
+    _iterator9.e(err);
+  } finally {
+    _iterator9.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))];
+}