@fireproof/vendor 0.0.0-smoke

package/patched/cborg/bench/json.js

@@ -0,0 +1,124 @@
+// can be run in a browser with `polendina --runner=bare-sync --timeout 6000 --cleanup bench.js`
+// with additional dependencies for cborg installed here
+
+import assert from 'assert'
+import { garbage } from 'ipld-garbage'
+import { decode, encode } from '../lib/json/json.js'
+
+let writebuf = ''
+const write = process.stdout
+  ? process.stdout.write.bind(process.stdout)
+  : (str) => {
+      writebuf += str
+      if (str.endsWith('\n')) {
+        console.log(writebuf.replace(/\n$/, ''))
+        writebuf = ''
+      }
+    }
+
+const textEncoder = new TextEncoder()
+const textDecoder = new TextDecoder()
+
+function jencode (obj) {
+  return textEncoder.encode(JSON.stringify(obj))
+}
+
+function jdecode (buf) {
+  return JSON.parse(textDecoder.decode(buf))
+}
+
+function runWith (description, count, targetTime, size, options) {
+  const fixtures = []
+
+  console.log(`${description} @ ${count.toLocaleString()}`)
+  for (let i = 0; i < count; i++) {
+    const obj = garbage(size, options)
+    const cbyts = encode(obj)
+    /*
+    const jbyts = jencode(obj)
+    if (Buffer.compare(Buffer.from(cbyts), jbyts) !== 0) {
+      console.log(`mismatch for obj: ${JSON.stringify(obj)}`)
+      console.log('\tc> ', Buffer.from(cbyts).toString('utf8'))
+      console.log('\tj> ', Buffer.from(jbyts).toString('utf8'))
+    }
+    */
+    if (cbyts.length <= size * 2) {
+      fixtures.push([obj, cbyts])
+    }
+  }
+  const avgSize = Math.round(fixtures.reduce((p, c) => p + c[1].length, 0) / fixtures.length)
+
+  const enc = (encoder) => {
+    for (const [obj, byts] of fixtures) {
+      const ebyts = encoder(obj)
+      if (byts.length !== ebyts.length) {
+        throw new Error('bork')
+      }
+    }
+    return fixtures.length
+  }
+
+  const bench = (bfn) => {
+    const start = Date.now()
+    let opcount = 0
+    do {
+      opcount += bfn()
+    } while (Date.now() - start < targetTime)
+    const ops = Math.round(opcount / ((Date.now() - start) / 1000))
+    return ops
+  }
+
+  const dec = (decoder) => {
+    for (const [obj, byts] of fixtures) {
+      let cobj
+      try {
+        cobj = decoder(byts)
+      } catch (e) {
+        console.log('Failed to decode:', Buffer.from(byts).toString('utf8'))
+        throw e
+      }
+      if (obj != null && typeof obj === 'object') {
+        assert.deepStrictEqual(Object.keys(cobj).length, Object.keys(obj).length)
+      } else {
+        assert.deepStrictEqual(obj, cobj)
+      }
+    }
+    return fixtures.length
+  }
+
+  const cmp = (desc, cbfn, bofn) => {
+    write(`\t${desc} (avg ${avgSize.toLocaleString()} b):`)
+    const cborgOps = bench(cbfn)
+    write(` cborg @ ${cborgOps.toLocaleString()} op/s`)
+    const jOps = bench(bofn)
+    write(` / JSON @ ${jOps.toLocaleString()} op/s`)
+    const percent = Math.round((cborgOps / jOps) * 1000) / 10
+    write(` = ${(percent).toLocaleString()} %\n`)
+    return percent
+  }
+
+  return [
+    cmp('encode', () => enc(encode), () => enc(jencode)),
+    cmp('decode', () => dec(decode), () => dec(jdecode))
+  ]
+}
+
+const targetTime = 1000
+const accum = []
+accum.push(runWith('rnd-100', 1000, targetTime, 100, { weights: { CID: 0, bytes: 0 } }))
+accum.push(runWith('rnd-300', 1000, targetTime, 300, { weights: { CID: 0, bytes: 0 } }))
+accum.push(runWith('rnd-nomap-300', 1000, targetTime, 300, { weights: { CID: 0, bytes: 0, map: 0 } }))
+accum.push(runWith('rnd-nolist-300', 1000, targetTime, 300, { weights: { CID: 0, bytes: 0, list: 0 } }))
+accum.push(runWith('rnd-nofloat-300', 1000, targetTime, 300, { weights: { CID: 0, bytes: 0, float: 0 } }))
+accum.push(runWith('rnd-nomaj7-300', 1000, targetTime, 300, { weights: { CID: 0, bytes: 0, float: 0, null: 0, boolean: 0 } }))
+accum.push(runWith('rnd-nostr-300', 1000, targetTime, 300, { weights: { CID: 0, bytes: 0, string: 0 } }))
+accum.push(runWith('rnd-nostrbyts-300', 1000, targetTime, 300, { weights: { CID: 0, bytes: 0, string: 0 } }))
+accum.push(runWith('rnd-1000', 1000, targetTime, 1000, { weights: { CID: 0, bytes: 0 } }))
+accum.push(runWith('rnd-2000', 1000, targetTime, 2000, { weights: { CID: 0, bytes: 0 } }))
+accum.push(runWith('rnd-fil-100', 1000, targetTime, 100, { weights: { float: 0, map: 0, CID: 0, bytes: 0 } }))
+accum.push(runWith('rnd-fil-300', 1000, targetTime, 300, { weights: { float: 0, map: 0, CID: 0, bytes: 0 } }))
+accum.push(runWith('rnd-fil-500', 1000, targetTime, 500, { weights: { float: 0, map: 0, CID: 0, bytes: 0 } }))
+accum.push(runWith('rnd-fil-1000', 1000, targetTime, 1000, { weights: { float: 0, map: 0, CID: 0, bytes: 0 } }))
+accum.push(runWith('rnd-fil-2000', 1000, targetTime, 2000, { weights: { float: 0, map: 0, CID: 0, bytes: 0 } }))
+console.log(`Avg encode: ${Math.round(accum.reduce((p, c) => p + c[0], 0) / accum.length).toLocaleString()} %`)
+console.log(`Avg decode: ${Math.round(accum.reduce((p, c) => p + c[1], 0) / accum.length).toLocaleString()} %`)

