@fireproof/vendor 0.0.0-smoke

package/patched/cborg/lib/json/encode.js

@@ -0,0 +1,299 @@
+// never reference the file directly to ensure the
+// indepency of the json module
+import { Type } from 'cborg'
+import { encodeCustom } from 'cborg'
+import { encodeErrPrefix } from 'cborg'
+import { asU8A, fromString } from 'cborg'
+
+/**
+ * @typedef {import('../../interface').EncodeOptions} EncodeOptions
+ * @typedef {import('../../interface').TokenTypeEncoder} TokenTypeEncoder
+ * @typedef {import('../token').Token} Token
+ * @typedef {import('../bl').Bl} Bl
+ */
+
+/**
+ * @param {(buf: Bl, token: Token) => void} action
+ * @returns {TokenTypeEncoder}
+ */
+function wrapCompareTokens (action) {
+  const wrapped = (/** @type {Bl} */ buf, /** @type {Token} */token) => action(buf, token)
+  /**
+   * @param {Token} tok1
+   * @param {Token} tok2
+   * @returns {number}
+   */
+  wrapped.compareTokens = function compareTokens (tok1, tok2) {
+    return tok1.value < tok2.value ? -1 : tok1.value > tok2.value ? 1 : 0
+  }
+  return wrapped
+}
+
+/**
+ * @returns {TokenTypeEncoder[]}
+ */
+function makeJSONEncoders() {
+  /** @type {TokenTypeEncoder[]} */
+  const encoders = []
+  /** @type {{type:Type,elements:number}[]} */
+  const inRecursive = []
+
+  /**
+   * @param {Bl} buf
+   */
+  function prefix (buf) {
+    const recurs = inRecursive[inRecursive.length - 1]
+    if (recurs) {
+      if (recurs.type.equals(Type.array)) {
+        recurs.elements++
+        if (recurs.elements !== 1) { // >first
+          buf.push([44]) // ','
+        }
+      }
+      if (recurs.type.equals(Type.map)) {
+        recurs.elements++
+        if (recurs.elements !== 1) { // >first
+          if (recurs.elements % 2 === 1) { // key
+            buf.push([44]) // ','
+          } else {
+            buf.push([58]) // ':'
+          }
+        }
+      }
+    }
+  }
+
+  encoders[Type.uint.major] = wrapCompareTokens((buf, token) => {
+    prefix(buf)
+    const is = String(token.value)
+    const isa = []
+    for (let i = 0; i < is.length; i++) {
+      isa[i] = is.charCodeAt(i)
+    }
+    buf.push(isa)
+  })
+
+  encoders[Type.negint.major] = wrapCompareTokens((buf, token) => {
+     encoders[Type.uint.major](buf, token)
+   })
+
+  encoders[Type.bytes.major] = wrapCompareTokens((_buf, _token) => {
+    throw new Error(`${encodeErrPrefix} unsupported type: Uint8Array`)
+  })
+
+  encoders[Type.string.major] = wrapCompareTokens((buf, token) => {
+    prefix(buf)
+    const byts = fromString(JSON.stringify(token.value))
+    buf.push(byts.length > 32 ? asU8A(byts) : byts)
+  })
+
+  encoders[Type.array.major] = wrapCompareTokens((buf, _token) => {
+    prefix(buf)
+    inRecursive.push({ type: Type.array, elements: 0 })
+    buf.push([91]) // '['
+  })
+
+  encoders[Type.map.major] = wrapCompareTokens((buf, _token) => {
+    prefix(buf)
+    inRecursive.push({ type: Type.map, elements: 0 })
+    buf.push([123]) // '{'
+  })
+
+  encoders[Type.tag.major] = wrapCompareTokens((_buf, _token) => {
+  })
+
+  encoders[Type.float.major] = wrapCompareTokens((buf, token) => {
+    if (token.type.equals(Type.break)) {
+      const recurs = inRecursive.pop()
+      if (recurs) {
+        if (recurs.type.equals(Type.array)) {
+          buf.push([93]) // ']'
+        } else if (recurs.type.equals(Type.map)) {
+          buf.push([125]) // '}'
+        /* c8 ignore next 3 */
+        } else {
+          throw new Error('Unexpected recursive type; this should not happen!')
+        }
+        return
+      }
+      /* c8 ignore next 2 */
+      throw new Error('Unexpected break; this should not happen!')
+    }
+    if (token.value === undefined) {
+      throw new Error(`${encodeErrPrefix} unsupported type: undefined`)
+    }
+
+    prefix(buf)
+    if (token.type.equals(Type.true)) {
+      buf.push([116, 114, 117, 101]) // 'true'
+      return
+    } else if (token.type.equals(Type.false)) {
+      buf.push([102, 97, 108, 115, 101]) // 'false'
+      return
+    } else if (token.type.equals(Type.null)) {
+      buf.push([110, 117, 108, 108]) // 'null'
+      return
+    }
+
+    // number
+    const is = String(token.value)
+    const isa = []
+    let dp = false
+    for (let i = 0; i < is.length; i++) {
+      isa[i] = is.charCodeAt(i)
+      if (!dp && (isa[i] === 46 || isa[i] === 101 || isa[i] === 69)) { // '[.eE]'
+        dp = true
+      }
+    }
+    if (!dp) { // need a decimal point for floats
+      isa.push(46) // '.'
+      isa.push(48) // '0'
+    }
+    buf.push(isa)
+  })
+  return encoders
+}
+
+// The below code is mostly taken and modified from https://github.com/feross/buffer
+// Licensed MIT. Copyright (c) Feross Aboukhadijeh
+// function encodeUtf8 (string, byts) {
+//   let codePoint
+//   const length = string.length
+//   let leadSurrogate = null
+
+//   for (let i = 0; i < length; ++i) {
+//     codePoint = string.charCodeAt(i)
+
+//     // is surrogate component
+//     if (codePoint > 0xd7ff && codePoint < 0xe000) {
+//       // last char was a lead
+//       if (!leadSurrogate) {
+//         // no lead yet
+//         /* c8 ignore next 9 */
+//         if (codePoint > 0xdbff) {
+//           // unexpected trail
+//           byts.push(0xef, 0xbf, 0xbd)
+//           continue
+//         } else if (i + 1 === length) {
+//           // unpaired lead
+//           byts.push(0xef, 0xbf, 0xbd)
+//           continue
+//         }
+
+//         // valid lead
+//         leadSurrogate = codePoint
+
+//         continue
+//       }
+
+//       // 2 leads in a row
+//       /* c8 ignore next 5 */
+//       if (codePoint < 0xdc00) {
+//         byts.push(0xef, 0xbf, 0xbd)
+//         leadSurrogate = codePoint
+//         continue
+//       }
+
+//       // valid surrogate pair
+//       codePoint = (leadSurrogate - 0xd800 << 10 | codePoint - 0xdc00) + 0x10000
+//     /* c8 ignore next 4 */
+//     } else if (leadSurrogate) {
+//       // valid bmp char, but last char was a lead
+//       byts.push(0xef, 0xbf, 0xbd)
+//     }
+
+//     leadSurrogate = null
+
+//     // encode utf8
+//     if (codePoint < 0x80) {
+//       // special JSON escapes
+//       switch (codePoint) {
+//         case 8: // '\b'
+//           byts.push(92, 98) // '\\b'
+//           continue
+//         case 9: // '\t'
+//           byts.push(92, 116) // '\\t'
+//           continue
+//         case 10: // '\n'
+//           byts.push(92, 110) // '\\n'
+//           continue
+//         case 12: // '\f'
+//           byts.push(92, 102) // '\\f'
+//           continue
+//         case 13: // '\r'
+//           byts.push(92, 114) // '\\r'
+//           continue
+//         case 34: // '"'
+//           byts.push(92, 34) // '\\"'
+//           continue
+//         case 92: // '\\'
+//           byts.push(92, 92) // '\\\\'
+//           continue
+//       }
+
+//       byts.push(codePoint)
+//     } else if (codePoint < 0x800) {
+//       /* c8 ignore next 1 */
+//       byts.push(
+//         codePoint >> 0x6 | 0xc0,
+//         codePoint & 0x3f | 0x80
+//       )
+//     } else if (codePoint < 0x10000) {
+//       /* c8 ignore next 1 */
+//       byts.push(
+//         codePoint >> 0xc | 0xe0,
+//         codePoint >> 0x6 & 0x3f | 0x80,
+//         codePoint & 0x3f | 0x80
+//       )
+//     /* c8 ignore next 9 */
+//     } else if (codePoint < 0x110000) {
+//       byts.push(
+//         codePoint >> 0x12 | 0xf0,
+//         codePoint >> 0xc & 0x3f | 0x80,
+//         codePoint >> 0x6 & 0x3f | 0x80,
+//         codePoint & 0x3f | 0x80
+//       )
+//     } else {
+//       /* c8 ignore next 2 */
+//       throw new Error('Invalid code point')
+//     }
+//   }
+// }
+
+/**
+ * @param {(Token|Token[])[]} e1
+ * @param {(Token|Token[])[]} e2
+ * @returns {number}
+ */
+function mapSorter (e1, e2) {
+  if (Array.isArray(e1[0]) || Array.isArray(e2[0])) {
+    throw new Error(`${encodeErrPrefix} complex map keys are not supported`)
+  }
+  const keyToken1 = e1[0]
+  const keyToken2 = e2[0]
+  if (!keyToken1.type.equals(Type.string) || !keyToken2.type.equals(Type.string)) {
+    throw new Error(`${encodeErrPrefix} non-string map keys are not supported`)
+  }
+  if (keyToken1 < keyToken2) {
+    return -1
+  }
+  if (keyToken1 > keyToken2) {
+    return 1
+  }
+  /* c8 ignore next 1 */
+  throw new Error(`${encodeErrPrefix} unexpected duplicate map keys, this is not supported`)
+}
+
+const defaultEncodeOptions = { addBreakTokens: true, mapSorter }
+
+/**
+ * @param {any} data
+ * @param {EncodeOptions} [options]
+ * @returns {Uint8Array}
+ */
+function encode (data, options) {
+  options = Object.assign({}, defaultEncodeOptions, options)
+  return encodeCustom(data, makeJSONEncoders(), options)
+}
+
+export { encode }

