zkjson 0.4.1 → 0.5.0

package/encoder-v2.js

@@ -1,1048 +1,884 @@
-const {
-  clone,
-  uniq,
-  sortBy,
-  map,
-  concat,
-  compose,
-  is,
-  descend,
-  ascend,
-  sortWith,
-  prop,
-  equals,
-  append,
-  isNil,
-  includes,
-  splitEvery,
-  flatten,
-} = require("ramda")
-const 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,
-}
-const opMap = {}
-for (let k in ops) opMap[ops[k]] = k
-
-const 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",
-}
-
-let strMap = {}
-for (const k in base64Map) strMap[base64Map[k]] = k
-
-function pad(arr, max = 0) {
-  arr = arr.map(n => n.toString())
-  for (let i = arr.length; i < max; i++) {
-    arr.push("0")
+const { bits, tobits, strmap, base64 } = require("./utils.js")
+
+class u8 {
+  constructor(size = 100, log = false) {
+    this.log = log
+
+    this.kc_counts = new Uint32Array(32)
+    this.vc_counts = new Uint32Array(32)
+    this.kc_diffs = new Uint32Array(4)
+    this.vc_diffs = new Uint32Array(4)
+    this.vlinks = new Uint32Array(32)
+    this.klinks = new Uint32Array(32)
+    this.vflags = new Uint32Array(16)
+    this.kflags = new Uint32Array(16)
+    this.bools = new Uint32Array(16)
+    this.keys = new Uint32Array(32)
+    this.types = new Uint32Array(32)
+    this.nums = new Uint32Array(32)
+    this.dc = new Uint32Array(32)
+    this.kvals = new Uint32Array(64)
+    this.vals = new Uint32Array(64)
+
+    this.strMap = new Map()
+
+    this.bitsLookup = new Uint8Array(17)
+    for (let i = 0; i < 17; i++) {
+      this.bitsLookup[i] = i === 0 ? 1 : 32 - Math.clz32(i)
+    }
+  }
+  fastBits(n) {
+    return n < 17 ? this.bitsLookup[n] : bits(n)
   }
-  return arr
-}
 
-function encodePath(path) {
-  const parts = []
-  let str = ""
-  let num = 0
-  for (const s of path) {
-    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 = ""
+  vc_diffs_set(index, value) {
+    const wordIndex = index >>> 5
+    const bitOffset = index & 31
+    if (value) {
+      this.vc_diffs[wordIndex] |= 1 << bitOffset
     } else {
-      str += s
+      this.vc_diffs[wordIndex] &= ~(1 << bitOffset)
     }
   }
-  if (str != "") parts.push(str)
-  if (parts.length == 0) parts.push("")
-  let encoded = [parts.length]
-  for (const p of parts) {
-    if (typeof p == "number") {
-      encoded = encoded.concat([0, 0, p])
+  vc_diffs_get(index) {
+    const wordIndex = index >>> 5
+    const bitOffset = index & 31
+    return (this.vc_diffs[wordIndex] >>> bitOffset) & 1
+  }
+  kc_diffs_set(index, value) {
+    const wordIndex = index >>> 5
+    const bitOffset = index & 31
+    if (value) {
+      this.kc_diffs[wordIndex] |= 1 << bitOffset
     } else {
-      let plen = [p.length]
-      if (p.length == 0) plen.push(1)
-      encoded = encoded.concat([
-        ...plen,
-        ...p.split("").map(c => c.charCodeAt(0)),
-      ])
+      this.kc_diffs[wordIndex] &= ~(1 << bitOffset)
     }
   }
-  return encoded
-}
+  kc_diffs_get(index) {
+    const wordIndex = index >>> 5
+    const bitOffset = index & 31
+    return (this.kc_diffs[wordIndex] >>> bitOffset) & 1
+  }
 
-function decodePath(path) {
-  let str = ""
-  let p = []
-  let len = path.shift()
-  while (path.length > 0) {
-    const type = path.shift()
-    let val = null
-    if (type == 0) {
-      const type2 = path.shift()
-      if (type2 == 0) {
-        val = [type2, path.shift()]
-      } else {
-        val = [type2]
-      }
-    } else {
-      val = []
-      for (let i = 0; i < type; i++) {
-        val.push(path.shift())
-      }
-    }
-    p.push([type, ...val])
+  add_vlinks(val, vlen) {
+    this.vlinks_len = this._add(this.vlinks, this.vlinks_len, val, vlen)
   }
-  let i = 0
-  for (let s of p) {
-    if (s[0] == 0 && s[1] == 0) str += `[${s[2]}]`
-    else if (s[0] == 0 && s[1] == 1) {
-      if (str != "") str += "."
-    } else {
-      str += `${i == 0 ? "" : "."}${s
-        .slice(1)
-        .map(c => String.fromCharCode(Number(c)))
-        .join("")}`
-    }
-    i++
+  add_klinks(val, vlen) {
+    this.klinks_len = this._add(this.klinks, this.klinks_len, val, vlen)
+  }
+  add_vflags(val, vlen) {
+    this.vflags_len = this._add(this.vflags, this.vflags_len, val, vlen)
+  }
+  add_kflags(val, vlen) {
+    this.kflags_len = this._add(this.kflags, this.kflags_len, val, vlen)
+  }
+  add_bools(val, vlen) {
+    this.bools_len = this._add(this.bools, this.bools_len, val, vlen)
+  }
+  add_keys(val, vlen) {
+    this.keys_len = this._add(this.keys, this.keys_len, val, vlen)
+  }
+  add_types(val, vlen) {
+    this.types_len = this._add(this.types, this.types_len, val, vlen)
+  }
+  add_nums(val, vlen) {
+    this.nums_len = this._add(this.nums, this.nums_len, val, vlen)
+  }
+  add_dc(val, vlen) {
+    this.dc_len = this._add(this.dc, this.dc_len, val, vlen)
+  }
+  add_kvals(val, vlen) {
+    this.kvals_len = this._add(this.kvals, this.kvals_len, val, vlen)
+  }
+  add_vals(val, vlen) {
+    this.vals_len = this._add(this.vals, this.vals_len, val, vlen)
   }
-  return str
-}
 
-function flattenPath(path) {
-  let p = [path.length]
-  for (const v of path) p = p.concat(v)
-  return p
-}
+  _add(tar, len, val, vlen) {
+    val &= vlen >= 32 ? 0xffffffff : (1 << vlen) - 1
+    const used = len & 31
+    const free = used === 0 ? 32 : 32 - used
+    const idx = len >> 5
+
+    if (vlen <= free) {
+      if (used === 0) tar[idx] = val
+      else tar[idx] = (tar[idx] << vlen) | val
+      len += vlen
+      return len
+    }
+
+    const high = val >>> (vlen - free)
+    if (used === 0) tar[idx] = high
+    else tar[idx] = (tar[idx] << free) | high
+    len += free
 
-function _encode(v, path = []) {
-  let 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)) {
-    let i = 0
-    for (const v2 of v) {
-      for (const v3 of _encode(v2, [...path, i])) vals.push(v3)
-      i++
+    let rest = vlen - free
+    if (rest <= 32) {
+      tar[idx + 1] = val & ((1 << rest) - 1)
+      len += rest
+      return len
     }
-  } else if (typeof v == "object") {
-    for (const k in v) for (let v4 of _encode(v[k], [...path, k])) vals.push(v4)
-  }
-  return vals
-}
 
-const filterDic = keys => keys.filter(entry => entry.count > 1)
-
-function countKeys(keys) {
-  let keys2 = []
-  for (let v of keys) {
-    let i = 0
-    for (let v2 of v) {
-      const _key = v.slice(0, i + 1)
-      let exists = false
-      for (let v3 of keys2) {
-        if (equals(_key, v3.key)) {
-          v3.count += 1
-          exists = true
-        }
-      }
-      if (!exists) keys2.push({ key: _key, count: 1 })
-      i++
+    let writeIdx = idx + 1
+    while (rest > 32) {
+      tar[writeIdx++] = (val >>> (rest - 32)) & 0xffffffff
+      len += 32
+      rest -= 32
     }
-  }
-  return keys2
-}
 
-function sortKeys(keys) {
-  return keys.sort((a, b) => {
-    if (b.count !== a.count) return b.count - a.count
-    for (let i = 0; i < Math.min(a.key.length, b.key.length); i++) {
-      const aVal = a.key[i]
-      const 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
+    if (rest > 0) {
+      tar[writeIdx] = val & ((1 << rest) - 1)
+      len += rest
     }
+    return len
+  }
 
-    return a.key.length - b.key.length
-  })
-}
+  push_vflag(flag) {
+    this.add_vflags(flag, 1)
+  }
 
-function buildDic(data) {
-  // --- Step 1. (Optional) Save original input order if needed.
-  data.forEach((entry, idx) => (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((a, b) => {
-    const keyA = a.key
-    const keyB = b.key
-
-    // Primary: Compare array lengths.
-    if (keyA.length !== keyB.length) return keyA.length - keyB.length
-
-    // Secondary: Compare total character lengths (ascending).
-    const totalA = keyA.reduce((acc, x) => acc + x.toString().length, 0)
-    const totalB = keyB.reduce((acc, x) => acc + x.toString().length, 0)
-    if (totalA !== totalB) return totalA - totalB
-    // Tertiary: Compare element-by-element using natural order.
-    for (let i = 0; i < keyA.length; i++) {
-      const elA = keyA[i]
-      const elB = keyB[i]
-
-      if (typeof elA === typeof elB) {
-        if (typeof elA === "number") {
-          if (elA !== elB) return elA - elB
-        } else if (typeof elA === "string") {
-          const cmp = elA.localeCompare(elB, undefined, { numeric: true })
-          if (cmp !== 0) return cmp
-        } else {
-          // Fallback: compare string representations.
-          const cmp = elA
-            .toString()
-            .localeCompare(elB.toString(), undefined, { numeric: true })
-          if (cmp !== 0) return cmp
-        }
-      } else {
-        // If types differ, compare string representations.
-        const cmp = elA
-          .toString()
-          .localeCompare(elB.toString(), undefined, { numeric: true })
-        if (cmp !== 0) return cmp
-      }
-    }
+  push_bool(bool) {
+    this.add_bools(bool ? 1 : 0, 1)
+  }
+
+  push_kflag(flag) {
+    this.add_kflags(flag, 1)
+  }
 
-    return 0
-  })
+  get_diff(v, prev) {
+    let diff = prev === null ? v : v - prev
+    let isDiff = false
+    if (diff < 0) {
+      diff = Math.abs(diff) + 3
+      isDiff = diff < 7
+    } else isDiff = diff < 4
+    const v2 = isDiff ? diff : v
+    return (v2 << 1) | (isDiff ? 1 : 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.
-  const dict = []
+  push_vlink(v) {
+    let result = this.get_diff(v, this.prev_link)
+    const isDiff = (result & 1) === 1
+    const v2 = result >>> 1
+    this.prev_link = v
+    this.push_vflag(isDiff ? 1 : 0)
+    this._push_vlink(v2, isDiff, this.dcount)
+    this.rcount++
+  }
 
-  // Helper: For a given string, look for a previously defined simple key (an array of length 1).
-  function getPointerIndex(str) {
-    for (let i = 0; i < dict.length; i++) {
-      if (dict[i].original.length === 1 && dict[i].original[0] === str) return i
+  push_klink(v) {
+    let result = this.get_diff(v, this.prev_klink)
+    const isDiff = (result & 1) === 1
+    const v2 = result >>> 1
+    this.prev_klink = v
+    this.push_kflag(isDiff ? 1 : 0)
+    this._push_klink(v2, isDiff, this.dcount)
+  }
+
+  set_newbits(count) {
+    const new_bits = this.fastBits(count + 1)
+    if (new_bits > this.prev_bits) {
+      const diff = new_bits - this.prev_bits
+      for (let i = 0; i < diff; i++) {
+        this.add_vlinks(0, this.prev_bits + i)
+      }
+      this.prev_bits = new_bits
     }
-    return -1
+    return new_bits
   }
 
-  // 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) {
-    const rep = []
-    let i = 0
-    while (i < key.length) {
-      const el = key[i]
-      if (typeof el === "string") {
-        const ptrIndex = getPointerIndex(el)
-        if (ptrIndex !== -1) {
-          let j = i
-          while (j < key.length && key[j] === el) {
-            j++
-          }
-          const groupLen = j - i
-          rep.push(groupLen === 1 ? [ptrIndex] : [ptrIndex, 0])
-          i = j
-          continue
-        }
+  set_newbits_k(count) {
+    const new_bits = this.fastBits(count + 1)
+    if (new_bits > this.prev_kbits) {
+      const diff = new_bits - this.prev_kbits
+      for (let i = 0; i < diff; i++) {
+        this.add_klinks(0, this.prev_kbits + i)
       }
-      rep.push(el)
-      i++
+      this.prev_kbits = new_bits
     }
-    return rep
+    return new_bits
   }
 
-  // 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) {
-    let cost = 0
-    for (const token of rep) cost += Array.isArray(token) ? token.length : 1
-    return cost
+  _flush_vlink(v, diff, count) {
+    if (diff) {
+      this.add_vlinks(v + 1, 3)
+    } else {
+      const nb = this.set_newbits(count)
+      this.add_vlinks(v + 1, nb)
+    }
   }
 
-  // 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) {
-    const n = key.length
-    const dp = Array(n + 1).fill(null)
-    dp[n] = { cost: 0, seg: [] }
-
-    for (let i = n - 1; i >= 0; i--) {
-      let best = null
-      // Try every dictionary entry.
-      for (let d = 0; d < dict.length; d++) {
-        const candidate = dict[d].original
-        const m = candidate.length
-        if (i + m <= n) {
-          let match = true
-          for (let k = 0; k < m; k++) {
-            if (key[i + k] !== candidate[k]) {
-              match = false
-              break
-            }
-          }
-          if (match && dp[i + m] !== null) {
-            const 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) }
-            }
-          }
-        }
+  flush_vlink() {
+    if (this.vc_v === null) return
+    if (this.vc_count < 4) {
+      for (let i = 0; i < this.vc_count; i++)
+        this._flush_vlink(
+          this.vc_v,
+          this.vc_diffs_get(i) === 1,
+          this.vc_counts[i],
+        )
+    } else {
+      if (this.vc_diffs_get(0) === 1) {
+        this.add_vlinks(0, 3)
+        this.short_vlinks(this.vc_count)
+        this.add_vlinks(this.vc_v + 1, 3)
+      } else {
+        const nb = this.set_newbits(this.vc_counts[0])
+        this.add_vlinks(0, nb)
+        this.short_vlinks(this.vc_count)
+        this.add_vlinks(this.vc_v + 1, nb)
       }
-      dp[i] = best
     }
-    return dp[0]
   }
 
-  // Process each entry (in the sorted, deterministic order).
-  for (const entry of data) {
-    const key = entry.key
-    let compressed
-    if (key.length === 1) {
-      // For simple keys, copy as-is.
-      compressed = key.slice()
+  _push_vlink(v, diff, count) {
+    if (this.vc_v === null) {
+      this.vc_v = v
+      this.vc_diffs_set(0, diff ? 1 : 0)
+      this.vc_counts[0] = count
+      this.vc_count = 1
+    } else if (v === this.vc_v) {
+      this.vc_diffs_set(this.vc_count, diff ? 1 : 0)
+      this.vc_counts[this.vc_count] = count
+      this.vc_count++
     } else {
-      // Try element-by-element compression.
-      const repA = compressElementByElement(key)
-      let bestCost = computeCost(repA)
-      let bestRep = repA
-
-      // Also try full segmentation over the entire key.
-      const segRes = segmentKey(key)
-      if (segRes !== null) {
-        const repB = [segRes.seg] // Represent segmentation as a pointer.
-        const costB = segRes.cost
-        if (costB < bestCost) {
-          bestCost = costB
-          bestRep = repB
-        }
-      }
+      this.flush_vlink()
+      this.vc_v = v
+      this.vc_diffs_set(0, diff ? 1 : 0)
+      this.vc_counts[0] = count
+      this.vc_count = 1
+    }
+  }
 
-      // Now try partial segmentation: try segmenting a prefix and then appending the literal remainder.
-      const n = key.length
-      for (let i = 1; i < n; i++) {
-        const prefixSeg = segmentKey(key.slice(0, i))
-        if (prefixSeg !== null) {
-          const literalPart = key.slice(i)
-          const 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)
-          }
-        }
+  flush_klink() {
+    if (this.kc_v === null) return
+    if (this.kc_count < 4) {
+      for (let i = 0; i < this.kc_count; i++)
+        this._flush_klink(
+          this.kc_v,
+          this.kc_diffs_get(i) === 1,
+          this.kc_counts[i],
+        )
+    } else {
+      if (this.kc_diffs_get(0) === 1) {
+        this.add_klinks(0, 3)
+        this.short_klinks(this.kc_count)
+        this.add_klinks(this.kc_v + 1, 3)
+      } else {
+        const nb = this.set_newbits_k(this.kc_counts[0])
+        this.add_klinks(0, nb)
+        this.short_klinks(this.kc_count)
+        this.add_klinks(this.kc_v + 1, nb)
       }
-
-      compressed = bestRep
     }
-    dict.push({ original: key, 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).
-  return {
-    dictionary: dict.map(entry => {
-      return entry.compressed.length === 1 && !is(Array, entry.compressed[0])
-        ? entry.compressed[0]
-        : entry.compressed
-    }),
-    keyMap: dict.map(entry => entry.original),
+  _flush_klink(v, diff, count) {
+    if (diff) {
+      this.add_klinks(v + 1, 3)
+    } else {
+      const nb = this.set_newbits_k(count)
+      this.add_klinks(v + 1, nb)
+    }
   }
-}
-const genDic = compose(buildDic, filterDic, sortKeys, countKeys, listKeys)
-
-function listKeys(v, key = [], keys = []) {
-  if (Array.isArray(v)) {
-    let i = 0
-    for (const v2 of v) {
-      listKeys(v2, append(i, key), keys)
-      i++
+
+  _push_klink(v, diff, count) {
+    if (this.kc_v === null) {
+      this.kc_v = v
+      this.kc_diffs_set(0, diff ? 1 : 0)
+      this.kc_counts[0] = count
+      this.kc_count = 1
+    } else if (v === this.kc_v) {
+      this.kc_diffs_set(this.kc_count, diff ? 1 : 0)
+      this.kc_counts[this.kc_count] = count
+      this.kc_count++
+    } else {
+      this.flush_klink()
+      this.kc_v = v
+      this.kc_diffs_set(0, diff ? 1 : 0)
+      this.kc_counts[0] = count
+      this.kc_count = 1
     }
-  } else if (typeof v == "object") {
-    for (const k in v) listKeys(v[k], append(k, key), keys)
-  } else {
-    keys.push(key)
   }
-  return keys
-}
 
-function isPrefix(path, prefix) {
-  if (prefix.length > path.length) return false
-  for (let i = 0; i < prefix.length; i++) {
-    if (!equals(path[i], prefix[i])) return false
+  push_type(v) {
+    let count = this.tcount
+    if (count > 3) {
+      this.add_types(0, 3)
+      this.short_types(count)
+      this.add_types(v, 3)
+    } else for (let i = 0; i < count; i++) this.add_types(v, 3)
+    this.tcount = 1
   }
-  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.
-  for (const { entry, index } of sortedDic) {
-    if (isPrefix(path, entry)) {
-      // Found a match: remove the matched prefix.
-      const remainder = path.slice(entry.length)
-      // Recursively apply dictionary replacement on the remainder.
-      const 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, ...replacedRemainder[0]]]
-      } else {
-        // Otherwise, return the dictionary reference for the prefix and then the literal remainder.
-        return [[index]].concat(replacedRemainder)
-      }
-    }
+
+  push_keylen(v) {
+    this.short_keys(v)
   }
-  // If no dictionary entry applies, return the original literal path.
-  return path
-}
 
-function applyDic(arr, dic) {
-  // Build sorted dictionary entries in descending order by length.
-  const sortedDic = dic
-    .map((entry, index) => ({ entry, index }))
-    .sort((a, b) => b.entry.length - a.entry.length)
-  // For each pair, apply dictionary replacement to the path.
-  return arr.map(pair => {
-    const newPath = applyDicToPath(pair[0], sortedDic)
-    return [newPath, pair[1]]
-  })
-}
+  push_int(v) {
+    let result = this.get_diff(v, this.prev_num)
+    const isDiff = (result & 1) === 1
+    const v2 = result >>> 1
 
-function encodePaths(data) {
-  for (let v of data) {
-    let path = []
-    for (let v2 of v[0]) {
-      if (is(Number, v2)) path.push([0, 0, v2])
-      else if (is(String, v2)) {
-        const key = v2.split("").map(c => c.charCodeAt(0))
-        path.push([key.length, ...(key.length == 0 ? [1] : key)])
-      } else if (is(Array, v2)) {
-        if (v2.length === 1) path.push([0, 3, v2[0]])
-        else path.push([0, 4, v2.length, ...v2])
-      }
-    }
-    v[0] = path
+    this.prev_num = v
+    this.dint(v2, isDiff)
   }
-  return data
-}
 
-function mapDic(dic, len) {
-  let _map = []
-  while (dic.length > 0) {
-    let dlen = dic.shift()
-    let _elms = []
-    while (dlen > 0) {
-      let type = dic.shift()
-      let elms = []
-      if (type == 7) {
-        let slen = dic.shift()
-        elms.push(slen)
-        for (let i = 0; i < slen; i++) elms.push(dic.shift())
-        _elms.push(elms)
-      } else if (type == 3) {
-        elms = concat(elms, [0, 0, dic.shift()])
-        _elms.push(elms)
-      } else if (type == 9) {
-        for (let v2 of _map[dic.shift()]) _elms.push(v2)
+  push_float(neg, v) {
+    if (v < 4) this.push_int(neg ? 4 + v : v)
+    else this.push_int(neg ? 4 : 0)
+  }
+
+  flush_nums() {
+    if (this.nc_diff !== null) {
+      if (this.nc_count < 3) {
+        for (let i = 0; i < this.nc_count; i++)
+          this._dint(this.nc_v, this.nc_diff)
+      } else {
+        this.add_nums(0, 2)
+        this.add_nums(7, 3)
+        this.short_nums(this.nc_count)
+        if (this.nc_diff) {
+          this.add_nums(0, 2)
+          this.add_nums(this.nc_v, 3)
+        } else if (this.nc_v < 64) {
+          const d = this.nc_v < 16 ? 4 : 6
+          const flag = this.nc_v < 16 ? 1 : 2
+          this.add_nums(flag, 2)
+          this.add_nums(this.nc_v, d)
+        } else this.leb128_nums(this.nc_v)
       }
-      dlen--
     }
-    _map.push(_elms)
-    if (_map.length === len) break
   }
-  return _map
-}
 
-function encodeDic(dict) {
-  let enc = []
-  for (let v of dict) {
-    let len = 1
-    let elms = []
-    if (!is(String, v)) {
-      len = 0
-      for (let v2 of v) {
-        if (is(Array, v2)) {
-          len += v2.length
-          for (let v3 of v2) elms = concat(elms, [9, v3])
-        } else {
-          len += 1
-          if (is(String, v2)) {
-            elms.push(7)
-            elms.push(v2.length)
-            elms = concat(
-              elms,
-              v2.split("").map(c => c.charCodeAt(0)),
-            )
-          } else {
-            elms = concat(elms, [3, v2])
-          }
-        }
-      }
+  dint(v, diff = false) {
+    if (this.nc_diff === null) {
+      this.nc_diff = diff
+      this.nc_v = v
+      this.nc_count = 1
+    } else if (this.nc_diff === diff && this.nc_v === v) {
+      this.nc_count += 1
     } else {
-      elms.push(7)
-      elms.push(v.length)
-      elms = concat(
-        elms,
-        v.split("").map(c => c.charCodeAt(0)),
-      )
+      if (this.nc_count === 1) this._dint(this.nc_v, this.nc_diff)
+      else this.flush_nums()
+      this.nc_diff = diff
+      this.nc_v = v
+      this.nc_count = 1
     }
-    enc = concat(enc, [len, ...elms])
   }
-  return enc
-}
 
-function encode(json, nodic = false) {
-  let dic = null
-  let dictionary, keyMap
-  if (nodic !== true) {
-    ;({ dictionary, keyMap } = genDic(json))
-    if (dictionary.length > 0) dic = encodeDic(dictionary)
+  _dint(v, diff) {
+    if (diff) {
+      this.add_nums(0, 2)
+      this.add_nums(v, 3)
+    } else if (v < 64) {
+      const d = v < 16 ? 4 : 6
+      const flag = v < 16 ? 1 : 2
+      this.add_nums(flag, 2)
+      this.add_nums(v, d)
+    } else this.leb128_nums(v)
   }
-  let enc = _encode(json)
-  if (dic) enc = applyDic(enc, keyMap)
-
-  enc = encodePaths(enc)
-  enc.sort((a, b) => {
-    const isUndefined = v => typeof v == "undefined"
-    const max = Math.max(a[0].length, b[0].length)
-    if (max > 0) {
-      for (let i = 0; i < max; i++) {
-        const exA = !isUndefined(a[0][i])
-        const exB = !isUndefined(b[0][i])
-        if (exA && !exB) return 1
-        if (!exA && exB) return -1
-        const max2 = Math.max(a[0][i].length, b[0][i].length)
-        if (max2 > 0) {
-          for (let i2 = 0; i2 < max2; i2++) {
-            const vA = a[0][i][i2]
-            const vB = b[0][i][i2]
-            const exA = !isUndefined(vA)
-            const exB = !isUndefined(vB)
-            if (exA && !exB) return 1
-            if (!exA && exB) return -1
-            if (vA > vB) return 1
-            if (vA < vB) return -1
-          }
-        }
-      }
+
+  leb128_2_kvals(v) {
+    while (v >= 128) {
+      this.add_kvals((v & 0x7f) | 0x80, 8)
+      v >>>= 7
     }
-    return 0
-  })
-  const _dic = dic ? [1, 0, 2, dictionary.length, ...dic] : []
-  return concat(
-    _dic,
-    enc.reduce((arr, v) => arr.concat([...flattenPath(v[0]), ...v[1]]), []),
-  )
-}
+    this.add_kvals(v, 8)
+  }
 
-function _decode(arr) {
-  let vals = []
-  let dic = []
-  while (arr.length > 0) {
-    let plen = arr.shift()
-    let keys = []
-    let val = null
-    let skip = false
-    while (plen > 0) {
-      const plen2 = arr.shift()
-      if (plen2 == 0) {
-        const plen3 = arr.shift()
-        if (plen3 == 1) {
-          keys.push([plen2, plen3])
-        } else if (plen3 == 0) {
-          keys.push([plen2, plen3, arr.shift()])
-        } else if (plen3 == 2) {
-          const dict = arr.shift()
-          dic = mapDic(arr, dict)
-          skip = true
-        } else if (plen3 == 3) {
-          const _keys = dic[arr.shift()]
-          for (const k of _keys) keys.push(k)
-        } else if (plen3 == 4) {
-          let key = []
-          let plen4 = arr.shift()
-          for (let i2 = 0; i2 < plen4; i2++) {
-            const _keys = dic[arr.shift()]
-            for (const k of _keys) keys.push(k)
-          }
-        }
-      } else if (plen2 != 0) {
-        const plen3 = plen2
-        let key = []
-        for (let i2 = 0; i2 < plen3; i2++) key.push(arr.shift())
-        keys.push([plen2, ...key])
-      }
-      plen--
+  leb128_dc(v) {
+    this.add_dc(3, 2)
+    while (v >= 128) {
+      this.add_dc((v & 0x7f) | 0x80, 8)
+      v >>>= 7
     }
-    if (skip) continue
-    const type = arr.shift()
-    val = [type]
-    if (type == 5 || type == 6) {
-      val.push(arr.shift())
-      val.push(arr.shift())
-    } else if (type == 3 || type == 4) {
-      val.push(arr.shift())
-    } else if (type == 7) {
-      const strlen = arr.shift()
-      val.push(strlen)
-      for (let i2 = 0; i2 < strlen; i2++) val.push(arr.shift())
+    this.add_dc(v, 8)
+  }
+
+  leb128_keys(v) {
+    this.add_keys(3, 2)
+    while (v >= 128) {
+      this.add_keys((v & 0x7f) | 0x80, 8)
+      v >>>= 7
     }
-    vals.push([keys, val])
+    this.add_keys(v, 8)
   }
-  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) {
-  let vals = []
-  if (typeof v == "number" || typeof v == "bigint") {
-    const int = Number.isInteger(v)
-    let moved = 0
-    let num = v
-    while (num % 1 != 0) {
-      num *= 10
-      moved += 1
+  leb128_klinks(v) {
+    this.add_klinks(3, 2)
+    while (v >= 128) {
+      this.add_klinks((v & 0x7f) | 0x80, 8)
+      v >>>= 7
     }
-    let type = 3
-    if (v >= 0) {
-      if (moved > 0) type = 5
-    } else {
-      if (moved > 0) type = 6
-      else type = 4
+    this.add_klinks(v, 8)
+  }
+
+  leb128_vals(v) {
+    this.add_vals(3, 2)
+    while (v >= 128) {
+      this.add_vals((v & 0x7f) | 0x80, 8)
+      v >>>= 7
     }
-    vals.push(type)
-    if (moved > 0) vals.push(moved)
-    if (v < 0) vals.push(-num)
-    else vals.push(num)
-  } else if (typeof v == "boolean") vals.push(v ? 1 : 2)
-  else if (v == null) vals = [0]
-  else if (typeof v == "string") {
-    vals = [7, v.length, ...v.split("").map(c => c.charCodeAt(0))]
-  } else vals = [8, ...encode(v)]
-  return vals
-}
+    this.add_vals(v, 8)
+  }
 
-function decodeVal(arr) {
-  const type = arr[0]
-  const _val = arr[1]
-  let 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 (let i = 0; i < arr[1]; i++) {
-      val /= 10
+  leb128_kvals(v) {
+    this.add_kvals(3, 2)
+    while (v >= 128) {
+      this.add_kvals((v & 0x7f) | 0x80, 8)
+      v >>>= 7
     }
-  } else if (type == 6) {
-    val = arr[2] * -1
-    for (let i = 0; i < arr[1]; i++) {
-      val /= 10
+    this.add_kvals(v, 8)
+  }
+
+  leb128_nums(v) {
+    this.add_nums(3, 2)
+    while (v >= 128) {
+      this.add_nums((v & 0x7f) | 0x80, 8)
+      v >>>= 7
     }
-  } else if (type == 7) {
-    val = arr
-      .slice(2)
-      .map(c => String.fromCharCode(Number(c)))
-      .join("")
-  } else if (type == 8) {
-    val = decode(arr.slice(1))
+    this.add_nums(v, 8)
   }
-  return val
-}
 
-function decode(arr) {
-  const decoded = _decode(arr)
-  let json =
-    decoded[0]?.[0]?.[0]?.[0] == 0 && decoded[0]?.[0]?.[0]?.[1] == 0 ? [] : {}
-  for (const v of decoded) {
-    const keys = v[0].map(v2 => {
-      if (v2[0] == 0) {
-        if (v2[1] == 1) return ""
-        return v2[2]
-      } else {
-        return v2
-          .slice(1)
-          .map(c => String.fromCharCode(Number(c)))
-          .join("")
-      }
-    })
-    if (keys.length == 0) {
-      json = decodeVal(v[1])
-    } else {
-      let obj = json
-      let i = 0
-      for (const k of keys) {
-        if (typeof k == "number") {
-          if (typeof keys[i + 1] == "undefined") {
-            obj[k] = decodeVal(v[1])
-          } else {
-            if (typeof obj[k] == "undefined") {
-              if (typeof keys[i + 1] == "string") {
-                obj[k] = {}
-              } else {
-                obj[k] = []
-              }
-            }
+  leb128_types(v) {
+    this.add_types(3, 2)
+    while (v >= 128) {
+      this.add_types((v & 0x7f) | 0x80, 8)
+      v >>>= 7
+    }
+    this.add_types(v, 8)
+  }
+
+  leb128_vlinks(v) {
+    this.add_vlinks(3, 2)
+    while (v >= 128) {
+      this.add_vlinks((v & 0x7f) | 0x80, 8)
+      v >>>= 7
+    }
+    this.add_vlinks(v, 8)
+  }
+
+  uint_dc(v) {
+    if (v < 64) {
+      const d = v < 8 ? 3 : v < 16 ? 4 : 6
+      const flag = v < 8 ? 0 : v < 16 ? 1 : 2
+      this.add_dc(flag, 2)
+      this.add_dc(v, d)
+    } else this.leb128_dc(v)
+  }
+
+  short_types(v) {
+    if (v < 16) {
+      const d = v < 4 ? 2 : this.fastBits(v)
+      this.add_types(d - 2, 2)
+      this.add_types(v, d)
+    } else this.leb128_types(v)
+  }
+
+  short_dc(v) {
+    if (v < 16) {
+      const d = v < 4 ? 2 : this.fastBits(v)
+      this.add_dc(d - 2, 2)
+      this.add_dc(v, d)
+    } else this.leb128_dc(v)
+  }
+
+  short_vals(v) {
+    if (v < 16) {
+      const d = v < 4 ? 2 : this.fastBits(v)
+      this.add_vals(d - 2, 2)
+      this.add_vals(v, d)
+    } else this.leb128_vals(v)
+  }
+
+  short_kvals(v) {
+    if (v < 16) {
+      const d = v < 4 ? 2 : this.fastBits(v)
+      this.add_kvals(d - 2, 2)
+      this.add_kvals(v, d)
+    } else this.leb128_kvals(v)
+  }
+
+  short_keys(v) {
+    if (v < 16) {
+      const d = v < 4 ? 2 : this.fastBits(v)
+      this.add_keys(d - 2, 2)
+      this.add_keys(v, d)
+    } else this.leb128_keys(v)
+  }
+
+  short_klinks(v) {
+    if (v < 16) {
+      const d = v < 4 ? 2 : this.fastBits(v)
+      this.add_klinks(d - 2, 2)
+      this.add_klinks(v, d)
+    } else this.leb128_klinks(v)
+  }
+
+  short_vlinks(v) {
+    if (v < 16) {
+      const d = v < 4 ? 2 : this.fastBits(v)
+      this.add_vlinks(d - 2, 2)
+      this.add_vlinks(v, d)
+    } else this.leb128_vlinks(v)
+  }
+
+  reset() {
+    this.strMap.clear()
+    this.str_len = 0
+    this.prev_bits = 1
+    this.prev_kbits = 1
+    this.prev_num = 0
+    this.nums_count = 0
+    this.prev_link = null
+    this.prev_klink = null
+    this.single = true
+    this.len = 0
+    this.dlen = 0
+    this.jlen = 0
+    this.dcount = 0
+    this.rcount = 0
+    this.tcount = 0
+    this.oid = 0
+    this.iid = 0
+
+    this.vc_v = null
+
+    this.vc_count = null
+
+    this.kc_v = null
+
+    this.kc_count = null
+
+    this.nc_diff = null
+    this.nc_v = null
+    this.nc_count = null
+
+    this.vlinks_len = 0
+    this.klinks_len = 0
+    this.vflags_len = 0
+    this.kflags_len = 0
+    this.bools_len = 0
+    this.keys_len = 0
+    this.types_len = 0
+    this.nums_len = 0
+    this.dc_len = 0
+    this.kvals_len = 0
+    this.vals_len = 0
+  }
+
+  dump() {
+    if (!this.single) {
+      this.flush_vlink()
+      this.flush_klink()
+      this.flush_nums()
+      this.add_dc(this.single ? 1 : 0, 1)
+      this.short_dc(this.rcount)
+    }
+
+    const totalBits =
+      this.dc_len +
+      this.vflags_len +
+      this.vlinks_len +
+      this.kflags_len +
+      this.klinks_len +
+      this.keys_len +
+      this.types_len +
+      this.nums_len +
+      this.bools_len +
+      this.kvals_len +
+      this.vals_len
+
+    const padBits = (8 - (totalBits % 8)) % 8
+    const finalBits = totalBits + padBits
+    const outLength = finalBits / 8
+    const out = new Uint8Array(outLength)
+
+    let outIndex = 0
+    let accumulator = 0
+    let accBits = 0
+
+    const writeBits = (num, numBits) => {
+      while (numBits > 0) {
+        const free = 8 - accBits
+        if (numBits <= free) {
+          accumulator = (accumulator << numBits) | (num & ((1 << numBits) - 1))
+          accBits += numBits
+          numBits = 0
+          if (accBits === 8) {
+            out[outIndex++] = accumulator
+            accumulator = 0
+            accBits = 0
           }
         } else {
-          if (typeof obj[k] == "undefined") {
-            if (typeof keys[i + 1] == "undefined") {
-              obj[k] = decodeVal(v[1])
-            } else if (typeof keys[i + 1] == "string") {
-              obj[k] = {}
-            } else {
-              obj[k] = []
-            }
-          }
+          const shift = numBits - free
+          const part = num >>> shift
+          accumulator = (accumulator << free) | (part & ((1 << free) - 1))
+          out[outIndex++] = accumulator
+          num = num & ((1 << shift) - 1)
+          numBits -= free
+          accumulator = 0
+          accBits = 0
         }
-        obj = obj[k]
-        i++
       }
     }
-  }
-  return json
-}
 
-const toIndex = str => {
-  return (
-    "1" +
-    str
-      .split("")
-      .map(s => base64Map[s])
-      .join("")
-  )
-}
-
-const fromIndex = id => {
-  let _id = id.toString().split("")
-  _id.shift()
-  return splitEvery(2, _id)
-    .map(s => {
-      return strMap[s.join("")]
-    })
-    .join("")
-}
-
-function toSignal(arr, uint_len = 75) {
-  const _arr = flatten(
-    arr.map(n => {
-      let str = splitEvery(8, n.toString().split(""))
+    const writeBuffer = (buffer, bitLen) => {
+      let remaining = bitLen
       let i = 0
-      str = str.map(s => {
-        const len = i == str.length - 1 ? s.length : 9
+      while (remaining > 0 && i < buffer.length) {
+        const bitsThis = Math.min(32, remaining)
+        writeBits(buffer[i] >>> 0, bitsThis)
+        remaining -= bitsThis
         i++
-        return len.toString() + s.join("")
-      })
-      return str
-    }),
-  )
-  let _arr2 = []
-  let one = 0
-  let i = 0
-  let start = null
-  if (!uint_len) uint_len = _arr * 100
-  for (let v of _arr) {
-    _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]}`
+
+    writeBuffer(this.dc, this.dc_len)
+    writeBuffer(this.vflags, this.vflags_len)
+    writeBuffer(this.vlinks, this.vlinks_len)
+    writeBuffer(this.kflags, this.kflags_len)
+    writeBuffer(this.klinks, this.klinks_len)
+    writeBuffer(this.keys, this.keys_len)
+    writeBuffer(this.types, this.types_len)
+    writeBuffer(this.bools, this.bools_len)
+    writeBuffer(this.nums, this.nums_len)
+    writeBuffer(this.kvals, this.kvals_len)
+    writeBuffer(this.vals, this.vals_len)
+
+    if (padBits > 0) writeBits(0, padBits)
+
+    return out
   }
-  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
+}
+
+function pushPathStr(u, v2, prev = null) {
+  if (u.dcount > 0) u.push_klink(prev === null ? 0 : prev + 1)
+  if (u.strMap.has(v2)) {
+    u.add_keys(2, 2)
+    u.push_keylen(0)
+    u.short_kvals(u.strMap.get(v2))
+  } else {
+    u.strMap.set(v2, u.str_len++)
+    const len = v2.length
+    let ktype = 3
+    let codes = []
+    let codes2 = []
+    if (len !== 0) {
+      let is64 = true
+      for (let i = 0; i < len; i++) {
+        codes2.push(v2.charCodeAt(i))
+        const c = base64[v2[i]]
+        if (typeof c === "undefined") is64 = false
+        else codes.push(c)
       }
-    } else {
-      _arr3.push(v)
+      if (is64) ktype = 2
     }
+    u.add_keys(ktype, 2)
+    u.push_keylen(len + 2)
+    if (ktype === 3) for (let v of codes2) u.leb128_2_kvals(v)
+    else for (let v of codes) u.add_kvals(v, 6)
   }
-  if (chain != null) _arr3.push(num)
-  let arrs2 = []
-  let len2 = 0
-  let str2 = ""
-  for (let v of _arr3) {
-    if (len2 + v.length > uint_len) {
-      arrs2.push("1" + str2)
-      if (+v[0] == 0) {
-        let len3 = uint_len - 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)}`
+  u.dcount++
+}
+
+function pushPathNum(u, prev = null, keylen) {
+  if (u.dcount > 0) u.push_klink(prev === null ? 0 : prev + 1)
+  u.add_keys(keylen, 2)
+  const id = keylen === 0 ? u.iid++ : u.oid++
+  u.dcount++
+}
+
+function encode_x(v, u) {
+  u.reset()
+  if (v === null) {
+    u.add_dc(1, 1)
+    u.add_dc(0, 7)
+  } else if (typeof v !== "object") {
+    u.add_dc(1, 1)
+    if (v === true) u.add_dc(1, 7)
+    else if (v === false) u.add_dc(2, 7)
+    else if (v === "") u.add_dc(3, 7)
+    else if (typeof v === "number") {
+      const moved = v % 1 === v ? 0 : getPrecision(v)
+      const type = moved === 0 ? (v < 0 ? 5 : 4) : v < 0 ? 7 : 6
+      if (type === 4) {
+        u.add_dc(1, 1)
+        if (v < 63) u.add_dc(v, 6)
+        else {
+          u.add_dc(63, 6)
+          u.leb128_2_dc(v - 63)
+        }
+      } else {
+        u.add_dc(0, 1)
+        u.add_dc(type + 1, 6)
+        if (moved > 0) u.uint_dc(moved)
+        u.uint_dc((v < 0 ? -1 : 1) * v * Math.pow(10, moved))
+      }
+    } else if (typeof v === "string") {
+      u.add_dc(0, 1)
+
+      if (v.length === 1) {
+        const charCode = v.charCodeAt(0)
+        const mapValue = strmap[v]
+
+        if (typeof mapValue !== "undefined") {
+          u.add_dc(mapValue + 9, 6)
+        } else {
+          u.add_dc(61, 6)
+          u.leb128_2_dc(charCode)
+        }
+      } else {
+        let is64 = true
+        for (let i = 0; i < v.length; i++) {
+          if (typeof base64[v[i]] === "undefined") {
+            is64 = false
+            break
           }
-        } 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 (is64) {
+          u.add_dc(62, 6)
+          u.short_dc(v.length)
+          for (let i = 0; i < v.length; i++) {
+            u.add_dc(base64[v[i]], 6)
           }
-          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)}`
+        } else {
+          u.add_dc(63, 6)
+          u.short_dc(v.length)
+          for (let i = 0; i < v.length; i++) {
+            u.leb128_2_dc(v.charCodeAt(i))
           }
         }
       }
-      len2 = 0
-      str2 = ""
     }
-    len2 += v.length
-    str2 += v
+  } else if (Array.isArray(v) && v.length === 0) {
+    u.add_dc(1, 1)
+    u.add_dc(4, 7)
+  } else if (Object.keys(v).length === 0) {
+    u.add_dc(1, 1)
+    u.add_dc(5, 7)
+  } else {
+    u.single = false
+    u.push_type(_encode_x(v, u))
   }
-  if (str2 != "") arrs2.push("1" + str2)
-  return arrs2
-}
-
-function fromSignal(arr) {
-  let _arr = []
-  let prev = ""
-  for (let s of arr) {
-    s = s.slice(1)
-    let str = s.split("")
-    while (str.length > 0) {
-      const len = +str.shift()
-      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)
+  return u.dump()
+}
+
+function getPrecision(v) {
+  const s = v.toString()
+  const dot = s.indexOf(".")
+  if (dot === -1) return 0
+  const frac = s.slice(dot + 1).replace(/0+$/, "")
+  return frac.length
+}
+
+function _encode_x(
+  v,
+  u,
+  plen = 0,
+  prev = null,
+  prev_type = null,
+  index = null,
+) {
+  if (typeof v === "number") {
+    if (prev !== null) u.push_vlink(prev + 1)
+
+    const moved = v % 1 === v ? 0 : getPrecision(v)
+    const type = moved === 0 ? (v < 0 ? 5 : 4) : 6
+
+    if (prev_type !== null && prev_type !== 4) u.push_type(prev_type)
+    else u.tcount++
+    if (moved > 0) {
+      u.push_float(v < 0, moved + 1)
+      if (moved > 2) u.push_int(moved + 1)
+    }
+    u.push_int((v < 0 ? -1 : 1) * v * Math.pow(10, moved))
+    return type
+  } else if (typeof v === "boolean") {
+    if (prev !== null) u.push_vlink(prev + 1)
+    const type = 3
+    if (prev_type !== null && prev_type !== type) u.push_type(prev_type)
+    else u.tcount++
+    u.push_bool(v)
+    return type
+  } else if (v === null) {
+    if (prev !== null) u.push_vlink(prev + 1)
+    if (prev_type !== null && prev_type !== 1) u.push_type(prev_type)
+    else u.tcount++
+    return 1
+  } else if (typeof v === "string") {
+    let ktype = 7
+    if (prev !== null) u.push_vlink(prev + 1)
+    if (u.strMap.has(v)) {
+      ktype = 2
+      u.push_type(prev_type)
+      u.short_vals(0)
+      u.short_vals(u.strMap.get(v))
+    } else {
+      u.strMap.set(v, u.str_len++)
+      const len = v.length
+      u.short_vals(len)
+      let codes = []
+      let codes2 = []
+      let is64 = true
+      if (len === 0) {
+        is64 = false
       } else {
-        const nums = str.slice(0, len).join("")
-        str = str.slice(len)
-        _arr.push(+(prev + nums))
-        prev = ""
+        for (let i = 0; i < len; i++) {
+          codes2.push(v.charCodeAt(i))
+          const c = base64[v[i]]
+          if (typeof c === "undefined") is64 = false
+          else codes.push(c)
+        }
+        if (is64) ktype = 2
       }
-    }
-  }
-  return _arr
-}
-
-const path = p => toSignal(encodePath(p))
-const val = v => toSignal(encodeVal(v))
-const query = v => toSignal(encodeQuery(v))
+      if (prev_type !== null && prev_type !== ktype) u.push_type(prev_type)
+      else u.tcount++
 
-function encodeQuery(v) {
-  if (!Array.isArray(v)) throw Error("query must be an array")
-  const op = v[0]
-  if (isNil(ops[op])) throw Error(`query not supported: ${op}`)
-  return [ops[op], ...encodeVal(v[1])]
-}
-
-function decodeQuery(v) {
-  const op = opMap[v[0]]
-  if (isNil(op)) throw Error("op doens't exist")
-  return [op, decodeVal(v.slice(1))]
-}
-
-function toUint8(sig) {
-  let num = BigInt(sig)
-  let byteArray = []
-  while (num > 0) {
-    byteArray.push(Number(num % 256n))
-    num /= 256n
+      if (is64) for (let v of codes) u.add_vals(v, 6)
+      else for (let v of codes2) u.leb128_2_vals(v)
+    }
+    return ktype
+  } else if (Array.isArray(v)) {
+    if (v.length === 0) {
+      if (prev !== null) u.push_vlink(prev + 1)
+      u.push_type(prev_type)
+      u.push_float(false, 1)
+      return 6
+    } else {
+      const _prev = u.dcount
+      pushPathNum(u, prev, 0)
+      let i = 0
+      for (const v2 of v) {
+        prev_type = _encode_x(v2, u, plen + 1, _prev, prev_type, i)
+        i++
+      }
+    }
+    return prev_type
+  } else if (typeof v === "object") {
+    if (Object.keys(v).length === 0) {
+      if (prev !== null) u.push_vlink(prev + 1)
+      u.push_type(prev_type)
+      u.push_float(true, 1)
+      return 6
+    } else {
+      pushPathNum(u, prev, 1)
+      const __prev = u.dcount
+      for (const k in v) {
+        const _prev = u.dcount
+        pushPathStr(u, k, __prev - 1)
+        prev_type = _encode_x(v[k], u, plen + 1, _prev, prev_type)
+      }
+      return prev_type
+    }
   }
-  return new Uint8Array(byteArray.reverse())
-}
-function compress(arr) {
-  let sig = toSignal(arr, false)
-  return toUint8(sig)
-}
-
-function decompress(arr) {
-  const str = fromUint8(arr)
-  return fromSignal([str])
 }
 
-function fromUint8(arr) {
-  let num = 0n
-  for (let byte of arr) {
-    num = num * 256n + BigInt(byte)
-  }
-  return num.toString()
+function decode_x(v, d) {
+  d.decode(v)
+  return d.json
 }
 
-module.exports = {
-  encode,
-  decode,
-  encodePath,
-  decodePath,
-  encodeVal,
-  decodeVal,
-  pad,
-  _encode,
-  flattenPath,
-  toSignal,
-  fromSignal,
-  toIndex,
-  fromIndex,
-  path,
-  val,
-  query,
-  encodeQuery,
-  decodeQuery,
-  compress,
-  decompress,
-  toUint8,
-  fromUint8,
-}
+module.exports = { encode_x, decode_x, u8 }