package/patched/cborg/bench/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "cborg-bench",
+  "type": "module",
+  "dependencies": {
+    "borc": "^2.1.2",
+    "ipld-garbage": "^3.0.3"
+  }
+}

package/patched/cborg/cborg.js

@@ -0,0 +1,31 @@
+import { encode } from './lib/encode.js'
+import { decode, decodeFirst, Tokeniser, tokensToObject } from './lib/decode.js'
+import { Token, Type } from './lib/token.js'
+
+// is this needed for the json module and other independ encoders
+export { encodeCustom } from './lib/encode.js'
+export { encodeErrPrefix, decodeErrPrefix } from './lib/common.js'
+export { asU8A, fromString, decodeCodePointsArray } from './lib/byte-utils.js'
+
+/**
+ * Export the types that were present in the original manual cborg.d.ts
+ * @typedef {import('./interface').TagDecoder} TagDecoder
+ * There was originally just `TypeEncoder` so don't break types by renaming or not exporting
+ * @typedef {import('./interface').OptionalTypeEncoder} TypeEncoder
+ * @typedef {import('./interface').DecodeOptions} DecodeOptions
+ * @typedef {import('./interface').EncodeOptions} EncodeOptions
+ */
+
+export {
+  // this is needed to prevent the bundleing trouble which happens
+  // due to the fact that token.js is used in lib/json and so in
+  // cborg/json which ends up on bundling to have two copies of token.js
+  // which will fail stmts like token.type === Type.array
+  decode,
+  decodeFirst,
+  Tokeniser as Tokenizer,
+  tokensToObject,
+  encode,
+  Token,
+  Type
+}

package/patched/cborg/example-bytestrings.js

