@fireproof/vendor 1.1.0 → 1.2.0

package/src/cborg/utils/byte-utils.js

@@ -0,0 +1,417 @@
+// Use Uint8Array directly in the browser, use Buffer in Node.js but don't
+// speak its name directly to avoid bundlers pulling in the `Buffer` polyfill
+
+// @ts-ignore
+export const useBuffer = globalThis.process &&
+  // @ts-ignore
+  !globalThis.process.browser &&
+  // @ts-ignore
+  globalThis.Buffer &&
+  // @ts-ignore
+  typeof globalThis.Buffer.isBuffer === 'function'
+
+const textDecoder = new TextDecoder()
+const textEncoder = new TextEncoder()
+
+/**
+ * @param {Uint8Array} buf
+ * @returns {boolean}
+ */
+function isBuffer (buf) {
+  // @ts-ignore
+  return useBuffer && globalThis.Buffer.isBuffer(buf)
+}
+
+/**
+ * @param {Uint8Array|number[]} buf
+ * @returns {Uint8Array}
+ */
+export function asU8A (buf) {
+  /* c8 ignore next */
+  if (!(buf instanceof Uint8Array)) {
+    return Uint8Array.from(buf)
+  }
+  return isBuffer(buf) ? new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength) : buf
+}
+
+export const toString = useBuffer
+  ? // eslint-disable-line operator-linebreak
+    /**
+     * @param {Uint8Array} bytes
+     * @param {number} start
+     * @param {number} end
+     */
+    (bytes, start, end) => {
+      return end - start > 64
+        ? // eslint-disable-line operator-linebreak
+      // @ts-ignore
+        globalThis.Buffer.from(bytes.subarray(start, end)).toString('utf8')
+        : utf8Slice(bytes, start, end)
+    }
+  /* c8 ignore next 11 */
+  : // eslint-disable-line operator-linebreak
+    /**
+     * @param {Uint8Array} bytes
+     * @param {number} start
+     * @param {number} end
+     */
+    (bytes, start, end) => {
+      return end - start > 64
+        ? textDecoder.decode(bytes.subarray(start, end))
+        : utf8Slice(bytes, start, end)
+    }
+
+export const fromString = useBuffer
+  ? // eslint-disable-line operator-linebreak
+    /**
+     * @param {string} string
+     */
+    (string) => {
+      return string.length > 64
+        ? // eslint-disable-line operator-linebreak
+      // @ts-ignore
+        globalThis.Buffer.from(string)
+        : utf8ToBytes(string)
+    }
+  /* c8 ignore next 7 */
+  : // eslint-disable-line operator-linebreak
+    /**
+     * @param {string} string
+     */
+    (string) => {
+      return string.length > 64 ? textEncoder.encode(string) : utf8ToBytes(string)
+    }
+
+/**
+ * Buffer variant not fast enough for what we need
+ * @param {number[]} arr
+ * @returns {Uint8Array}
+ */
+export const fromArray = (arr) => {
+  return Uint8Array.from(arr)
+}
+
+export const slice = useBuffer
+  ? // eslint-disable-line operator-linebreak
+    /**
+     * @param {Uint8Array} bytes
+     * @param {number} start
+     * @param {number} end
+     */
+    (bytes, start, end) => {
+      if (isBuffer(bytes)) {
+        return new Uint8Array(bytes.subarray(start, end))
+      }
+      return bytes.slice(start, end)
+    }
+  /* c8 ignore next 9 */
+  : // eslint-disable-line operator-linebreak
+    /**
+     * @param {Uint8Array} bytes
+     * @param {number} start
+     * @param {number} end
+     */
+    (bytes, start, end) => {
+      return bytes.slice(start, end)
+    }
+
+export const concat = useBuffer
+  ? // eslint-disable-line operator-linebreak
+    /**
+     * @param {Uint8Array[]} chunks
+     * @param {number} length
+     * @returns {Uint8Array}
+     */
+    (chunks, length) => {
+      // might get a stray plain Array here
+      /* c8 ignore next 1 */
+      chunks = chunks.map((c) => c instanceof Uint8Array
+        ? c
+        // this case is occasionally missed during test runs so becomes coverage-flaky
+        /* c8 ignore next 4 */
+        : // eslint-disable-line operator-linebreak
+        // @ts-ignore
+        globalThis.Buffer.from(c))
+      // @ts-ignore
+      return asU8A(globalThis.Buffer.concat(chunks, length))
+    }
+  /* c8 ignore next 19 */
+  : // eslint-disable-line operator-linebreak
+    /**
+     * @param {Uint8Array[]} chunks
+     * @param {number} length
+     * @returns {Uint8Array}
+     */
+    (chunks, length) => {
+      const out = new Uint8Array(length)
+      let off = 0
+      for (let b of chunks) {
+        if (off + b.length > out.length) {
+          // final chunk that's bigger than we need
+          b = b.subarray(0, out.length - off)
+        }
+        out.set(b, off)
+        off += b.length
+      }
+      return out
+    }
+
+export const alloc = useBuffer
+  ? // eslint-disable-line operator-linebreak
+    /**
+     * @param {number} size
+     * @returns {Uint8Array}
+     */
+    (size) => {
+      // we always write over the contents we expose so this should be safe
+      // @ts-ignore
+      return globalThis.Buffer.allocUnsafe(size)
+    }
+  /* c8 ignore next 8 */
+  : // eslint-disable-line operator-linebreak
+    /**
+     * @param {number} size
+     * @returns {Uint8Array}
+     */
+    (size) => {
+      return new Uint8Array(size)
+    }
+
+export const toHex = useBuffer
+  ? // eslint-disable-line operator-linebreak
+    /**
+     * @param {Uint8Array} d
+     * @returns {string}
+     */
+    (d) => {
+      if (typeof d === 'string') {
+        return d
+      }
+      // @ts-ignore
+      return globalThis.Buffer.from(toBytes(d)).toString('hex')
+    }
+  /* c8 ignore next 12 */
+  : // eslint-disable-line operator-linebreak
+    /**
+     * @param {Uint8Array} d
+     * @returns {string}
+     */
+    (d) => {
+      if (typeof d === 'string') {
+        return d
+      }
+      // @ts-ignore not smart enough to figure this out
+      return Array.prototype.reduce.call(toBytes(d), (p, c) => `${p}${c.toString(16).padStart(2, '0')}`, '')
+    }
+
+export const fromHex = useBuffer
+  ? // eslint-disable-line operator-linebreak
+  /**
+   * @param {string|Uint8Array} hex
+   * @returns {Uint8Array}
+   */
+    (hex) => {
+      if (hex instanceof Uint8Array) {
+        return hex
+      }
+      // @ts-ignore
+      return globalThis.Buffer.from(hex, 'hex')
+    }
+  /* c8 ignore next 17 */
+  : // eslint-disable-line operator-linebreak
+  /**
+   * @param {string|Uint8Array} hex
+   * @returns {Uint8Array}
+   */
+    (hex) => {
+      if (hex instanceof Uint8Array) {
+        return hex
+      }
+      if (!hex.length) {
+        return new Uint8Array(0)
+      }
+      return new Uint8Array(hex.split('')
+        .map((/** @type {string} */ c, /** @type {number} */ i, /** @type {string[]} */ d) => i % 2 === 0 ? `0x${c}${d[i + 1]}` : '')
+        .filter(Boolean)
+        .map((/** @type {string} */ e) => parseInt(e, 16)))
+    }
+
+/**
+ * @param {Uint8Array|ArrayBuffer|ArrayBufferView} obj
+ * @returns {Uint8Array}
+ */
+function toBytes (obj) {
+  if (obj instanceof Uint8Array && obj.constructor.name === 'Uint8Array') {
+    return obj
+  }
+  if (obj instanceof ArrayBuffer) {
+    return new Uint8Array(obj)
+  }
+  if (ArrayBuffer.isView(obj)) {
+    return new Uint8Array(obj.buffer, obj.byteOffset, obj.byteLength)
+  }
+  /* c8 ignore next */
+  throw new Error('Unknown type, must be binary type')
+}
+
+/**
+ * @param {Uint8Array} b1
+ * @param {Uint8Array} b2
+ * @returns {number}
+ */
+export function compare (b1, b2) {
+  /* c8 ignore next 5 */
+  if (isBuffer(b1) && isBuffer(b2)) {
+    // probably not possible to get here in the current API
+    // @ts-ignore Buffer
+    return b1.compare(b2)
+  }
+  for (let i = 0; i < b1.length; i++) {
+    if (b1[i] === b2[i]) {
+      continue
+    }
+    return b1[i] < b2[i] ? -1 : 1
+  } /* c8 ignore next 3 */
+  return 0
+}
+
+// The below code is taken from https://github.com/google/closure-library/blob/8598d87242af59aac233270742c8984e2b2bdbe0/closure/goog/crypt/crypt.js#L117-L143
+// Licensed Apache-2.0.
+
+/**
+ * @param {string} str
+ * @returns {number[]}
+ */
+function utf8ToBytes (str) {
+  const out = []
+  let p = 0
+  for (let i = 0; i < str.length; i++) {
+    let c = str.charCodeAt(i)
+    if (c < 128) {
+      out[p++] = c
+    } else if (c < 2048) {
+      out[p++] = (c >> 6) | 192
+      out[p++] = (c & 63) | 128
+    } else if (
+      ((c & 0xFC00) === 0xD800) && (i + 1) < str.length &&
+      ((str.charCodeAt(i + 1) & 0xFC00) === 0xDC00)) {
+      // Surrogate Pair
+      c = 0x10000 + ((c & 0x03FF) << 10) + (str.charCodeAt(++i) & 0x03FF)
+      out[p++] = (c >> 18) | 240
+      out[p++] = ((c >> 12) & 63) | 128
+      out[p++] = ((c >> 6) & 63) | 128
+      out[p++] = (c & 63) | 128
+    } else {
+      out[p++] = (c >> 12) | 224
+      out[p++] = ((c >> 6) & 63) | 128
+      out[p++] = (c & 63) | 128
+    }
+  }
+  return out
+}
+
+// The below code is mostly taken from https://github.com/feross/buffer
+// Licensed MIT. Copyright (c) Feross Aboukhadijeh
+
+/**
+ * @param {Uint8Array} buf
+ * @param {number} offset
+ * @param {number} end
+ * @returns {string}
+ */
+function utf8Slice (buf, offset, end) {
+  const res = []
+
+  while (offset < end) {
+    const firstByte = buf[offset]
+    let codePoint = null
+    let bytesPerSequence = (firstByte > 0xef) ? 4 : (firstByte > 0xdf) ? 3 : (firstByte > 0xbf) ? 2 : 1
+
+    if (offset + bytesPerSequence <= end) {
+      let secondByte, thirdByte, fourthByte, tempCodePoint
+
+      switch (bytesPerSequence) {
+        case 1:
+          if (firstByte < 0x80) {
+            codePoint = firstByte
+          }
+          break
+        case 2:
+          secondByte = buf[offset + 1]
+          if ((secondByte & 0xc0) === 0x80) {
+            tempCodePoint = (firstByte & 0x1f) << 0x6 | (secondByte & 0x3f)
+            if (tempCodePoint > 0x7f) {
+              codePoint = tempCodePoint
+            }
+          }
+          break
+        case 3:
+          secondByte = buf[offset + 1]
+          thirdByte = buf[offset + 2]
+          if ((secondByte & 0xc0) === 0x80 && (thirdByte & 0xc0) === 0x80) {
+            tempCodePoint = (firstByte & 0xf) << 0xc | (secondByte & 0x3f) << 0x6 | (thirdByte & 0x3f)
+            /* c8 ignore next 3 */
+            if (tempCodePoint > 0x7ff && (tempCodePoint < 0xd800 || tempCodePoint > 0xdfff)) {
+              codePoint = tempCodePoint
+            }
+          }
+          break
+        case 4:
+          secondByte = buf[offset + 1]
+          thirdByte = buf[offset + 2]
+          fourthByte = buf[offset + 3]
+          if ((secondByte & 0xc0) === 0x80 && (thirdByte & 0xc0) === 0x80 && (fourthByte & 0xc0) === 0x80) {
+            tempCodePoint = (firstByte & 0xf) << 0x12 | (secondByte & 0x3f) << 0xc | (thirdByte & 0x3f) << 0x6 | (fourthByte & 0x3f)
+            if (tempCodePoint > 0xffff && tempCodePoint < 0x110000) {
+              codePoint = tempCodePoint
+            }
+          }
+      }
+    }
+
+    /* c8 ignore next 5 */
+    if (codePoint === null) {
+      // we did not generate a valid codePoint so insert a
+      // replacement char (U+FFFD) and advance only 1 byte
+      codePoint = 0xfffd
+      bytesPerSequence = 1
+    } else if (codePoint > 0xffff) {
+      // encode to utf16 (surrogate pair dance)
+      codePoint -= 0x10000
+      res.push(codePoint >>> 10 & 0x3ff | 0xd800)
+      codePoint = 0xdc00 | codePoint & 0x3ff
+    }
+
+    res.push(codePoint)
+    offset += bytesPerSequence
+  }
+
+  return decodeCodePointsArray(res)
+}
+
+// Based on http://stackoverflow.com/a/22747272/680742, the browser with
+// the lowest limit is Chrome, with 0x10000 args.
+// We go 1 magnitude less, for safety
+const MAX_ARGUMENTS_LENGTH = 0x1000
+
+/**
+ * @param {number[]} codePoints
+ * @returns {string}
+ */
+export function decodeCodePointsArray (codePoints) {
+  const len = codePoints.length
+  if (len <= MAX_ARGUMENTS_LENGTH) {
+    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
+  }
+  /* c8 ignore next 10 */
+  // Decode in chunks to avoid "call stack size exceeded".
+  let res = ''
+  let i = 0
+  while (i < len) {
+    res += String.fromCharCode.apply(
+      String,
+      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
+    )
+  }
+  return res
+}