package/patched/cborg/lib/json/json.js

@@ -0,0 +1,4 @@
+import { encode } from './encode.js'
+import { decode, decodeFirst, Tokenizer } from './decode.js'
+
+export { encode, decode, decodeFirst, Tokenizer }

package/patched/cborg/lib/jump.js

@@ -0,0 +1,209 @@
+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 { decodeErrPrefix } from './common.js'
+import { fromArray } from './byte-utils.js'
+
+/**
+ * @typedef {import('../interface').DecodeOptions} DecodeOptions
+ */
+
+/**
+ * @param {Uint8Array} data
+ * @param {number} pos
+ * @param {number} minor
+ */
+function invalidMinor (data, pos, minor) {
+  throw new Error(`${decodeErrPrefix} encountered invalid minor (${minor}) for major ${data[pos] >>> 5}`)
+}
+
+/**
+ * @param {string} msg
+ * @returns {()=>any}
+ */
+function errorer (msg) {
+  return () => { throw new Error(`${decodeErrPrefix} ${msg}`) }
+}
+
+/** @type {((data:Uint8Array, pos:number, minor:number, options?:DecodeOptions) => any)[]} */
+export const jump = []
+
+// 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') // 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') // 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')
+}
+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') // 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
+
+/** @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)])
+      }
+  }
+}

package/patched/cborg/lib/length.js

@@ -0,0 +1,61 @@
+import { makeCborEncoders, objectToTokens } from './encode.js'
+import { quickEncodeToken } from './jump.js'
+
+/**
+ * @typedef {import('../interface').EncodeOptions} EncodeOptions
+ * @typedef {import('../interface').TokenTypeEncoder} TokenTypeEncoder
+ * @typedef {import('../interface').TokenOrNestedTokens} TokenOrNestedTokens
+ */
+
+const cborEncoders = makeCborEncoders()
+
+/** @type {EncodeOptions} */
+const defaultEncodeOptions = {
+  float64: false,
+  quickEncodeToken
+}
+
+/**
+ * Calculate the byte length of the given data when encoded as CBOR with the
+ * options provided.
+ * This calculation will be accurate if the same options are used as when
+ * performing a normal encode. Some encode options can change the encoding
+ * output length.
+ *
+ * @param {any} data
+ * @param {EncodeOptions} [options]
+ * @returns {number}
+ */
+export function encodedLength (data, options) {
+  options = Object.assign({}, defaultEncodeOptions, options)
+  options.mapSorter = undefined // won't change the length
+  const tokens = objectToTokens(data, options)
+  return tokensToLength(tokens, cborEncoders, options)
+}
+
+/**
+ * Calculate the byte length of the data as represented by the given tokens when
+ * encoded as CBOR with the options provided.
+ * This function is for advanced users and would not normally be called
+ * directly. See `encodedLength()` for appropriate use.
+ *
+ * @param {TokenOrNestedTokens} tokens
+ * @param {TokenTypeEncoder[]} [encoders]
+ * @param {EncodeOptions} [options]
+ */
+export function tokensToLength (tokens, encoders = cborEncoders, options = defaultEncodeOptions) {
+  if (Array.isArray(tokens)) {
+    let len = 0
+    for (const token of tokens) {
+      len += tokensToLength(token, encoders, options)
+    }
+    return len
+  } else {
+    const encoder = encoders[tokens.type.major]
+    /* c8 ignore next 3 */
+    if (encoder.encodedSize === undefined || typeof encoder.encodedSize !== 'function') {
+      throw new Error(`Encoder for ${tokens.type.name} does not have an encodedSize()`)
+    }
+    return encoder.encodedSize(tokens, options)
+  }
+}

