@fireproof/vendor 0.0.0-smoke → 1.0.1

package/src/cborg/cborg/lib/decode.js

@@ -1,209 +0,0 @@
-import { decodeErrPrefix } from './common.js'
-import { Type } from './token.js'
-import { jump, quick } from './jump.js'
-
-/**
- * @typedef {import('./token.js').Token} Token
- * @typedef {import('../interface').DecodeOptions} DecodeOptions
- * @typedef {import('../interface').DecodeTokenizer} DecodeTokenizer
- */
-
-const defaultDecodeOptions = {
-  strict: false,
-  allowIndefinite: true,
-  allowUndefined: true,
-  allowBigInt: true
-}
-
-/**
- * @implements {DecodeTokenizer}
- */
-class Tokeniser {
-  /**
-   * @param {Uint8Array} data
-   * @param {DecodeOptions} options
-   */
-  constructor (data, options = {}) {
-    this._pos = 0
-    this.data = data
-    this.options = options
-  }
-
-  pos () {
-    return this._pos
-  }
-
-  done () {
-    return this._pos >= this.data.length
-  }
-
-  next () {
-    const byt = this.data[this._pos]
-    let token = quick[byt]
-    if (token === undefined) {
-      const decoder = jump[byt]
-      /* c8 ignore next 4 */
-      // if we're here then there's something wrong with our jump or quick lists!
-      if (!decoder) {
-        throw new Error(`${decodeErrPrefix} no decoder for major type ${byt >>> 5} (byte 0x${byt.toString(16).padStart(2, '0')})`)
-      }
-      const minor = byt & 31
-      token = decoder(this.data, this._pos, minor, this.options)
-    }
-    // @ts-ignore we get to assume encodedLength is set (crossing fingers slightly)
-    this._pos += token.encodedLength
-    return token
-  }
-}
-
-const DONE = Symbol.for('DONE')
-const BREAK = Symbol.for('BREAK')
-
-/**
- * @param {Token} token
- * @param {DecodeTokenizer} tokeniser
- * @param {DecodeOptions} options
- * @returns {any|BREAK|DONE}
- */
-function tokenToArray (token, tokeniser, options) {
-  const arr = []
-  for (let i = 0; i < token.value; i++) {
-    const value = tokensToObject(tokeniser, options)
-    if (value === BREAK) {
-      if (token.value === Infinity) {
-        // normal end to indefinite length array
-        break
-      }
-      throw new Error(`${decodeErrPrefix} got unexpected break to lengthed array`)
-    }
-    if (value === DONE) {
-      throw new Error(`${decodeErrPrefix} found array but not enough entries (got ${i}, expected ${token.value})`)
-    }
-    arr[i] = value
-  }
-  return arr
-}
-
-/**
- * @param {Token} token
- * @param {DecodeTokenizer} tokeniser
- * @param {DecodeOptions} options
- * @returns {any|BREAK|DONE}
- */
-function tokenToMap (token, tokeniser, options) {
-  const useMaps = options.useMaps === true
-  const obj = useMaps ? undefined : {}
-  const m = useMaps ? new Map() : undefined
-  for (let i = 0; i < token.value; i++) {
-    const key = tokensToObject(tokeniser, options)
-    if (key === BREAK) {
-      if (token.value === Infinity) {
-        // normal end to indefinite length map
-        break
-      }
-      throw new Error(`${decodeErrPrefix} got unexpected break to lengthed map`)
-    }
-    if (key === DONE) {
-      throw new Error(`${decodeErrPrefix} found map but not enough entries (got ${i} [no key], expected ${token.value})`)
-    }
-    if (useMaps !== true && typeof key !== 'string') {
-      throw new Error(`${decodeErrPrefix} non-string keys not supported (got ${typeof key})`)
-    }
-    if (options.rejectDuplicateMapKeys === true) {
-      // @ts-ignore
-      if ((useMaps && m.has(key)) || (!useMaps && (key in obj))) {
-        throw new Error(`${decodeErrPrefix} found repeat map key "${key}"`)
-      }
-    }
-    const value = tokensToObject(tokeniser, options)
-    if (value === DONE) {
-      throw new Error(`${decodeErrPrefix} found map but not enough entries (got ${i} [no value], expected ${token.value})`)
-    }
-    if (useMaps) {
-      // @ts-ignore TODO reconsider this .. maybe needs to be strict about key types
-      m.set(key, value)
-    } else {
-      // @ts-ignore TODO reconsider this .. maybe needs to be strict about key types
-      obj[key] = value
-    }
-  }
-  // @ts-ignore c'mon man
-  return useMaps ? m : obj
-}
-
-/**
- * @param {DecodeTokenizer} tokeniser
- * @param {DecodeOptions} options
- * @returns {any|BREAK|DONE}
- */
-function tokensToObject (tokeniser, options) {
-  // should we support array as an argument?
-  // check for tokenIter[Symbol.iterator] and replace tokenIter with what that returns?
-  if (tokeniser.done()) {
-    return DONE
-  }
-
-  const token = tokeniser.next()
-
-  if (token.type.equals(Type.break)) {
-    return BREAK
-  }
-
-  if (token.type.terminal) {
-    return token.value
-  }
-
-  if (token.type.equals(Type.array)) {
-    return tokenToArray(token, tokeniser, options)
-  }
-
-  if (token.type.equals(Type.map)) {
-    return tokenToMap(token, tokeniser, options)
-  }
-
-  if (token.type.equals(Type.tag)) {
-    if (options.tags && typeof options.tags[token.value] === 'function') {
-      const tagged = tokensToObject(tokeniser, options)
-      return options.tags[token.value](tagged)
-    }
-    throw new Error(`${decodeErrPrefix} tag not supported (${token.value})`)
-  }
-  /* c8 ignore next */
-  throw new Error('unsupported')
-}
-
-/**
- * @param {Uint8Array} data
- * @param {DecodeOptions} [options]
- * @returns {[any, Uint8Array]}
- */
-function decodeFirst (data, options) {
-  if (!(data instanceof Uint8Array)) {
-    throw new Error(`${decodeErrPrefix} data to decode must be a Uint8Array`)
-  }
-  options = Object.assign({}, defaultDecodeOptions, options)
-  const tokeniser = options.tokenizer || new Tokeniser(data, options)
-  const decoded = tokensToObject(tokeniser, options)
-  if (decoded === DONE) {
-    throw new Error(`${decodeErrPrefix} did not find any content to decode`)
-  }
-  if (decoded === BREAK) {
-    throw new Error(`${decodeErrPrefix} got unexpected break`)
-  }
-  return [decoded, data.subarray(tokeniser.pos())]
-}
-
-/**
- * @param {Uint8Array} data
- * @param {DecodeOptions} [options]
- * @returns {any}
- */
-function decode (data, options) {
-  const [decoded, remainder] = decodeFirst(data, options)
-  if (remainder.length > 0) {
-    throw new Error(`${decodeErrPrefix} too many terminals, data makes no sense`)
-  }
-  return decoded
-}
-
-export { Tokeniser, tokensToObject, decode, decodeFirst }

