@fireproof/vendor 0.0.0-smoke → 1.0.1

package/patched/cborg/lib/7float.js

@@ -1,308 +0,0 @@
-// TODO: shift some of the bytes logic to bytes-utils so we can use Buffer
-// where possible
-
-import { Token, Type } from './token.js'
-import { decodeErrPrefix } from './common.js'
-import { encodeUint } from './0uint.js'
-
-/**
- * @typedef {import('./bl.js').Bl} Bl
- * @typedef {import('../interface').DecodeOptions} DecodeOptions
- * @typedef {import('../interface').EncodeOptions} EncodeOptions
- */
-
-const MINOR_FALSE = 20
-const MINOR_TRUE = 21
-const MINOR_NULL = 22
-const MINOR_UNDEFINED = 23
-
-/**
- * @param {Uint8Array} _data
- * @param {number} _pos
- * @param {number} _minor
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-export function decodeUndefined (_data, _pos, _minor, options) {
-  if (options.allowUndefined === false) {
-    throw new Error(`${decodeErrPrefix} undefined values are not supported`)
-  } else if (options.coerceUndefinedToNull === true) {
-    return new Token(Type.null, null, 1)
-  }
-  return new Token(Type.undefined, undefined, 1)
-}
-
-/**
- * @param {Uint8Array} _data
- * @param {number} _pos
- * @param {number} _minor
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-export function decodeBreak (_data, _pos, _minor, options) {
-  if (options.allowIndefinite === false) {
-    throw new Error(`${decodeErrPrefix} indefinite length items not allowed`)
-  }
-  return new Token(Type.break, undefined, 1)
-}
-
-/**
- * @param {number} value
- * @param {number} bytes
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-function createToken (value, bytes, options) {
-  if (options) {
-    if (options.allowNaN === false && Number.isNaN(value)) {
-      throw new Error(`${decodeErrPrefix} NaN values are not supported`)
-    }
-    if (options.allowInfinity === false && (value === Infinity || value === -Infinity)) {
-      throw new Error(`${decodeErrPrefix} Infinity values are not supported`)
-    }
-  }
-  return new Token(Type.float, value, bytes)
-}
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} _minor
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-export function decodeFloat16 (data, pos, _minor, options) {
-  return createToken(readFloat16(data, pos + 1), 3, options)
-}
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} _minor
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-export function decodeFloat32 (data, pos, _minor, options) {
-  return createToken(readFloat32(data, pos + 1), 5, options)
-}
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} _minor
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-export function decodeFloat64 (data, pos, _minor, options) {
-  return createToken(readFloat64(data, pos + 1), 9, options)
-}
-
-/**
- * @param {Bl} buf
- * @param {Token} token
- * @param {EncodeOptions} options
- */
-export function encodeFloat (buf, token, options) {
-  const float = token.value
-
-  if (float === false) {
-    buf.push([Type.float.majorEncoded | MINOR_FALSE])
-  } else if (float === true) {
-    buf.push([Type.float.majorEncoded | MINOR_TRUE])
-  } else if (float === null) {
-    buf.push([Type.float.majorEncoded | MINOR_NULL])
-  } else if (float === undefined) {
-    buf.push([Type.float.majorEncoded | MINOR_UNDEFINED])
-  } else {
-    let decoded
-    let success = false
-    if (!options || options.float64 !== true) {
-      encodeFloat16(float)
-      decoded = readFloat16(ui8a, 1)
-      if (float === decoded || Number.isNaN(float)) {
-        ui8a[0] = 0xf9
-        buf.push(ui8a.slice(0, 3))
-        success = true
-      } else {
-        encodeFloat32(float)
-        decoded = readFloat32(ui8a, 1)
-        if (float === decoded) {
-          ui8a[0] = 0xfa
-          buf.push(ui8a.slice(0, 5))
-          success = true
-        }
-      }
-    }
-    if (!success) {
-      encodeFloat64(float)
-      decoded = readFloat64(ui8a, 1)
-      ui8a[0] = 0xfb
-      buf.push(ui8a.slice(0, 9))
-    }
-  }
-}
-
-/**
- * @param {Token} token
- * @param {EncodeOptions} options
- * @returns {number}
- */
-encodeFloat.encodedSize = function encodedSize (token, options) {
-  const float = token.value
-
-  if (float === false || float === true || float === null || float === undefined) {
-    return 1
-  }
-
-  if (!options || options.float64 !== true) {
-    encodeFloat16(float)
-    let decoded = readFloat16(ui8a, 1)
-    if (float === decoded || Number.isNaN(float)) {
-      return 3
-    }
-    encodeFloat32(float)
-    decoded = readFloat32(ui8a, 1)
-    if (float === decoded) {
-      return 5
-    }
-  }
-  return 9
-}
-
-const buffer = new ArrayBuffer(9)
-const dataView = new DataView(buffer, 1)
-const ui8a = new Uint8Array(buffer, 0)
-
-/**
- * @param {number} inp
- */
-function encodeFloat16 (inp) {
-  if (inp === Infinity) {
-    dataView.setUint16(0, 0x7c00, false)
-  } else if (inp === -Infinity) {
-    dataView.setUint16(0, 0xfc00, false)
-  } else if (Number.isNaN(inp)) {
-    dataView.setUint16(0, 0x7e00, false)
-  } else {
-    dataView.setFloat32(0, inp)
-    const valu32 = dataView.getUint32(0)
-    const exponent = (valu32 & 0x7f800000) >> 23
-    const mantissa = valu32 & 0x7fffff
-
-    /* c8 ignore next 6 */
-    if (exponent === 0xff) {
-      // too big, Infinity, but this should be hard (impossible?) to trigger
-      dataView.setUint16(0, 0x7c00, false)
-    } else if (exponent === 0x00) {
-      // 0.0, -0.0 and subnormals, shouldn't be possible to get here because 0.0 should be counted as an int
-      dataView.setUint16(0, ((inp & 0x80000000) >> 16) | (mantissa >> 13), false)
-    } else { // standard numbers
-      // chunks of logic here borrowed from https://github.com/PJK/libcbor/blob/c78f437182533e3efa8d963ff4b945bb635c2284/src/cbor/encoding.c#L127
-      const logicalExponent = exponent - 127
-      // Now we know that 2^exponent <= 0 logically
-      /* c8 ignore next 6 */
-      if (logicalExponent < -24) {
-        /* No unambiguous representation exists, this float is not a half float
-          and is too small to be represented using a half, round off to zero.
-          Consistent with the reference implementation. */
-        // should be difficult (impossible?) to get here in JS
-        dataView.setUint16(0, 0)
-      } else if (logicalExponent < -14) {
-        /* Offset the remaining decimal places by shifting the significand, the
-          value is lost. This is an implementation decision that works around the
-          absence of standard half-float in the language. */
-        dataView.setUint16(0, ((valu32 & 0x80000000) >> 16) | /* sign bit */ (1 << (24 + logicalExponent)), false)
-      } else {
-        dataView.setUint16(0, ((valu32 & 0x80000000) >> 16) | ((logicalExponent + 15) << 10) | (mantissa >> 13), false)
-      }
-    }
-  }
-}
-
-/**
- * @param {Uint8Array} ui8a
- * @param {number} pos
- * @returns {number}
- */
-function readFloat16 (ui8a, pos) {
-  if (ui8a.length - pos < 2) {
-    throw new Error(`${decodeErrPrefix} not enough data for float16`)
-  }
-
-  const half = (ui8a[pos] << 8) + ui8a[pos + 1]
-  if (half === 0x7c00) {
-    return Infinity
-  }
-  if (half === 0xfc00) {
-    return -Infinity
-  }
-  if (half === 0x7e00) {
-    return NaN
-  }
-  const exp = (half >> 10) & 0x1f
-  const mant = half & 0x3ff
-  let val
-  if (exp === 0) {
-    val = mant * (2 ** -24)
-  } else if (exp !== 31) {
-    val = (mant + 1024) * (2 ** (exp - 25))
-  /* c8 ignore next 4 */
-  } else {
-    // may not be possible to get here
-    val = mant === 0 ? Infinity : NaN
-  }
-  return (half & 0x8000) ? -val : val
-}
-
-/**
- * @param {number} inp
- */
-function encodeFloat32 (inp) {
-  dataView.setFloat32(0, inp, false)
-}
-
-/**
- * @param {Uint8Array} ui8a
- * @param {number} pos
- * @returns {number}
- */
-function readFloat32 (ui8a, pos) {
-  if (ui8a.length - pos < 4) {
-    throw new Error(`${decodeErrPrefix} not enough data for float32`)
-  }
-  const offset = (ui8a.byteOffset || 0) + pos
-  return new DataView(ui8a.buffer, offset, 4).getFloat32(0, false)
-}
-
-/**
- * @param {number} inp
- */
-function encodeFloat64 (inp) {
-  dataView.setFloat64(0, inp, false)
-}
-
-/**
- * @param {Uint8Array} ui8a
- * @param {number} pos
- * @returns {number}
- */
-function readFloat64 (ui8a, pos) {
-  if (ui8a.length - pos < 8) {
-    throw new Error(`${decodeErrPrefix} not enough data for float64`)
-  }
-  const offset = (ui8a.byteOffset || 0) + pos
-  return new DataView(ui8a.buffer, offset, 8).getFloat64(0, false)
-}
-
-/**
- * @param {Token} _tok1
- * @param {Token} _tok2
- * @returns {number}
- */
-encodeFloat.compareTokens = encodeUint.compareTokens
-/*
-encodeFloat.compareTokens = function compareTokens (_tok1, _tok2) {
-  return _tok1
-  throw new Error(`${encodeErrPrefix} cannot use floats as map keys`)
-}
-*/