package/patched/cborg/lib/token.js

@@ -0,0 +1,76 @@
+class Type {
+  /**
+   * @param {number} major
+   * @param {string} name
+   * @param {boolean} terminal
+   */
+  constructor (major, name, terminal) {
+    this.major = major
+    this.majorEncoded = major << 5
+    this.name = name
+    this.terminal = terminal
+  }
+
+  /* c8 ignore next 3 */
+  toString () {
+    return `Type[${this.major}].${this.name}`
+  }
+
+  /**
+   * @param {Type} typ
+   * @returns {boolean}
+   */
+  equals (typ) {
+    return this.major === typ.major && this.name === typ.name
+  }
+
+  /**
+   * @param {Type} typ
+   * @returns {number}
+   */
+  compare (typ) {
+    /* c8 ignore next 1 */
+    return this.major < typ.major ? -1 : this.major > typ.major ? 1 : 0
+  }
+}
+
+// convert to static fields when better supported
+Type.uint = new Type(0, 'uint', true)
+Type.negint = new Type(1, 'negint', true)
+Type.bytes = new Type(2, 'bytes', true)
+Type.string = new Type(3, 'string', true)
+Type.array = new Type(4, 'array', false)
+Type.map = new Type(5, 'map', false)
+Type.tag = new Type(6, 'tag', false) // terminal?
+Type.float = new Type(7, 'float', true)
+Type.false = new Type(7, 'false', true)
+Type.true = new Type(7, 'true', true)
+Type.null = new Type(7, 'null', true)
+Type.undefined = new Type(7, 'undefined', true)
+Type.break = new Type(7, 'break', true)
+
+// Type.indefiniteLength = new Type(0, 'indefiniteLength', true)
+
+class Token {
+  /**
+   * @param {Type} type
+   * @param {any} [value]
+   * @param {number} [encodedLength]
+   */
+  constructor (type, value, encodedLength) {
+    this.type = type
+    this.value = value
+    this.encodedLength = encodedLength
+    /** @type {Uint8Array|undefined} */
+    this.encodedBytes = undefined
+    /** @type {Uint8Array|undefined} */
+    this.byteValue = undefined
+  }
+
+  /* c8 ignore next 3 */
+  toString () {
+    return `Token[${this.type}].${this.value}`
+  }
+}
+
+export { Type, Token }