package/src/cborg/utils/common.js

@@ -0,0 +1,11 @@
+/**
+ * @param {Uint8Array} data
+ * @param {number} pos
+ * @param {number} need
+ * @param {string} decodeErrPrefix
+ */
+export function assertEnoughData (data, pos, need, decodeErrPrefix) {
+  if (data.length - pos < need) {
+    throw new Error(`${decodeErrPrefix} not enough data for type`)
+  }
+}

package/src/cborg/utils/index.js

@@ -0,0 +1,12 @@
+export * from './byte-utils.js'
+export { encodeUint, uintBoundaries } from './0uint.js'
+export { encodeNegint } from './1negint.js'
+export { encodeBytes } from './2bytes.js'
+export { encodeString } from './3string.js'
+export { encodeArray } from './4array.js'
+export { encodeMap } from './5map.js'
+export { encodeTag } from './6tag.js'
+export { encodeFloat } from './7float.js'
+export { Bl } from './bl.js'
+export { Token, Type } from './token.js'
+export * from './jump.js'

package/src/cborg/utils/jump.js

@@ -0,0 +1,222 @@
+import { Token, Type } from './token.js'
+import * as uint from './0uint.js'
+import * as negint from './1negint.js'
+import * as bytes from './2bytes.js'
+import * as string from './3string.js'
+import * as array from './4array.js'
+import * as map from './5map.js'
+import * as tag from './6tag.js'
+import * as float from './7float.js'
+import { fromArray } from './byte-utils.js'
+
+/**
+ * @typedef {import('../interface.js').DecodeOptions} DecodeOptions
+ * @typedef {import('../interface.js').DecodeFunction} DecodeFunction
+ */
+
+/**
+ * @param {string} decodeErrPrefix
+ * @returns {DecodeFunction}
+ */
+function invalidMinorWithPrefix (decodeErrPrefix) {
+  /**
+   * @param {Uint8Array} data
+   * @param {number} pos
+   * @param {number} minor
+   */
+  return (data, pos, minor) => {
+    throw new Error(`${decodeErrPrefix} encountered invalid minor (${minor}) for major ${data[pos] >>> 5}`)
+  }
+}
+
+/**
+ * @param {string} msg
+ * @param {string} decodeErrPrefix
+ * @returns {()=>any}
+ */
+function errorer (msg, decodeErrPrefix) {
+  return () => { throw new Error(`${decodeErrPrefix} ${msg}`) }
+}
+
+/**
+ * @param {string} decodeErrPrefix
+ * @return {DecodeFunction[]}
+ */
+export function jump (decodeErrPrefix) {
+  const invalidMinor = invalidMinorWithPrefix(decodeErrPrefix)
+  const jump = Array(256).fill(invalidMinor)
+  // unsigned integer, 0x00..0x17 (0..23)
+  // for (let i = 0; i <= 0x17; i++) {
+  // jump[i] = invalidMinor // uint.decodeUintCompact, handled by quick[]
+  // }
+  jump[0x18] = uint.decodeUint8 // unsigned integer, one-byte uint8_t follows
+  jump[0x19] = uint.decodeUint16 // unsigned integer, two-byte uint16_t follows
+  jump[0x1a] = uint.decodeUint32 // unsigned integer, four-byte uint32_t follows
+  jump[0x1b] = uint.decodeUint64 // unsigned integer, eight-byte uint64_t follows
+  // jump[0x1c] = invalidMinor
+  // jump[0x1d] = invalidMinor
+  // jump[0x1e] = invalidMinor
+  // jump[0x1f] = invalidMinor
+  // negative integer, -1-0x00..-1-0x17 (-1..-24)
+  // for (let i = 0x20; i <= 0x37; i++) {
+  // jump[i] = invalidMinor // negintDecode, handled by quick[]
+  // }
+  jump[0x38] = negint.decodeNegint8 // negative integer, -1-n one-byte uint8_t for n follows
+  jump[0x39] = negint.decodeNegint16 // negative integer, -1-n two-byte uint16_t for n follows
+  jump[0x3a] = negint.decodeNegint32 // negative integer, -1-n four-byte uint32_t for follows
+  jump[0x3b] = negint.decodeNegint64 // negative integer, -1-n eight-byte uint64_t for follows
+  // jump[0x3c] = invalidMinor
+  // jump[0x3d] = invalidMinor
+  // jump[0x3e] = invalidMinor
+  // jump[0x3f] = invalidMinor
+  // byte string, 0x00..0x17 bytes follow
+  for (let i = 0x40; i <= 0x57; i++) {
+    jump[i] = bytes.decodeBytesCompact
+  }
+  jump[0x58] = bytes.decodeBytes8 // byte string, one-byte uint8_t for n, and then n bytes follow
+  jump[0x59] = bytes.decodeBytes16 // byte string, two-byte uint16_t for n, and then n bytes follow
+  jump[0x5a] = bytes.decodeBytes32 // byte string, four-byte uint32_t for n, and then n bytes follow
+  jump[0x5b] = bytes.decodeBytes64 // byte string, eight-byte uint64_t for n, and then n bytes follow
+  // jump[0x5c] = invalidMinor
+  // jump[0x5d] = invalidMinor
+  // jump[0x5e] = invalidMinor
+  jump[0x5f] = errorer('indefinite length bytes/strings are not supported', decodeErrPrefix) // byte string, byte strings follow, terminated by "break"
+  // UTF-8 string 0x00..0x17 bytes follow
+  for (let i = 0x60; i <= 0x77; i++) {
+    jump[i] = string.decodeStringCompact
+  }
+  jump[0x78] = string.decodeString8 // UTF-8 string, one-byte uint8_t for n, and then n bytes follow
+  jump[0x79] = string.decodeString16 // UTF-8 string, two-byte uint16_t for n, and then n bytes follow
+  jump[0x7a] = string.decodeString32 // UTF-8 string, four-byte uint32_t for n, and then n bytes follow
+  jump[0x7b] = string.decodeString64 // UTF-8 string, eight-byte uint64_t for n, and then n bytes follow
+  // jump[0x7c] = invalidMinor
+  // jump[0x7d] = invalidMinor
+  // jump[0x7e] = invalidMinor
+  jump[0x7f] = errorer('indefinite length bytes/strings are not supported', decodeErrPrefix) // UTF-8 strings follow, terminated by "break"
+  // array, 0x00..0x17 data items follow
+  for (let i = 0x80; i <= 0x97; i++) {
+    jump[i] = array.decodeArrayCompact
+  }
+  jump[0x98] = array.decodeArray8 // array, one-byte uint8_t for n, and then n data items follow
+  jump[0x99] = array.decodeArray16 // array, two-byte uint16_t for n, and then n data items follow
+  jump[0x9a] = array.decodeArray32 // array, four-byte uint32_t for n, and then n data items follow
+  jump[0x9b] = array.decodeArray64 // array, eight-byte uint64_t for n, and then n data items follow
+  // jump[0x9c] = invalidMinor
+  // jump[0x9d] = invalidMinor
+  // jump[0x9e] = invalidMinor
+  jump[0x9f] = array.decodeArrayIndefinite // array, data items follow, terminated by "break"
+  // map, 0x00..0x17 pairs of data items follow
+  for (let i = 0xa0; i <= 0xb7; i++) {
+    jump[i] = map.decodeMapCompact
+  }
+  jump[0xb8] = map.decodeMap8 // map, one-byte uint8_t for n, and then n pairs of data items follow
+  jump[0xb9] = map.decodeMap16 // map, two-byte uint16_t for n, and then n pairs of data items follow
+  jump[0xba] = map.decodeMap32 // map, four-byte uint32_t for n, and then n pairs of data items follow
+  jump[0xbb] = map.decodeMap64 // map, eight-byte uint64_t for n, and then n pairs of data items follow
+  // jump[0xbc] = invalidMinor
+  // jump[0xbd] = invalidMinor
+  // jump[0xbe] = invalidMinor
+  jump[0xbf] = map.decodeMapIndefinite // map, pairs of data items follow, terminated by "break"
+  // tags
+  for (let i = 0xc0; i <= 0xd7; i++) {
+    jump[i] = tag.decodeTagCompact
+  }
+  jump[0xd8] = tag.decodeTag8
+  jump[0xd9] = tag.decodeTag16
+  jump[0xda] = tag.decodeTag32
+  jump[0xdb] = tag.decodeTag64
+  // jump[0xdc] = invalidMinor
+  // jump[0xdd] = invalidMinor
+  // jump[0xde] = invalidMinor
+  // jump[0xdf] = invalidMinor
+  // 0xe0..0xf3 simple values, unsupported
+  for (let i = 0xe0; i <= 0xf3; i++) {
+    jump[i] = errorer('simple values are not supported', decodeErrPrefix)
+  }
+  // jump[0xf4] = invalidMinor // false, handled by quick[]
+  // jump[0xf5] = invalidMinor // true, handled by quick[]
+  // jump[0xf6] = invalidMinor // null, handled by quick[]
+  jump[0xf7] = float.decodeUndefined // undefined
+  jump[0xf8] = errorer('simple values are not supported', decodeErrPrefix) // simple value, one byte follows, unsupported
+  jump[0xf9] = float.decodeFloat16 // half-precision float (two-byte IEEE 754)
+  jump[0xfa] = float.decodeFloat32 // single-precision float (four-byte IEEE 754)
+  jump[0xfb] = float.decodeFloat64 // double-precision float (eight-byte IEEE 754)
+  // jump[0xfc] = invalidMinor
+  // jump[0xfd] = invalidMinor
+  // jump[0xfe] = invalidMinor
+  jump[0xff] = float.decodeBreak // "break" stop code
+  return jump
+}
+
+/** @type {Token[]} */
+export const quick = []
+// ints <24
+for (let i = 0; i < 24; i++) {
+  quick[i] = new Token(Type.uint, i, 1)
+}
+// negints >= -24
+for (let i = -1; i >= -24; i--) {
+  quick[31 - i] = new Token(Type.negint, i, 1)
+}
+// empty bytes
+quick[0x40] = new Token(Type.bytes, new Uint8Array(0), 1)
+// empty string
+quick[0x60] = new Token(Type.string, '', 1)
+// empty list
+quick[0x80] = new Token(Type.array, 0, 1)
+// empty map
+quick[0xa0] = new Token(Type.map, 0, 1)
+// false
+quick[0xf4] = new Token(Type.false, false, 1)
+// true
+quick[0xf5] = new Token(Type.true, true, 1)
+// null
+quick[0xf6] = new Token(Type.null, null, 1)
+
+/**
+ * @param {Token} token
+ * @returns {Uint8Array|undefined}
+ */
+export function quickEncodeToken (token) {
+  switch (token.type) {
+    case Type.false:
+      return fromArray([0xf4])
+    case Type.true:
+      return fromArray([0xf5])
+    case Type.null:
+      return fromArray([0xf6])
+    case Type.bytes:
+      if (!token.value.length) {
+        return fromArray([0x40])
+      }
+      return
+    case Type.string:
+      if (token.value === '') {
+        return fromArray([0x60])
+      }
+      return
+    case Type.array:
+      if (token.value === 0) {
+        return fromArray([0x80])
+      }
+      /* c8 ignore next 2 */
+      // shouldn't be possible if this were called when there was only one token
+      return
+    case Type.map:
+      if (token.value === 0) {
+        return fromArray([0xa0])
+      }
+      /* c8 ignore next 2 */
+      // shouldn't be possible if this were called when there was only one token
+      return
+    case Type.uint:
+      if (token.value < 24) {
+        return fromArray([Number(token.value)])
+      }
+      return
+    case Type.negint:
+      if (token.value >= -24) {
+        return fromArray([31 - Number(token.value)])
+      }
+  }
+}