package/patched/cborg/lib/bin.js

@@ -1,189 +0,0 @@
-#!/usr/bin/env node
-
-import process from 'process'
-import { decode, encode } from '../cborg.js'
-import { tokensToDiagnostic, fromDiag } from './diagnostic.js'
-import { fromHex as _fromHex, toHex } from './byte-utils.js'
-
-/**
- * @param {number} code
- */
-function usage (code) {
-  console.error('Usage: cborg <command> <args>')
-  console.error('Valid commands:')
-  console.error('\tbin2diag [--width <width>] [binary input]')
-  console.error('\tbin2hex [binary input]')
-  console.error('\tbin2json [--pretty] [binary input]')
-  console.error('\tdiag2bin [diagnostic input]')
-  console.error('\tdiag2hex [diagnostic input]')
-  console.error('\tdiag2json [--pretty] [diagnostic input]')
-  console.error('\thex2bin [hex input]')
-  console.error('\thex2diag [--width <width>] [hex input]')
-  console.error('\thex2json [--pretty] [hex input]')
-  console.error('\tjson2bin \'[json input]\'')
-  console.error('\tjson2diag [--width <width>] \'[json input]\'')
-  console.error('\tjson2hex \'[json input]\'')
-  console.error('Input may either be supplied as an argument or piped via stdin')
-  process.exit(code || 0)
-}
-
-async function fromStdin () {
-  const chunks = []
-  for await (const chunk of process.stdin) {
-    chunks.push(chunk)
-  }
-  return Buffer.concat(chunks)
-}
-
-/**
- * @param {string} str
- * @returns {Uint8Array}
- */
-function fromHex (str) {
-  str = str.replace(/\r?\n/g, '') // let's be charitable
-  /* c8 ignore next 3 */
-  if (!(/^([0-9a-f]{2})*$/i).test(str)) {
-    throw new Error('Input string is not hexadecimal format')
-  }
-  return _fromHex(str)
-}
-
-function argvPretty () {
-  const argv = process.argv.filter((s) => s !== '--pretty')
-  const pretty = argv.length !== process.argv.length
-  return { argv, pretty }
-}
-
-function argvWidth () {
-  const widthIndex = process.argv.findIndex((s) => s === '--width')
-  if (widthIndex <= 0 || widthIndex + 1 >= process.argv.length) {
-    return { argv: process.argv.filter((s) => s !== '--width'), width: undefined }
-  }
-  const width = parseInt(process.argv[widthIndex + 1], 10)
-  if (!width || width < 20) {
-    return { argv: process.argv.filter((s) => s !== '--width'), width: undefined }
-  }
-  const argv = process.argv
-  argv.splice(widthIndex, 2)
-  return { argv, width }
-}
-
-async function run () {
-  const cmd = process.argv[2]
-
-  switch (cmd) {
-    case 'help': {
-      return usage(0)
-    }
-
-    case 'bin2diag': {
-      /* c8 ignore next 1 */
-      const { argv, width } = argvWidth()
-      const bin = argv.length < 4 ? (await fromStdin()) : new TextEncoder().encode(argv[3])
-      for (const line of tokensToDiagnostic(bin, width)) {
-        console.log(line)
-      }
-      return
-    }
-
-    case 'bin2hex': {
-      // this is really nothing to do with cbor.. just handy
-      /* c8 ignore next 1 */
-      const bin = process.argv.length < 4 ? (await fromStdin()) : new TextEncoder().encode(process.argv[3])
-      return console.log(toHex(bin))
-    }
-
-    case 'bin2json': {
-      const { argv, pretty } = argvPretty()
-      /* c8 ignore next 1 */
-      const bin = argv.length < 4 ? (await fromStdin()) : new TextEncoder().encode(argv[3])
-      return console.log(JSON.stringify(decode(bin), undefined, pretty ? 2 : undefined))
-    }
-
-    case 'diag2bin': {
-      // no coverage on windows for non-stdin input
-      /* c8 ignore next 1 */
-      const bin = fromDiag(process.argv.length < 4 ? (await fromStdin()).toString() : process.argv[3])
-      return process.stdout.write(bin)
-    }
-
-    case 'diag2hex': {
-      // no coverage on windows for non-stdin input
-      /* c8 ignore next 1 */
-      const bin = fromDiag(process.argv.length < 4 ? (await fromStdin()).toString() : process.argv[3])
-      return console.log(toHex(bin))
-    }
-
-    case 'diag2json': {
-      const { argv, pretty } = argvPretty()
-      // no coverage on windows for non-stdin input
-      /* c8 ignore next 1 */
-      const bin = fromDiag(argv.length < 4 ? (await fromStdin()).toString() : argv[3])
-      return console.log(JSON.stringify(decode(bin), undefined, pretty ? 2 : undefined))
-    }
-
-    case 'hex2bin': {
-      // this is really nothing to do with cbor.. just handy
-      const bin = fromHex(process.argv.length < 4 ? (await fromStdin()).toString() : process.argv[3])
-      return process.stdout.write(bin)
-    }
-
-    case 'hex2diag': {
-      const { argv, width } = argvWidth()
-      const bin = fromHex(argv.length < 4 ? (await fromStdin()).toString() : argv[3])
-      for (const line of tokensToDiagnostic(bin, width)) {
-        console.log(line)
-      }
-      return
-    }
-
-    case 'hex2json': {
-      const { argv, pretty } = argvPretty()
-      const bin = fromHex(argv.length < 4 ? (await fromStdin()).toString() : argv[3])
-      return console.log(JSON.stringify(decode(bin), undefined, pretty ? 2 : undefined))
-    }
-
-    case 'json2bin': {
-      const inp = process.argv.length < 4 ? (await fromStdin()).toString() : process.argv[3]
-      const obj = JSON.parse(inp)
-      return process.stdout.write(encode(obj))
-    }
-
-    case 'json2diag': {
-      const { argv, width } = argvWidth()
-      const inp = argv.length < 4 ? (await fromStdin()).toString() : argv[3]
-      const obj = JSON.parse(inp)
-      for (const line of tokensToDiagnostic(encode(obj), width)) {
-        console.log(line)
-      }
-      return
-    }
-
-    case 'json2hex': {
-      const inp = process.argv.length < 4 ? (await fromStdin()).toString() : process.argv[3]
-      const obj = JSON.parse(inp)
-      return console.log(toHex(encode(obj)))
-    }
-
-    default: { // no, or unknown cmd
-      // this is a dirty hack to allow import of this package by the tests
-      // for inclusion in ipjs bundling, but to silently ignore it so we don't
-      // print usage and exit(1).
-      if (process.argv.findIndex((a) => a.endsWith('mocha')) === -1) {
-        if (cmd) {
-          console.error(`Unknown command: '${cmd}'`)
-        }
-        usage(1)
-      }
-    }
-  }
-}
-
-run().catch((err) => {
-  /* c8 ignore next 2 */
-  console.error(err)
-  process.exit(1)
-})
-
-// for ipjs, to get it to compile
-export default true

