zkjson 0.1.17 → 0.1.19

package/collection.js

@@ -1,5 +1,5 @@
 const newMemEmptyTrie = require("./circomlibjs").newMemEmptyTrie
-const { pad, str2val, val2str, id2str, encode, str2id } = require("./encoder")
+const { pad, toSignal, id2str, encode, toIndex } = require("./encoder")
 const Doc = require("./doc")
 
 class Collection {
@@ -28,7 +28,7 @@ class Collection {
       val: doc_inputs.val,
       root: this.tree.F.toObject(this.tree.root).toString(),
       siblings,
-      key: str2id(id),
+      key: toIndex(id),
     }
   }
   async init() {
@@ -36,24 +36,24 @@ class Collection {
   }
   async insert(_key, _val) {
     const doc = encode(_val)
-    const id = str2id(_key)
-    const val = pad(val2str(doc), this.size_json)
+    const id = toIndex(_key)
+    const val = pad(toSignal(doc), this.size_json)
     return await this.tree.insert(id, val)
   }
   async update(_key, _val) {
     const doc = encode(_val)
-    const id = str2id(_key)
-    const val = pad(val2str(doc), this.size_json)
+    const id = toIndex(_key)
+    const val = pad(toSignal(doc), this.size_json)
     return await this.tree.update(id, val)
   }
 
   async delete(_key) {
-    const id = str2id(_key)
+    const id = toIndex(_key)
     return await this.tree.delete(id)
   }
 
   async get(_key) {
-    const id = str2id(_key)
+    const id = toIndex(_key)
     return await this.tree.find(id)
   }
 }

package/encoder.js

@@ -395,7 +395,7 @@ function decode(arr) {
   return json
 }
 