@@ -0,0 +1,180 @@
+/*
+RFC 8746 defines a set of tags to use for typed arrays. Out of the box, cborg doesn't care about
+tags and just squashes all concerns around byte arrays to Uint8Array with major type 2. This is
+fine for most use cases, but it is lossy, you can't round-trip and retain your original type.
+
+This example shows how to use cborg to round-trip a typed array with tags.
+
+https://www.rfc-editor.org/rfc/rfc8746.html
+*/
+
+import { encode, decode, Token, Tokenizer, Type } from 'cborg.js'
+
+const tagUint8Array = 64
+const tagUint64Array = 71
+// etc... see https://www.rfc-editor.org/rfc/rfc8746.html#name-iana-considerations
+
+/* ENCODERS */
+
+/**
+ * @param {any} obj
+ * @returns {[Token]}
+ */
+function uint8ArrayEncoder (obj) {
+  if (!(obj instanceof Uint8Array)) {
+    throw new Error('expected Uint8Array')
+  }
+  return [
+    new Token(Type.tag, tagUint8Array),
+    new Token(Type.bytes, obj)
+  ]
+}
+
+/**
+ * @param {any} obj
+ * @returns {[Token]}
+ */
+function uint64ArrayEncoder (obj) {
+  if (!(obj instanceof BigUint64Array)) {
+    throw new Error('expected BigUint64Array')
+  }
+  return [
+    new Token(Type.tag, tagUint64Array),
+    // BigUint64Array to a Uint8Array, but we have to pay attention to the possibility of it being
+    // a view of a larger ArrayBuffer.
+    new Token(Type.bytes, new Uint8Array(obj.buffer, obj.byteOffset, obj.byteLength))
+  ]
+}
+
+// etc...
+
+const typeEncoders = {
+  Uint8Array: uint8ArrayEncoder,
+  BigUint64Array: uint64ArrayEncoder
+}
+
+/* DECODERS */
+
+/**
+ * @param {ArrayBuffer} bytes
+ * @returns {any}
+ */
+function uint8ArrayDecoder (bytes) {
+  if (!(bytes instanceof ArrayBuffer)) {
+    throw new Error('expected ArrayBuffer')
+  }
+  return new Uint8Array(bytes)
+}
+
+/**
+ * @param {ArrayBuffer} bytes
+ * @returns {any}
+ */
+function uint64ArrayDecoder (bytes) {
+  if (!(bytes instanceof ArrayBuffer)) {
+    throw new Error('expected ArrayBuffer')
+  }
+  return new BigUint64Array(bytes)
+}
+
+// etc...
+
+const tags = []
+tags[tagUint8Array] = uint8ArrayDecoder
+tags[tagUint64Array] = uint64ArrayDecoder
+
+/* TOKENIZER */
+
+// We have to deal with the fact that cborg talks in Uint8Arrays but we now want it to treat major 2
+// as ArrayBuffers, so we have to transform the token stream to replace the Uint8Array with an
+// ArrayBuffer.
+
+class ArrayBufferTransformingTokeniser extends Tokenizer {
+  next () {
+    const nextToken = super.next()
+    if (nextToken.type.equals(Type.bytes)) {
+      // Transform the (assumed) Uint8Array value to an ArrayBuffer of the same bytes, note though
+      // that all tags we care about are going to be <tag><bytes>, so we're also transforming those
+      // into ArrayBuffers, so our tag decoders need to also assume they are getting ArrayBuffers
+      // now. An alternative would be to watch the token stream for <tag> and not transform the next
+      // token if it's <bytes>, but that's a bit more complicated for demo purposes.
+      nextToken.value = nextToken.value.buffer
+    }
+    return nextToken
+  }
+}
+
+// Optional: a new decode() wrapper, mainly so we don't have to deal with the complications of\
+// instantiating a Tokenizer which needs both data and the options.
+function byteStringDecoder (data, options) {
+  options = Object.assign({}, options, {
+    tags,
+    tokenizer: new ArrayBufferTransformingTokeniser(data, options)
+  })
+  return decode(data, options)
+}
+
+/* ROUND-TRIP */
+
+const original = {
+  u8: new Uint8Array([1, 2, 3, 4, 5]),
+  u64: new BigUint64Array([10000000000000000n, 20000000000000000n, 30000000000000000n, 40000000000000000n, 50000000000000000n]),
+  ab: new Uint8Array([6, 7, 8, 9, 10]).buffer
+}
+
+const encoded = encode(original, { typeEncoders })
+
+const decoded = byteStringDecoder(encoded)
+
+console.log('Original:', original)
+console.log('Encoded:', Buffer.from(encoded).toString('hex')) // excuse the Buffer, sorry browser peeps
+console.log('Decoded:', decoded)
+
+/* Output:
+
+Original: {
+  u8: Uint8Array(5) [ 1, 2, 3, 4, 5 ],
+  u64: BigUint64Array(5) [
+    10000000000000000n,
+    20000000000000000n,
+    30000000000000000n,
+    40000000000000000n,
+    50000000000000000n
+  ],
+  ab: ArrayBuffer { [Uint8Contents]: <06 07 08 09 0a>, byteLength: 5 }
+}
+Encoded: a362616245060708090a627538d84045010203040563753634d84758280000c16ff2862300000082dfe40d47000000434fd7946a00000004bfc91b8e000000c52ebca2b100
+Decoded: {
+  ab: ArrayBuffer { [Uint8Contents]: <06 07 08 09 0a>, byteLength: 5 },
+  u8: Uint8Array(5) [ 1, 2, 3, 4, 5 ],
+  u64: BigUint64Array(5) [
+    10000000000000000n,
+    20000000000000000n,
+    30000000000000000n,
+    40000000000000000n,
+    50000000000000000n
+  ]
+}
+
+*/
+
+/* Diagnostic:
+
+$ cborg hex2diag a362616245060708090a627538d84045010203040563753634d84758280000c16ff2862300000082dfe40d47000000434fd7946a00000004bfc91b8e000000c52ebca2b100
+a3                                                # map(3)
+  62                                              #   string(2)
+    6162                                          #     "ab"
+  45                                              #   bytes(5)
+    060708090a                                    #     "\x06\x07\x08\x09\x0a"
+  62                                              #   string(2)
+    7538                                          #     "u8"
+  d8 40                                           #   tag(64)
+    45                                            #     bytes(5)
+      0102030405                                  #       "\x01\x02\x03\x04\x05"
+  63                                              #   string(3)
+    753634                                        #     "u64"
+  d8 47                                           #   tag(71)
+    58 28                                         #     bytes(40)
+      0000c16ff2862300000082dfe40d47000000434fd7  #       "\x00\x00Áoò\x86#\x00\x00\x00\x82ßä\x0dG\x00\x00\x00CO×"
+      946a00000004bfc91b8e000000c52ebca2b100      #       "\x94j\x00\x00\x00\x04¿É\x1b\x8e\x00\x00\x00Å.¼¢±\x00
+*/