package/src/cborg/cborg/lib/diagnostic_test.js

@@ -1,117 +0,0 @@
-import { tokensToDiagnostic } from './diagnostic.js'
-import { fromHex } from './byte-utils.js'
-
-const inp = `
-a7
-62
-6964
-78 40
-6469643a6578616d706c653a31324433
-4b6f6f574d4864727a6377706a626472
-5a733547477145524176636771583362
-3564707550745061396f743639796577
-65
-70726f6f66
-a4
-64
-74797065
-74
-656432353531395369676e617475726532303138
-67
-63726561746564
-74
-323032302d30352d30315430333a30303a30325a
-67
-63726561746f72
-78 8c
-6469643a6578616d706c653a31324433
-4b6f6f574d4864727a6377706a626472
-5a733547477145524176636771583362
-3564707550745061396f743639796577
-3b206578616d706c653a6b65793d6964
-3d626166797265696375627478357771
-6f336e6f73633463617a726b63746668
-776436726577657a6770776f65347377
-69726c733465626468733269
-6e
-7369676e617475726556616c7565
-78 58
-6f3972364c78676f474e38466f616565
-554136456444637631324776447a4645
-6d43676a577a76707572325953517941
-3857327230535357554b2b6e4835744d
-717a61464c756e3677775a31456f7433
-37616d4744673d3d
-67
-63726561746564
-74
-323031382d31322d30315430333a30303a30305a
-67
-75706461746564
-74
-323032302d30352d30315430333a30303a30305a
-68
-40636f6e74657874
-78 1c
-68747470733a2f2f7777772e77332e6f
-72672f6e732f6469642f7631
-69
-7075626c69634b6579
-81
-a5
-62
-6964
-78 85
-6261667972656963756274783577716f
-336e6f73633463617a726b6374666877
-6436726577657a6770776f6534737769
-726c7334656264687332693b6578616d
-706c653a6b65793d6964626166797265
-6963756274783577716f336e6f736334
-63617a726b6374666877643672657765
-7a6770776f6534737769726c73346562
-6468733269
-64
-74797065
-6e
-45644473615075626c69634b6579
-65
-6375727665
-67
-65643235353139
-67
-65787069726573
-74
-323031392d31322d30315430333a30303a30305a
-6f
-7075626c69634b6579426173653634
-78 2c
-716d7a3774704c4e4b4b4b646c376344
-375062656a4469425670374f4e706d5a
-62666d633763454b396d673d
-6e
-61757468656e7469636174696f6e
-81
-78 83
-6469643a6578616d706c653a31324433
-4b6f6f574d4864727a6377706a626472
-5a733547477145524176636771583362
-3564707550745061396f743639796577
-3b6b65792d69643d6261667972656963
-756274783577716f336e6f7363346361
-7a726b63746668776436726577657a67
-70776f6534737769726c733465626468
-733269
-`.replace(/[\n ]/g, '')
-
-// tokensToDiagnostic(fromHex('861864fb4376345785d8a0002063796570428411fb3ff199999999999a'))
-for (const line of tokensToDiagnostic(fromHex('851864fb4376345785d8a00020a661624284116166f46168f7616ef6617379012c7965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965706174f5fb3ff199999999999a'))) {
-  console.log(line)
-}
-for (const line of tokensToDiagnostic(fromHex(inp))) {
-  console.log(line)
-}
-
-for (const line of tokensToDiagnostic(fromHex('82410181a161318182410041ff'))) {
-  console.log(line)
-}