-const str2id = str => {
+const toIndex = str => {
   return (
     "1" +
     str
@@ -405,7 +405,7 @@ const str2id = str => {
   )
 }
 
-const id2str = id => {
+const fromIndex = id => {
   let _id = id.toString().split("")
   _id.shift()
   return splitEvery(2, _id)
@@ -415,7 +415,7 @@ const id2str = id => {
     .join("")
 }
 
-function val2str(arr) {
+function toSignal(arr) {
   const _arr = flatten(
     arr.map(n => {
       let str = splitEvery(8, n.toString().split(""))
@@ -428,30 +428,118 @@ function val2str(arr) {
       return str
     })
   )
-  let arrs = []
-  let len = 0
-  let str = ""
+  let _arr2 = []
+  let one = 0
+  let i = 0
+  let start = null
   for (let v of _arr) {
-    if (len + v.length > 76) {
-      len = 0
-      arrs.push(str)
-      str = ""
+    _arr2.push(v)
+    if (v.length - 1 === 1) {
+      if (start === null) start = i
+      one += v.length - 1
+      if (one === 9) {
+        _arr2[start] = `0${one}${_arr2[start][1]}`
+        for (let i2 = start + 1; i2 <= i; i2++) _arr2[i2] = `${_arr2[i2][1]}`
+        one = 0
+        start = null
+      }
+    } else {
+      if (one > 2) {
+        _arr2[start] = `0${one}${_arr2[start][1]}`
+        for (let i2 = start + 1; i2 < i; i2++) _arr2[i2] = `${_arr2[i2][1]}`
+      }
+      one = 0
+      start = null
+    }
+    i++
+  }
+  if (one > 2) {
+    _arr2[start] = `0${one}${_arr2[start][1]}`
+    for (let i2 = start + 1; i2 <= i - 1; i2++) _arr2[i2] = `${_arr2[i2][1]}`
+  }
+  let _arr3 = []
+  let chain = null
+  let cur = 0
+  let num = ""
+  for (let v of _arr2) {
+    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)
     }
-    len += v.length
-    str += v
   }
-  if (str !== "") arrs.push(str)
-  return arrs
+  if (chain !== null) _arr3.push(num)
+  let arrs2 = []
+  let len2 = 0
+  let str2 = ""
+  for (let v of _arr3) {
+    if (len2 + v.length > 75) {
+      arrs2.push("1" + str2)
+      if (+v[0] === 0) {
+        let len3 = 75 - len2
+        if (len3 == 2 || len3 == 3) {
+          arrs2[arrs2.length - 1] += `1${v[2]}`
+          let new_len = +v[1] - 1
+          if (new_len === 2) {
+            v = `1${v[3]}1${v[4]}`
+          } else {
+            v = `0${new_len}${v.slice(3)}`
+          }
+        } else if (len3 > 3) {
+          let new_len = +v[1] - 2
+          let old_len = 2
+          if (len3 === 4) {
+            arrs2[arrs2.length - 1] += `1${v[2]}1${v[3]}`
+          } else {
+            old_len = len3 - 2
+            new_len = +v[1] - old_len
+            arrs2[arrs2.length - 1] += `0${old_len}${v.slice(2, 2 + old_len)}`
+          }
+          if (new_len === 1) {
+            v = `1${v[old_len + 2]}`
+          } else if (new_len === 2) {
+            v = `1${v[old_len + 2]}1${v[old_len + 3]}`
+          } else {
+            v = `0${new_len}${v.slice(old_len + 2)}`
+          }
+        }
+      }
+      len2 = 0
+      str2 = ""
+    }
+    len2 += v.length
+    str2 += v
+  }
+  if (str2 !== "") arrs2.push("1" + str2)
+  return arrs2
 }
 
-function str2val(arr) {
+function fromSignal(arr) {
   let _arr = []
   let prev = ""
-  for (const s of arr) {
+  for (let s of arr) {
+    s = s.slice(1)
     let str = s.split("")
     while (str.length > 0) {
       const len = +str.shift()
-      if (len === 9) {
+      if (len === 0) {
+        const len2 = +str.shift()
+        for (let 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 {
@@ -465,13 +553,9 @@ function str2val(arr) {
   return _arr
 }
 
-const toSignal = val2str
-const fromSignal = str2val
-const toIndex = str2id
-const fromIndex = id2str
-
 const path = p => toSignal(encodePath(p))
 const val = v => toSignal(encodeVal(v))
+const query = v => toSignal(encodeQuery(v))
 
 function encodeQuery(v) {
   if (!Array.isArray(v)) throw Error("query must be an array")
@@ -483,7 +567,7 @@ function encodeQuery(v) {
 function decodeQuery(v) {
   const op = opMap[v[0]]
   if (isNil(op)) throw Error("op doens't exist")
-  return [op, ...decodeVal(v.slice(1))]
+  return [op, decodeVal(v.slice(1))]
 }
 
 module.exports = {
@@ -496,16 +580,13 @@ module.exports = {
   pad,
   _encode,
   flattenPath,
-  str2id,
-  val2str,
-  str2val,
-  id2str,
   toSignal,
   fromSignal,
   toIndex,
   fromIndex,
   path,
   val,
+  query,
   encodeQuery,
   decodeQuery,
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zkjson",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "description": "Zero Knowledge Provable JSON",
   "main": "index.js",
   "license": "MIT",

package/parse.js

@@ -0,0 +1,314 @@
+const { length, next, arr: _arr, push, pop, last } = require("./uint")
+const _null_ = [110, 117, 108, 108]
+const _true_ = [116, 114, 117, 101]
+const _false_ = [102, 97, 108, 115, 101]
+
+const eql = (a, b) => {
+  if (a.length != b.length) return 0
+  for (let i = 0; i < b.length; i++) {
+    if (a[i] != b[i]) return 0
+  }
+  return 1
+}
+
+const eql2 = (a, b, blen, size = 100) => {
+  var alen = length(a, size)
+  if (alen != blen) return 0
+  var c = [0, size, 0, 0, 0, 0, 0, 0, 0]
+  for (let i = 0; i < blen; i++) {
+    c = next(a, c)
+    if (c[0] != b[i]) return 0
+  }
+  return 1
+}
+
+const constVal = (_v, type) => {
+  let val = []
+  val.push(type)
+  if (type == 1) {
+    if (eql(_v, _true_) == 1) {
+      val.push(1)
+    } else {
+      val.push(0)
+    }
+  } else if (type == 3) {
+    val.push(_v.length)
+    for (let v of _v) {
+      val.push(v)
+    }
+  } else if (type == 2) {
+    if (_v[0] == 45) {
+      val.push(0)
+    } else {
+      val.push(1)
+    }
+    let after = 0
+    let right = 0
+    let digits = 0
+    for (let v of _v) {
+      if (v == 46) {
+        after = 1
+      } else if (v != 45) {
+        if (after == 1) right += 1
+        digits = digits * 10 + (v - 48)
+      }
+    }
+    val.push(right)
+    val.push(digits)
+  }
+  return val
+}
+
+const constVal2 = (_v, type, size) => {
+  var val = _arr(size)
+  push(val, size, 9, type)
+  if (type == 1) {
+    if (eql2(_v, _true_, 4, size) == 1) {
+      push(val, size, 9, 1)
+    } else {
+      push(val, size, 9, 0)
+    }
+  } else if (type == 3) {
+    push(length(_v, size))
+    var c = [0, size, 0, 0, 0, 0, 0, 0, 0]
+    while (c[5] == 0) {
+      c = next(_v, c)
+      push(val, size, 9, c[0])
+    }
+  } else if (type == 2) {
+    if (_v[0] == 45) {
+      push(val, size, 9, 0)
+    } else {
+      push(val, size, 9, 1)
+    }
+    let after = 0
+    let right = 0
+    let digits = 0
+    var c = [0, size, 0, 0, 0, 0, 0, 0, 0]
+    while (c[5] == 0) {
+      c = next(_v, c)
+      if (c[0] == 46) {
+        after = 1
+      } else if (c[0] != 45) {
+        if (after == 1) right += 1
+        digits = digits * 10 + (c[0] - 48)
+      }
+    }
+    push(val, size, 9, right)
+    push(val, size, 9, digits)
+  }
+  return val
+}
+
+const constPath = p => {
+  let pth = [p.length]
+  for (let _v of p) {
+    if (Array.isArray(_v)) {
+      pth.push(_v.length)
+      for (let v2 of _v) pth.push(v2)
+    } else {
+      pth.push(0)
+      pth.push(0)
+      pth.push(_v)
+    }
+  }
+  return pth
+}
+
+const constPath2 = (p, size) => {
+  let pth = [p.length]
+  var pth2 = _arr(size)
+  for (let _v of p) {
+    if (Array.isArray(_v)) {
+      pth.push(_v.length)
+      for (let v2 of _v) pth.push(v2)
+    } else {
+      pth.push(0)
+      pth.push(0)
+      pth.push(_v)
+    }
+  }
+  return pth2
+}
+
+const parse = (str, size = 100) => {
+  var val = []
+  var val2 = _arr(size)
+  var inVal = 0
+  var isNum = 0
+  var esc = 0
+  var nextKey = 0
+  var arr = 0
+  var obj = 0
+  var path = []
+  var path2 = _arr(size)
+  var ao = _arr(5)
+  var ind = _arr(5)
+  var err = 0
+  var json = []
+  let c = [0, size, 0, 0, 0, 0, 0, 0, 0]
+  while (c[5] == 0) {
+    c = next(str, c)
+    var s = c[0]
+    if (inVal == 1) {
+      if (s == 92) {
+        esc = 1
+      } else if (s == 34) {
+        if (esc == 1) {
+          val.push(s)
+          push(val2, size, 9, s)
+        } else {
+          inVal = 0
+          if (nextKey == 1 && last(ao, 5) == 1) {
+            path.push(val) // val push
+          } else {
+            if (last(ao, 5) == 2) {
+              var _ind = last(ind, 5)
+              path.push(_ind)
+              ind = pop(ind, 5)
+              push(ind, 5, 9, _ind + 1)
+            }
+            // console.log("val: ", `< ${path.join(".")} >`, val)
+            //console.log(constVal2(val2, 3, size))
+            json.push([constPath(path), constVal(val, 3)])
+            path.pop()
+          }
+
+          val = []
+          val2 = _arr(size)
+          nextKey = 0
+        }
+        esc = 0
+      } else {
+        val.push(s)
+        push(val2, size, 9, s)
+        esc = 0
+      }
+    } else if (isNum == 1) {
+      if (s == 44 || s == 32 || s == 125 || s == 93) {
+        if (last(ao, 5) == 2) {
+          var _ind = last(ind, 5)
+          path.push(_ind)
+          ind = pop(ind, 5)
+          push(ind, 5, 9, _ind + 1)
+        }
+        if (
+          eql2(val2, _true_, 4, size) == 0 &&
+          eql2(val2, _false_, 5, size) == 0 &&
+          eql2(val2, _null_, 4, size) == 0 &&
+          Number.isNaN(+val)
+        ) {
+          err = 1
+        }
+        // console.log("val: ", `< ${path.join(".")} >`, val)
+        var type = 2
+        if (eql2(val2, _null_, 4, size) == 1) {
+          type = 0
+        } else if (
+          eql2(val2, _true_, 4, size) == 1 ||
+          eql2(val2, _false_, 5, size)
+        ) {
+          type = 1
+        }
+        //console.log(constVal2(val2, type, size))
+        json.push([constPath(path), constVal(val, type)])
+        path.pop()
+        if (s == 93) {
+          if (last(ao, 5) != 2) err = 1
+          ao.pop()
+          path.pop()
+          arr--
+          pop(ind, 5)
+        }
+        if (s == 125) {
+          if (last(ao, 5) != 1) err = 1
+          pop(ao, 5)
+          path.pop()
+          obj--
+        }
+        isNum = 0
+        val = []
+        val2 = _arr(size)
+        if (s == 44) nextKey = 1
+      } else {
+        val.push(s)
+        push(val2, size, 9, s)
+      }
+    } else if (s == 34) {
+      inVal = 1
+    } else if (
+      s != 123 &&
+      s != 58 &&
+      s != 32 &&
+      s != 44 &&
+      s != 91 &&
+      s != 93 &&
+      s != 125
+    ) {
+      isNum = 1
+      val.push(s)
+      push(val2, size, 9, s)
+    } else {
+      if (s != 32) {
+        if (s == 123 || s == 44) nextKey = 1
+        if (s == 123) {
+          if (last(ao, 5) == 2) {
+            var _ind = last(ind, 5)
+            path.push(_ind)
+            ind = pop(ind, 5)
+            push(ind, 5, 9, _ind + 1)
+          }
+          push(ao, 5, 9, 1)
+          obj++
+        }
+        if (s == 125) {
+          if (last(ao, 5) != 1) err = 1
+          pop(ao, 5)
+          path.pop()
+          obj--
+        }
+        if (s == 91) {
+          if (last(ao, 5) == 2) {
+            var _ind = last(ind, 5)
+            path.push(_ind)
+            ind = pop(ind, 5)
+            push(ind, 5, 9, _ind + 1)
+          }
+          push(ind, 5, 9, 0)
+          push(ao, 5, 9, 2)
+          arr++
+        }
+        if (s == 93) {
+          if (last(ao, 5) != 2) err = 1
+          pop(ao, 5)
+          pop(ind, 5)
+          path.pop()
+          arr--
+        }
+      }
+    }
+  }
+
+  if (length(val2, size)) {
+    isNum = 0
+    // maybe need type this is only for bare values
+    //console.log(constVal2(val2, type, size))
+    json.push([constPath(path), constVal(val)])
+    //for (var v of path) json[json.length - 1][0].push(v)
+  }
+  if (ao.length > 0) err = 1
+  if (ind.length > 0) err = 1
+  if (inVal) err = 1
+  if (isNum) err = 1
+  var j = _arr(size)
+  for (var v of json) {
+    for (var v2 of v) {
+      for (var v3 of v2) {
+        j = push(j, size, 9, v3)
+      }
+    }
+  }
+  return j
+}
+
+module.exports = { parse }

package/uint.js

@@ -0,0 +1,425 @@
+function digits(x) {
+  if (x == 0) return 1
+  var p = 0
+  while (x > 0) {
+    x = (x / 10) >> 0 // x = x \ 10
+    p++
+  }
+  return p
+}
+
+const arr = row => {
+  var _arr = []
+  for (var i = 0; i < row; i++) {
+    _arr.push(0)
+  }
+  return _arr
+}
+
+const toArray = (json, size) => {
+  var j = []
+  var c = [0, size, 0, 0, 0, 0, 0, 0, 0]
+  while (c[5] == 0) {
+    c = next(json, c)
+    j.push(c[0])
+  }
+  return j
+}
+
+const length = (json, size) => {
+  var _len = 0
+  var c = [0, size, 0, 0, 0, 0, 0, 0, 0]
+  var nonzero = 0
+  while (c[5] == 0) {
+    c = next(json, c)
+    if (c[0] > 0) nonzero = 1
+    _len++
+  }
+  if (nonzero) {
+    return _len
+  } else {
+    return 0
+  }
+}
+
+const slice = (json, size, digit, start, end) =>{
+  var _arr = arr(size)
+  var c = [0, size, 0, 0, 0, 0, 0, 0, 0]
+  var i = 0
+  while (c[5] == 0) {
+    c = next(json, c)
+    if (i >= start && i < end) push(_arr, size, digit, c[0])
+    i++
+  }
+  return _arr
+}
+
+const get = (json,size,index) =>{
+  var c = [0, size, 0, 0, 0, 0, 0, 0, 0]
+  var i = 0
+  while (c[5] == 0) {
+    c = next(json, c)
+    if(i == index) return c[0]
+    i++
+  }
+  throw Error()
+}
+
+const insert = (json, size, digit, at, val) =>{
+  var _arr = arr(size)
+  var c = [0, size, 0, 0, 0, 0, 0, 0, 0]
+  var i = 0
+  if(at == 0) {
+    _arr = push(_arr, size, digit, val)
+  }
+  while (c[5] == 0) {
+    c = next(json, c)
+    push(_arr, size, digit, c[0])
+    i++
+    if(at == i) push(_arr, size, digit, val)
+  }
+  return _arr
+}
+
+const replace = (json, size, digit, at, val) =>{
+  var _arr = arr(size)
+  var c = [0, size, 0, 0, 0, 0, 0, 0, 0]
+  var i = 0
+  while (c[5] == 0) {
+    c = next(json, c)
+    if(at == i) {
+      _arr = push(_arr, size, digit, val)
+    }else{
+      push(_arr, size, digit, c[0])
+    }
+    i++
+  }
+  return _arr
+}
+
+const last = (json, size) => {
+  var val = 0
+  var c = [0, size, 0, 0, 0, 0, 0, 0, 0]
+  while (c[5] == 0) {
+    c = next(json, c)
+    val = c[0]
+  }
+  return val
+}
+const lastRow = (json, size) => {
+  var v = 0
+  for (var j = 0; j < size; j++) {
+    if (json[j] != 0) v = j
+  }
+  return v
+}
+
+const shift = (json, size, digit) => {
+  var _arr = arr(size)
+  var c = [0, size, 0, 0, 0, 0, 0, 0, 0]
+  var i = 0
+  while (c[5] == 0) {
+    c = next(json, c)
+    if (i > 0) push(_arr, size, digit, c[0])
+    i++
+  }
+  return _arr
+}
+
+const unshift = (json, size, digit, num) => {
+  var _arr = arr(size)
+  push(_arr, size, digit, num)
+  var c = [0, size, 0, 0, 0, 0, 0, 0, 0]
+  var i = 0
+  if (json[0] !== 0) {
+    while (c[5] == 0) {
+      c = next(json, c)
+      push(_arr, size, digit, c[0])
+      i++
+    }
+  }
+  return _arr
+}
+
+const pop = (json, size, overflow = 3) => {
+  var l = 0
+  var ll = 0
+  var lnum = 0
+  var series = 0
+  var snum = 0
+  var link = 0
+  var _l = 0
+  var _d = 0
+  for (var l2 = 0; l2 < size; l2++) {
+    if (json[l2] != 0) {
+      _l = l2
+      var x = json[l2]
+      var d = digits(x)
+      var p = d
+      var on = 0
+      var i = 0
+      while (x > 0) {
+        var n = (x / 10 ** (p - 1)) >> 0 // var n = x \ 10 ** (p - 1)
+        x -= 10 ** (p - 1) * n
+        p--
+        i++
+        if (on == 0) {
+          on = 1
+        } else {
+          var len = n
+          if (link == 0) {
+            ll = i - 1
+            l = l2
+            _d = d
+          }
+          lnum = len
+          snum = 0
+          if (len == 0) {
+            var n = (x / 10 ** (p - 1)) >> 0 // var n = x \ 10 ** (p - 1)
+            var len2 = (x / 10 ** (p - 1)) >> 0 // var n = x \ 10 ** (p - 1)
+            series = len2
+            x -= 10 ** (p - 1) * n
+            p--
+            i++
+            for (var i2 = 0; i2 < len2; i2++) {
+              var n = (x / 10 ** (p - 1)) >> 0 // var n = x \ 10 ** (p - 1)
+              snum = snum * 10 + n
+              x -= 10 ** (p - 1) * n
+              p--
+              i++
+            }
+          } else {
+            var _len = len
+            if (len == overflow + 1) {
+              link = 2
+              _len = overflow
+            } else if (link > 0) {
+              link--
+            }
+            series = 0
+            for (var i2 = 0; i2 < _len; i2++) {
+              var n = (x / 10 ** (p - 1)) >> 0 // var n = x \ 10 ** (p - 1)
+              x -= 10 ** (p - 1) * n
+              p--
+              i++
+            }
+          }
+        }
+      }
+    }
+  }
+
+  if (link == 1) {
+    for (var i = l + 1; i <= _l; i++) {
+      json[i] = 0
+    }
+    if (ll < 2) {
+      json[l] = 0
+    } else {
+      json[l] = (json[l] / 10 ** (_d - ll)) >> 0
+    }
+  } else if (series != 0) {
+    if (series == 3) {
+      json[l] = (json[l] / 10 ** (d - ll)) >> 0
+      json[l] = json[l] * 10 + 1
+      var n = (snum / 10 ** 2) >> 0
+      json[l] = json[l] * 10 + n
+      json[l] = json[l] * 10 + 1
+      var n2 = ((snum / 10) >> 0) - n * 10
+      json[l] = json[l] * 10 + n2
+    } else {
+      json[l] = (json[l] / 10 ** (d - ll - 1)) >> 0
+      json[l] = json[l] * 10 + (series - 1)
+      snum = (snum / 10) >> 0
+      json[l] = json[l] * 10 ** (series - 1) + snum
+    }
+  } else if (ll < 2) {
+    json[l] = 0
+  } else {
+    json[l] = (json[l] / 10 ** (d - ll)) >> 0
+  }
+  return json
+}
+
+const push = (json, size, digit, c, overflow = 3) => {
+  var i4 = 0
+  var init = 0
+  while (c > 0 || init == 0) {
+    init = 1
+    var len = digits(c)
+    var _len = len
+    var _len2 = len
+    var _c = c
+    if (overflow < len) {
+      _len = overflow
+      _len2 = overflow + 1
+      _c = (c / 10 ** (len - overflow)) >> 0 // _c = c \ 10 ** (len - overflow)
+      c -= _c * 10 ** (len - overflow)
+    } else {
+      c = 0
+    }
+    var appended = 0
+    for (var i = i4; i < size; i++) {
+      var d = digits(json[i])
+      var one = 0
+      var ones = 0
+      var nums = 0
+      if (_len == 1 && digit > d) {
+        var x = json[i] - 10 ** (d - 1)
+        var i2 = 1
+        while (i2 < d) {
+          var len = (x / 10 ** (d - i2 - 1)) >> 0
+          x = x - len * 10 ** (d - i2 - 1)
+          if (len == 1) {
+            if (ones == 0) one = i2
+            ones++
+          } else if (len !== 0) {
+            ones = 0
+            nums = 0
+          } else {
+            one = i2
+          }
+          i2++
+          if (len == 0) {
+            var len3 = (x / 10 ** (d - i2 - 1)) >> 0
+            x = x - len3 * 10 ** (d - i2 - 1)
+            i2++
+            ones = len3
+            for (var i3 = 0; i3 < len3; i3++) {
+              var len2 = (x / 10 ** (d - i2 - 1)) >> 0
+              x = x - len2 * 10 ** (d - i2 - 1)
+              nums = nums * 10 + len2
+              i2++
+            }
+          } else {
+            for (var i3 = 0; i3 < len; i3++) {
+              var len2 = (x / 10 ** (d - i2 - 1)) >> 0
+              x = x - len2 * 10 ** (d - i2 - 1)
+              if (len == 1) nums = nums * 10 + len2
+              i2++
+            }
+          }
+        }
+        if (ones == 2) nums = nums * 10 + _c
+      }
+      if (ones > 2) {
+        var x = (json[i] / 10 ** (d - one - 1)) >> 0
+        x = x * 10 + ones + 1
+        x = x * 10 ** ones + nums
+        x = x * 10 + _c
+        json[i] = x
+        i4 = i
+        appended = 1
+      } else if (ones == 2) {
+        var x = (json[i] / 10 ** (d - one)) >> 0
+        x = x * 10 + 0
+        x = x * 10 + ones + 1
+        x = x * 10 ** (ones + 1) + nums
+        json[i] = x
+        i4 = i
+        appended = 1
+      } else if (digit > d + _len && appended == 0) {
+        if (json[i] == 0) json[i] = 1
+        json[i] = json[i] * 10 + _len2
+        json[i] = json[i] * 10 ** _len + _c
+        i4 = i
+        appended = 1
+      }
+    }
+  }
+  return json
+}
+
+const next = (json, c) => {
+  if (c[5] == 1) {
+    return [0, c[1], 0, 0, 0, 1, c[6], c[7], c[8]]
+  }
+  var prev = 0
+  for (var j = c[2]; j < c[1]; j++) {
+    var d = digits(json[j])
+    if (json[j] > 0) {
+      var p = c[4] == 0 ? digits(json[j]) : c[4]
+      var x = c[4] == 0 ? json[j] : c[3]
+      var cur = 0
+      var num = 0
+      var on = c[4] == 0 ? 0 : c[7]
+      var len = c[4] == 0 ? 0 : c[8]
+      while (p > 0) {
+        var n = (x / 10 ** (p - 1)) >> 0 // var n = x \ 10 ** (p - 1)
+        if (on == 0) {
+          on = 1
+        } else if (on == 1) {
+          if (n == 0) {
+            on = 4
+          } else {
+            if (n == 9) {
+              len = 8
+              on = 3
+            } else {
+              on = 2
+              len = n
+            }
+            cur = 0
+          }
+        } else if (on == 4) {
+          on = 5
+          len = n
+        } else {
+          num += n * 10 ** (len - cur - 1)
+          cur++
+          if (on == 5) {
+            num = n
+            len--
+            x -= 10 ** (p - 1) * n
+            p--
+            var done = 0
+            if (p == 0) {
+              j++
+              if (c[1] == j || json[j] == 0) {
+                x = 0
+                done = 1
+              } else {
+                x = json[j]
+              }
+            }
+            if (len == 0) on = 1
+            return [num, c[1], j, x, p, done, c[6], on, len]
+          } else if (cur == len) {
+            prev *= 10 ** len
+            if (on == 3) {
+              prev += num
+            } else {
+              num += prev
+              x -= 10 ** (p - 1) * n
+              p--
+              var done = 0
+              if (p == 0) {
+                j++
+                if (c[1] == j || json[j] == 0) {
+                  x = 0
+                  done = 1
+                } else {
+                  x = json[j]
+                }
+              }
+              return [num, c[1], j, x, p, done, c[6], 1, len]
+            }
+            cur = 0
+            on = 1
+            len = 0
+            num = 0
+          }
+        }
+        x -= 10 ** (p - 1) * n
+        p--
+      }
+    } else {
+      return [0, c[1], 0, 0, 0, 1, c[6], 0, 0]
+    }
+  }
+  return [0, c[1], 0, 0, 0, 1, c[6], 0, 0]
+}
+
+module.exports = {
+  next, arr, push, length, last, pop, toArray, shift, unshift, slice, insert, replace,get
+}