package/patched/cborg/example-json.js

@@ -0,0 +1,6 @@
+import { encode, decode } from 'cborg/json'
+
+const decoded = decode(Buffer.from('7b2274686973223a7b226973223a224a534f4e21222c22796179223a747275657d7d', 'hex'))
+console.log('decoded:', decoded)
+console.log('encoded:', encode(decoded))
+console.log('encoded (string):', Buffer.from(encode(decoded)).toString())

package/patched/cborg/example.js

@@ -0,0 +1,5 @@
+import { encode, decode } from 'cborg'
+
+const decoded = decode(Buffer.from('a16474686973a26269736543424f522163796179f5', 'hex'))
+console.log('decoded:', decoded)
+console.log('encoded:', encode(decoded))

package/patched/cborg/interface.ts

@@ -0,0 +1,56 @@
+import { Token } from './lib/token'
+import { Bl } from './lib/bl'
+
+export type TokenOrNestedTokens = Token | Token[] | TokenOrNestedTokens[]
+
+export interface Reference {
+  parent: Reference | undefined
+  obj: object | any[]
+  includes(obj: object | any[]): boolean
+}
+
+export type OptionalTypeEncoder = (data: any, typ: string, options: EncodeOptions, refStack?: Reference) => TokenOrNestedTokens | null
+
+export type StrictTypeEncoder = (data: any, typ: string, options: EncodeOptions, refStack?: Reference) => TokenOrNestedTokens
+
+export type TokenTypeEncoder = {
+  (buf: Bl, token: Token, options?: EncodeOptions): void;
+  compareTokens(t1: Token, t2: Token): number;
+  // TODO: make this non-optional as a breaking change and remove the throw in length.js
+  encodedSize?(token: Token, options?: EncodeOptions): number;
+}
+
+export type MapSorter = (e1: (Token | Token[])[], e2: (Token | Token[])[]) => number
+
+export type QuickEncodeToken = (token: Token) => Uint8Array | undefined
+
+export interface DecodeTokenizer {
+  done(): boolean,
+  next(): Token,
+  pos(): number,
+}
+
+export type TagDecoder = (inner: any) => any
+
+export interface DecodeOptions {
+  allowIndefinite?: boolean
+  allowUndefined?: boolean
+  coerceUndefinedToNull?: boolean
+  allowInfinity?: boolean
+  allowNaN?: boolean
+  allowBigInt?: boolean
+  strict?: boolean
+  useMaps?: boolean
+  rejectDuplicateMapKeys?: boolean
+  retainStringBytes?: boolean
+  tags?: TagDecoder[],
+  tokenizer?: DecodeTokenizer
+}
+
+export interface EncodeOptions {
+  float64?: boolean,
+  addBreakTokens?: boolean,
+  mapSorter?: MapSorter,
+  quickEncodeToken?: QuickEncodeToken,
+  typeEncoders?: { [typeName: string]: OptionalTypeEncoder }
+}