package/patched/cborg/lib/common.js

@@ -1,27 +0,0 @@
-const decodeErrPrefix = 'CBOR decode error:'
-const encodeErrPrefix = 'CBOR encode error:'
-
-const uintMinorPrefixBytes = []
-uintMinorPrefixBytes[23] = 1
-uintMinorPrefixBytes[24] = 2
-uintMinorPrefixBytes[25] = 3
-uintMinorPrefixBytes[26] = 5
-uintMinorPrefixBytes[27] = 9
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} need
- */
-function assertEnoughData (data, pos, need) {
-  if (data.length - pos < need) {
-    throw new Error(`${decodeErrPrefix} not enough data for type`)
-  }
-}
-
-export {
-  decodeErrPrefix,
-  encodeErrPrefix,
-  uintMinorPrefixBytes,
-  assertEnoughData
-}

package/patched/cborg/lib/diagnostic.js

@@ -1,156 +0,0 @@
-import { Tokeniser } from './decode.js'
-import { Type } from './token.js'
-import { toHex, fromHex } from './byte-utils.js'
-import { uintBoundaries } from './0uint.js'
-
-const utf8Encoder = new TextEncoder()
-const utf8Decoder = new TextDecoder()
-
-/**
- * @param {Uint8Array} inp
- * @param {number} [width]
- */
-function * tokensToDiagnostic (inp, width = 100) {
-  const tokeniser = new Tokeniser(inp, { retainStringBytes: true, allowBigInt: true })
-  let pos = 0
-  const indent = []
-
-  /**
-   * @param {number} start
-   * @param {number} length
-   * @returns {string}
-   */
-  const slc = (start, length) => {
-    return toHex(inp.slice(pos + start, pos + start + length))
-  }
-
-  while (!tokeniser.done()) {
-    const token = tokeniser.next()
-    let margin = ''.padStart(indent.length * 2, ' ')
-    // @ts-ignore should be safe for decode
-    let vLength = token.encodedLength - 1
-    /** @type {string|number} */
-    let v = String(token.value)
-    let outp = `${margin}${slc(0, 1)}`
-    const str = token.type.equals(Type.bytes) || token.type.equals(Type.string)
-    if (token.type.equals(Type.string)) {
-      v = v.length
-      vLength -= v
-    } else if (token.type.equals(Type.bytes)) {
-      v = token.value.length
-      // @ts-ignore
-      vLength -= v
-    }
-
-    let multilen
-    switch (token.type.name) {
-      case Type.string.name:
-      case Type.bytes.name:
-      case Type.map.name:
-      case Type.array.name:
-        // for bytes and string, we want to print out the length part of the value prefix if it
-        // exists - it exists for short lengths (<24) but does for longer lengths
-        multilen = token.type.equals(Type.string) ? utf8Encoder.encode(token.value).length : token.value.length
-        if (multilen >= uintBoundaries[0]) {
-          if (multilen < uintBoundaries[1]) {
-            outp += ` ${slc(1, 1)}`
-          } else if (multilen < uintBoundaries[2]) {
-            outp += ` ${slc(1, 2)}`
-            /* c8 ignore next 5 */
-          } else if (multilen < uintBoundaries[3]) { // sus
-            outp += ` ${slc(1, 4)}`
-          } else if (multilen < uintBoundaries[4]) { // orly?
-            outp += ` ${slc(1, 8)}`
-          }
-        }
-        break
-      default:
-        // print the value if it's not compacted into the first byte
-        outp += ` ${slc(1, vLength)}`
-        break
-    }
-
-    outp = outp.padEnd(width / 2, ' ')
-    outp += `# ${margin}${token.type.name}`
-    // there should be a method to get a Type from a String
-    if (token.type.name !== v) {
-      outp += `(${v})`
-    }
-    yield outp
-
-    if (str) {
-      let asString = token.type.equals(Type.string)
-      margin += '  '
-      let repr = asString ? utf8Encoder.encode(token.value) : token.value
-      if (asString && token.byteValue !== undefined) {
-        if (repr.length !== token.byteValue.length) {
-          // bail on printing this as a string, it's probably not utf8, so treat it as bytes
-          // (you can probably blame a Go programmer for this)
-          repr = token.byteValue
-          asString = false
-        }
-      }
-      const wh = ((width / 2) - margin.length - 1) / 2
-      let snip = 0
-      while (repr.length - snip > 0) {
-        const piece = repr.slice(snip, snip + wh)
-        snip += piece.length
-        const st = asString
-          ? utf8Decoder.decode(piece)
-          : piece.reduce((/** @type {string} */ p, /** @type {number} */ c) => {
-            if (c < 0x20 || (c >= 0x7f && c < 0xa1) || c === 0xad) {
-              return `${p}\\x${c.toString(16).padStart(2, '0')}`
-            }
-            return `${p}${String.fromCharCode(c)}`
-          }, '')
-        yield `${margin}${toHex(piece)}`.padEnd(width / 2, ' ') + `# ${margin}"${st}"`
-      }
-    }
-
-    if (indent.length) {
-      indent[indent.length - 1]--
-    }
-    if (!token.type.terminal) {
-      switch (token.type.name) {
-        case Type.map.name:
-          indent.push(token.value * 2)
-          break
-        case Type.array.name:
-          indent.push(token.value)
-          break
-        // TODO: test tags .. somehow
-        /* c8 ignore next 5 */
-        case Type.tag.name:
-          indent.push(1)
-          break
-        default:
-          throw new Error(`Unknown token type '${token.type.name}'`)
-      }
-    }
-    while (indent.length && indent[indent.length - 1] <= 0) {
-      indent.pop()
-    }
-    // @ts-ignore it should be set on a decode operation
-    pos += token.encodedLength
-  }
-}
-
-/**
- * Convert an input string formatted as CBOR diagnostic output into binary CBOR form.
- * @param {string} input
- * @returns {Uint8Array}
- */
-function fromDiag (input) {
-  /* c8 ignore next 3 */
-  if (typeof input !== 'string') {
-    throw new TypeError('Expected string input')
-  }
-  input = input.replace(/#.*?$/mg, '').replace(/[\s\r\n]+/mg, '')
-  /* c8 ignore next 3 */
-  if (/[^a-f0-9]/i.test(input)) {
-    throw new TypeError('Input string was not CBOR diagnostic format')
-  }
-  return fromHex(input)
-}
-
-export { tokensToDiagnostic, fromDiag }