package/src/cborg/cborg/lib/is.js

@@ -1,106 +0,0 @@
-// This is an unfortunate replacement for @sindresorhus/is that we need to
-// re-implement for performance purposes. In particular the is.observable()
-// check is expensive, and unnecessary for our purposes. The values returned
-// are compatible with @sindresorhus/is, however.
-
-const typeofs = [
-  'string',
-  'number',
-  'bigint',
-  'symbol'
-]
-
-const objectTypeNames = [
-  'Function',
-  'Generator',
-  'AsyncGenerator',
-  'GeneratorFunction',
-  'AsyncGeneratorFunction',
-  'AsyncFunction',
-  'Observable',
-  'Array',
-  'Buffer',
-  'Object',
-  'RegExp',
-  'Date',
-  'Error',
-  'Map',
-  'Set',
-  'WeakMap',
-  'WeakSet',
-  'ArrayBuffer',
-  'SharedArrayBuffer',
-  'DataView',
-  'Promise',
-  'URL',
-  'HTMLElement',
-  'Int8Array',
-  'Uint8Array',
-  'Uint8ClampedArray',
-  'Int16Array',
-  'Uint16Array',
-  'Int32Array',
-  'Uint32Array',
-  'Float32Array',
-  'Float64Array',
-  'BigInt64Array',
-  'BigUint64Array'
-]
-
-/**
- * @param {any} value
- * @returns {string}
- */
-export function is (value) {
-  if (value === null) {
-    return 'null'
-  }
-  if (value === undefined) {
-    return 'undefined'
-  }
-  if (value === true || value === false) {
-    return 'boolean'
-  }
-  const typeOf = typeof value
-  if (typeofs.includes(typeOf)) {
-    return typeOf
-  }
-  /* c8 ignore next 4 */
-  // not going to bother testing this, it's not going to be valid anyway
-  if (typeOf === 'function') {
-    return 'Function'
-  }
-  if (Array.isArray(value)) {
-    return 'Array'
-  }
-  if (isBuffer(value)) {
-    return 'Buffer'
-  }
-  const objectType = getObjectType(value)
-  if (objectType) {
-    return objectType
-  }
-  /* c8 ignore next */
-  return 'Object'
-}
-
-/**
- * @param {any} value
- * @returns {boolean}
- */
-function isBuffer (value) {
-  return value && value.constructor && value.constructor.isBuffer && value.constructor.isBuffer.call(null, value)
-}
-
-/**
- * @param {any} value
- * @returns {string|undefined}
- */
-function getObjectType (value) {
-  const objectTypeName = Object.prototype.toString.call(value).slice(8, -1)
-  if (objectTypeNames.includes(objectTypeName)) {
-    return objectTypeName
-  }
-  /* c8 ignore next */
-  return undefined
-}

package/src/cborg/cborg/lib/json/json.js

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

package/src/cborg/cborg/lib/jump.js

@@ -1,209 +0,0 @@
-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)])
-      }
-  }
-}