package/patched/cborg/lib/0uint.js

@@ -0,0 +1,227 @@
+/* globals BigInt */
+
+import { Token, Type } from './token.js'
+import { decodeErrPrefix, assertEnoughData } from './common.js'
+
+export const uintBoundaries = [24, 256, 65536, 4294967296, BigInt('18446744073709551616')]
+
+/**
+ * @typedef {import('./bl.js').Bl} Bl
+ * @typedef {import('../interface').DecodeOptions} DecodeOptions
+ */
+
+/**
+ * @param {Uint8Array} data
+ * @param {number} offset
+ * @param {DecodeOptions} options
+ * @returns {number}
+ */
+export function readUint8 (data, offset, options) {
+  assertEnoughData(data, offset, 1)
+  const value = data[offset]
+  if (options.strict === true && value < uintBoundaries[0]) {
+    throw new Error(`${decodeErrPrefix} integer encoded in more bytes than necessary (strict decode)`)
+  }
+  return value
+}
+
+/**
+ * @param {Uint8Array} data
+ * @param {number} offset
+ * @param {DecodeOptions} options
+ * @returns {number}
+ */
+export function readUint16 (data, offset, options) {
+  assertEnoughData(data, offset, 2)
+  const value = (data[offset] << 8) | data[offset + 1]
+  if (options.strict === true && value < uintBoundaries[1]) {
+    throw new Error(`${decodeErrPrefix} integer encoded in more bytes than necessary (strict decode)`)
+  }
+  return value
+}
+
+/**
+ * @param {Uint8Array} data
+ * @param {number} offset
+ * @param {DecodeOptions} options
+ * @returns {number}
+ */
+export function readUint32 (data, offset, options) {
+  assertEnoughData(data, offset, 4)
+  const value = (data[offset] * 16777216 /* 2 ** 24 */) + (data[offset + 1] << 16) + (data[offset + 2] << 8) + data[offset + 3]
+  if (options.strict === true && value < uintBoundaries[2]) {
+    throw new Error(`${decodeErrPrefix} integer encoded in more bytes than necessary (strict decode)`)
+  }
+  return value
+}
+
+/**
+ * @param {Uint8Array} data
+ * @param {number} offset
+ * @param {DecodeOptions} options
+ * @returns {number|bigint}
+ */
+export function readUint64 (data, offset, options) {
+  // assume BigInt, convert back to Number if within safe range
+  assertEnoughData(data, offset, 8)
+  const hi = (data[offset] * 16777216 /* 2 ** 24 */) + (data[offset + 1] << 16) + (data[offset + 2] << 8) + data[offset + 3]
+  const lo = (data[offset + 4] * 16777216 /* 2 ** 24 */) + (data[offset + 5] << 16) + (data[offset + 6] << 8) + data[offset + 7]
+  const value = (BigInt(hi) << BigInt(32)) + BigInt(lo)
+  if (options.strict === true && value < uintBoundaries[3]) {
+    throw new Error(`${decodeErrPrefix} integer encoded in more bytes than necessary (strict decode)`)
+  }
+  if (value <= Number.MAX_SAFE_INTEGER) {
+    return Number(value)
+  }
+  if (options.allowBigInt === true) {
+    return value
+  }
+  throw new Error(`${decodeErrPrefix} integers outside of the safe integer range are not supported`)
+}
+
+/* not required thanks to quick[] list
+const oneByteTokens = new Array(24).fill(0).map((v, i) => new Token(Type.uint, i, 1))
+export function decodeUintCompact (data, pos, minor, options) {
+  return oneByteTokens[minor]
+}
+*/
+
+/**
+ * @param {Uint8Array} data
+ * @param {number} pos
+ * @param {number} _minor
+ * @param {DecodeOptions} options
+ * @returns {Token}
+ */
+export function decodeUint8 (data, pos, _minor, options) {
+  return new Token(Type.uint, readUint8(data, pos + 1, options), 2)
+}
+
+/**
+ * @param {Uint8Array} data
+ * @param {number} pos
+ * @param {number} _minor
+ * @param {DecodeOptions} options
+ * @returns {Token}
+ */
+export function decodeUint16 (data, pos, _minor, options) {
+  return new Token(Type.uint, readUint16(data, pos + 1, options), 3)
+}
+
+/**
+ * @param {Uint8Array} data
+ * @param {number} pos
+ * @param {number} _minor
+ * @param {DecodeOptions} options
+ * @returns {Token}
+ */
+export function decodeUint32 (data, pos, _minor, options) {
+  return new Token(Type.uint, readUint32(data, pos + 1, options), 5)
+}
+
+/**
+ * @param {Uint8Array} data
+ * @param {number} pos
+ * @param {number} _minor
+ * @param {DecodeOptions} options
+ * @returns {Token}
+ */
+export function decodeUint64 (data, pos, _minor, options) {
+  return new Token(Type.uint, readUint64(data, pos + 1, options), 9)
+}
+
+/**
+ * @param {Bl} buf
+ * @param {Token} token
+ */
+export function encodeUint (buf, token) {
+  return encodeUintValue(buf, 0, token.value)
+}
+
+/**
+ * @param {Bl} buf
+ * @param {number} major
+ * @param {number|bigint} uint
+ */
+export function encodeUintValue (buf, major, uint) {
+  if (uint < uintBoundaries[0]) {
+    const nuint = Number(uint)
+    // pack into one byte, minor=0, additional=value
+    buf.push([major | nuint])
+  } else if (uint < uintBoundaries[1]) {
+    const nuint = Number(uint)
+    // pack into two byte, minor=0, additional=24
+    buf.push([major | 24, nuint])
+  } else if (uint < uintBoundaries[2]) {
+    const nuint = Number(uint)
+    // pack into three byte, minor=0, additional=25
+    buf.push([major | 25, nuint >>> 8, nuint & 0xff])
+  } else if (uint < uintBoundaries[3]) {
+    const nuint = Number(uint)
+    // pack into five byte, minor=0, additional=26
+    buf.push([major | 26, (nuint >>> 24) & 0xff, (nuint >>> 16) & 0xff, (nuint >>> 8) & 0xff, nuint & 0xff])
+  } else {
+    const buint = BigInt(uint)
+    if (buint < uintBoundaries[4]) {
+      // pack into nine byte, minor=0, additional=27
+      const set = [major | 27, 0, 0, 0, 0, 0, 0, 0]
+      // simulate bitwise above 32 bits
+      let lo = Number(buint & BigInt(0xffffffff))
+      let hi = Number(buint >> BigInt(32) & BigInt(0xffffffff))
+      set[8] = lo & 0xff
+      lo = lo >> 8
+      set[7] = lo & 0xff
+      lo = lo >> 8
+      set[6] = lo & 0xff
+      lo = lo >> 8
+      set[5] = lo & 0xff
+      set[4] = hi & 0xff
+      hi = hi >> 8
+      set[3] = hi & 0xff
+      hi = hi >> 8
+      set[2] = hi & 0xff
+      hi = hi >> 8
+      set[1] = hi & 0xff
+      buf.push(set)
+    } else {
+      throw new Error(`${decodeErrPrefix} encountered BigInt larger than allowable range`)
+    }
+  }
+}
+
+/**
+ * @param {Token} token
+ * @returns {number}
+ */
+encodeUint.encodedSize = function encodedSize (token) {
+  return encodeUintValue.encodedSize(token.value)
+}
+
+/**
+ * @param {number} uint
+ * @returns {number}
+ */
+encodeUintValue.encodedSize = function encodedSize (uint) {
+  if (uint < uintBoundaries[0]) {
+    return 1
+  }
+  if (uint < uintBoundaries[1]) {
+    return 2
+  }
+  if (uint < uintBoundaries[2]) {
+    return 3
+  }
+  if (uint < uintBoundaries[3]) {
+    return 5
+  }
+  return 9
+}
+
+/**
+ * @param {Token} tok1
+ * @param {Token} tok2
+ * @returns {number}
+ */
+encodeUint.compareTokens = function compareTokens (tok1, tok2) {
+  return tok1.value < tok2.value ? -1 : tok1.value > tok2.value ? 1 : /* c8 ignore next */ 0
+}