@fireproof/vendor 0.0.0-smoke → 0.22.0-dev-preview

package/patched/cborg/lib/1negint.js

@@ -1,111 +0,0 @@
-/* eslint-env es2020 */
-
-import { Token, Type } from './token.js'
-import * as uint from './0uint.js'
-import { decodeErrPrefix } from './common.js'
-
-/**
- * @typedef {import('./bl.js').Bl} Bl
- * @typedef {import('../interface').DecodeOptions} DecodeOptions
- */
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} _minor
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-export function decodeNegint8 (data, pos, _minor, options) {
-  return new Token(Type.negint, -1 - uint.readUint8(data, pos + 1, options), 2)
-}
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} _minor
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-export function decodeNegint16 (data, pos, _minor, options) {
-  return new Token(Type.negint, -1 - uint.readUint16(data, pos + 1, options), 3)
-}
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} _minor
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-export function decodeNegint32 (data, pos, _minor, options) {
-  return new Token(Type.negint, -1 - uint.readUint32(data, pos + 1, options), 5)
-}
-
-const neg1b = BigInt(-1)
-const pos1b = BigInt(1)
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} _minor
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-export function decodeNegint64 (data, pos, _minor, options) {
-  const int = uint.readUint64(data, pos + 1, options)
-  if (typeof int !== 'bigint') {
-    const value = -1 - int
-    if (value >= Number.MIN_SAFE_INTEGER) {
-      return new Token(Type.negint, value, 9)
-    }
-  }
-  if (options.allowBigInt !== true) {
-    throw new Error(`${decodeErrPrefix} integers outside of the safe integer range are not supported`)
-  }
-  return new Token(Type.negint, neg1b - BigInt(int), 9)
-}
-
-/**
- * @param {Bl} buf
- * @param {Token} token
- */
-export function encodeNegint (buf, token) {
-  const negint = token.value
-  const unsigned = (typeof negint === 'bigint' ? (negint * neg1b - pos1b) : (negint * -1 - 1))
-  uint.encodeUintValue(buf, token.type.majorEncoded, unsigned)
-}
-
-/**
- * @param {Token} token
- * @returns {number}
- */
-encodeNegint.encodedSize = function encodedSize (token) {
-  const negint = token.value
-  const unsigned = (typeof negint === 'bigint' ? (negint * neg1b - pos1b) : (negint * -1 - 1))
-  /* c8 ignore next 4 */
-  // handled by quickEncode, we shouldn't get here but it's included for completeness
-  if (unsigned < uint.uintBoundaries[0]) {
-    return 1
-  }
-  if (unsigned < uint.uintBoundaries[1]) {
-    return 2
-  }
-  if (unsigned < uint.uintBoundaries[2]) {
-    return 3
-  }
-  if (unsigned < uint.uintBoundaries[3]) {
-    return 5
-  }
-  return 9
-}
-
-/**
- * @param {Token} tok1
- * @param {Token} tok2
- * @returns {number}
- */
-encodeNegint.compareTokens = function compareTokens (tok1, tok2) {
-  // opposite of the uint comparison since we store the uint version in bytes
-  return tok1.value < tok2.value ? 1 : tok1.value > tok2.value ? -1 : /* c8 ignore next */ 0
-}

package/patched/cborg/lib/2bytes.js

@@ -1,133 +0,0 @@
-import { Token, Type } from './token.js'
-import { assertEnoughData, decodeErrPrefix } from './common.js'
-import * as uint from './0uint.js'
-import { compare, fromString, slice } from './byte-utils.js'
-
-/**
- * @typedef {import('./bl.js').Bl} Bl
- * @typedef {import('../interface').DecodeOptions} DecodeOptions
- */
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} prefix
- * @param {number} length
- * @returns {Token}
- */
-function toToken (data, pos, prefix, length) {
-  assertEnoughData(data, pos, prefix + length)
-  const buf = slice(data, pos + prefix, pos + prefix + length)
-  return new Token(Type.bytes, buf, prefix + length)
-}
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} minor
- * @param {DecodeOptions} _options
- * @returns {Token}
- */
-export function decodeBytesCompact (data, pos, minor, _options) {
-  return toToken(data, pos, 1, minor)
-}
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} _minor
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-export function decodeBytes8 (data, pos, _minor, options) {
-  return toToken(data, pos, 2, uint.readUint8(data, pos + 1, options))
-}
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} _minor
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-export function decodeBytes16 (data, pos, _minor, options) {
-  return toToken(data, pos, 3, uint.readUint16(data, pos + 1, options))
-}
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} _minor
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-export function decodeBytes32 (data, pos, _minor, options) {
-  return toToken(data, pos, 5, uint.readUint32(data, pos + 1, options))
-}
-
-// TODO: maybe we shouldn't support this ..
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} _minor
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-export function decodeBytes64 (data, pos, _minor, options) {
-  const l = uint.readUint64(data, pos + 1, options)
-  if (typeof l === 'bigint') {
-    throw new Error(`${decodeErrPrefix} 64-bit integer bytes lengths not supported`)
-  }
-  return toToken(data, pos, 9, l)
-}
-
-/**
- * `encodedBytes` allows for caching when we do a byte version of a string
- * for key sorting purposes
- * @param {Token} token
- * @returns {Uint8Array}
- */
-function tokenBytes (token) {
-  if (token.encodedBytes === undefined) {
-    token.encodedBytes = token.type.equals(Type.string) ? fromString(token.value) : token.value
-  }
-  // @ts-ignore c'mon
-  return token.encodedBytes
-}
-
-/**
- * @param {Bl} buf
- * @param {Token} token
- */
-export function encodeBytes (buf, token) {
-  const bytes = tokenBytes(token)
-  uint.encodeUintValue(buf, token.type.majorEncoded, bytes.length)
-  buf.push(bytes)
-}
-
-/**
- * @param {Token} token
- * @returns {number}
- */
-encodeBytes.encodedSize = function encodedSize (token) {
-  const bytes = tokenBytes(token)
-  return uint.encodeUintValue.encodedSize(bytes.length) + bytes.length
-}
-
-/**
- * @param {Token} tok1
- * @param {Token} tok2
- * @returns {number}
- */
-encodeBytes.compareTokens = function compareTokens (tok1, tok2) {
-  return compareBytes(tokenBytes(tok1), tokenBytes(tok2))
-}
-
-/**
- * @param {Uint8Array} b1
- * @param {Uint8Array} b2
- * @returns {number}
- */
-export function compareBytes (b1, b2) {
-  return b1.length < b2.length ? -1 : b1.length > b2.length ? 1 : compare(b1, b2)
-}

package/patched/cborg/lib/3string.js

@@ -1,90 +0,0 @@
-import { Token, Type } from './token.js'
-import { assertEnoughData, decodeErrPrefix } from './common.js'
-import * as uint from './0uint.js'
-import { encodeBytes } from './2bytes.js'
-import { toString, slice } from './byte-utils.js'
-
-/**
- * @typedef {import('./bl.js').Bl} Bl
- * @typedef {import('../interface').DecodeOptions} DecodeOptions
- */
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} prefix
- * @param {number} length
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-function toToken (data, pos, prefix, length, options) {
-  const totLength = prefix + length
-  assertEnoughData(data, pos, totLength)
-  const tok = new Token(Type.string, toString(data, pos + prefix, pos + totLength), totLength)
-  if (options.retainStringBytes === true) {
-    tok.byteValue = slice(data, pos + prefix, pos + totLength)
-  }
-  return tok
-}
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} minor
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-export function decodeStringCompact (data, pos, minor, options) {
-  return toToken(data, pos, 1, minor, options)
-}
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} _minor
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-export function decodeString8 (data, pos, _minor, options) {
-  return toToken(data, pos, 2, uint.readUint8(data, pos + 1, options), options)
-}
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} _minor
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-export function decodeString16 (data, pos, _minor, options) {
-  return toToken(data, pos, 3, uint.readUint16(data, pos + 1, options), options)
-}
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} _minor
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-export function decodeString32 (data, pos, _minor, options) {
-  return toToken(data, pos, 5, uint.readUint32(data, pos + 1, options), options)
-}
-
-// TODO: maybe we shouldn't support this ..
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} _minor
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-export function decodeString64 (data, pos, _minor, options) {
-  const l = uint.readUint64(data, pos + 1, options)
-  if (typeof l === 'bigint') {
-    throw new Error(`${decodeErrPrefix} 64-bit integer string lengths not supported`)
-  }
-  return toToken(data, pos, 9, l, options)
-}
-
-export const encodeString = encodeBytes

package/patched/cborg/lib/4array.js

@@ -1,113 +0,0 @@
-import { Token, Type } from './token.js'
-import * as uint from './0uint.js'
-import { decodeErrPrefix } from './common.js'
-
-/**
- * @typedef {import('./bl.js').Bl} Bl
- * @typedef {import('../interface').DecodeOptions} DecodeOptions
- */
-
-/**
- * @param {Uint8Array} _data
- * @param {number} _pos
- * @param {number} prefix
- * @param {number} length
- * @returns {Token}
- */
-function toToken (_data, _pos, prefix, length) {
-  return new Token(Type.array, length, prefix)
-}
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} minor
- * @param {DecodeOptions} _options
- * @returns {Token}
- */
-export function decodeArrayCompact (data, pos, minor, _options) {
-  return toToken(data, pos, 1, minor)
-}
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} _minor
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-export function decodeArray8 (data, pos, _minor, options) {
-  return toToken(data, pos, 2, uint.readUint8(data, pos + 1, options))
-}
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} _minor
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-export function decodeArray16 (data, pos, _minor, options) {
-  return toToken(data, pos, 3, uint.readUint16(data, pos + 1, options))
-}
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} _minor
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-export function decodeArray32 (data, pos, _minor, options) {
-  return toToken(data, pos, 5, uint.readUint32(data, pos + 1, options))
-}
-
-// TODO: maybe we shouldn't support this ..
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} _minor
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-export function decodeArray64 (data, pos, _minor, options) {
-  const l = uint.readUint64(data, pos + 1, options)
-  if (typeof l === 'bigint') {
-    throw new Error(`${decodeErrPrefix} 64-bit integer array lengths not supported`)
-  }
-  return toToken(data, pos, 9, l)
-}
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} _minor
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-export function decodeArrayIndefinite (data, pos, _minor, options) {
-  if (options.allowIndefinite === false) {
-    throw new Error(`${decodeErrPrefix} indefinite length items not allowed`)
-  }
-  return toToken(data, pos, 1, Infinity)
-}
-
-/**
- * @param {Bl} buf
- * @param {Token} token
- */
-export function encodeArray (buf, token) {
-  uint.encodeUintValue(buf, Type.array.majorEncoded, token.value)
-}
-
-// using an array as a map key, are you sure about this? we can only sort
-// by map length here, it's up to the encoder to decide to look deeper
-encodeArray.compareTokens = uint.encodeUint.compareTokens
-
-/**
- * @param {Token} token
- * @returns {number}
- */
-encodeArray.encodedSize = function encodedSize (token) {
-  return uint.encodeUintValue.encodedSize(token.value)
-}

package/patched/cborg/lib/5map.js

@@ -1,113 +0,0 @@
-import { Token, Type } from './token.js'
-import * as uint from './0uint.js'
-import { decodeErrPrefix } from './common.js'
-
-/**
- * @typedef {import('./bl.js').Bl} Bl
- * @typedef {import('../interface').DecodeOptions} DecodeOptions
- */
-
-/**
- * @param {Uint8Array} _data
- * @param {number} _pos
- * @param {number} prefix
- * @param {number} length
- * @returns {Token}
- */
-function toToken (_data, _pos, prefix, length) {
-  return new Token(Type.map, length, prefix)
-}
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} minor
- * @param {DecodeOptions} _options
- * @returns {Token}
- */
-export function decodeMapCompact (data, pos, minor, _options) {
-  return toToken(data, pos, 1, minor)
-}
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} _minor
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-export function decodeMap8 (data, pos, _minor, options) {
-  return toToken(data, pos, 2, uint.readUint8(data, pos + 1, options))
-}
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} _minor
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-export function decodeMap16 (data, pos, _minor, options) {
-  return toToken(data, pos, 3, uint.readUint16(data, pos + 1, options))
-}
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} _minor
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-export function decodeMap32 (data, pos, _minor, options) {
-  return toToken(data, pos, 5, uint.readUint32(data, pos + 1, options))
-}
-
-// TODO: maybe we shouldn't support this ..
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} _minor
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-export function decodeMap64 (data, pos, _minor, options) {
-  const l = uint.readUint64(data, pos + 1, options)
-  if (typeof l === 'bigint') {
-    throw new Error(`${decodeErrPrefix} 64-bit integer map lengths not supported`)
-  }
-  return toToken(data, pos, 9, l)
-}
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} _minor
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-export function decodeMapIndefinite (data, pos, _minor, options) {
-  if (options.allowIndefinite === false) {
-    throw new Error(`${decodeErrPrefix} indefinite length items not allowed`)
-  }
-  return toToken(data, pos, 1, Infinity)
-}
-
-/**
- * @param {Bl} buf
- * @param {Token} token
- */
-export function encodeMap (buf, token) {
-  uint.encodeUintValue(buf, Type.map.majorEncoded, token.value)
-}
-
-// using a map as a map key, are you sure about this? we can only sort
-// by map length here, it's up to the encoder to decide to look deeper
-encodeMap.compareTokens = uint.encodeUint.compareTokens
-
-/**
- * @param {Token} token
- * @returns {number}
- */
-encodeMap.encodedSize = function encodedSize (token) {
-  return uint.encodeUintValue.encodedSize(token.value)
-}

package/patched/cborg/lib/6tag.js

@@ -1,80 +0,0 @@
-import { Token, Type } from './token.js'
-import * as uint from './0uint.js'
-
-/**
- * @typedef {import('./bl.js').Bl} Bl
- * @typedef {import('../interface').DecodeOptions} DecodeOptions
- */
-
-/**
- * @param {Uint8Array} _data
- * @param {number} _pos
- * @param {number} minor
- * @param {DecodeOptions} _options
- * @returns {Token}
- */
-export function decodeTagCompact (_data, _pos, minor, _options) {
-  return new Token(Type.tag, minor, 1)
-}
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} _minor
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-export function decodeTag8 (data, pos, _minor, options) {
-  return new Token(Type.tag, uint.readUint8(data, pos + 1, options), 2)
-}
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} _minor
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-export function decodeTag16 (data, pos, _minor, options) {
-  return new Token(Type.tag, uint.readUint16(data, pos + 1, options), 3)
-}
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} _minor
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-export function decodeTag32 (data, pos, _minor, options) {
-  return new Token(Type.tag, uint.readUint32(data, pos + 1, options), 5)
-}
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} _minor
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-export function decodeTag64 (data, pos, _minor, options) {
-  return new Token(Type.tag, uint.readUint64(data, pos + 1, options), 9)
-}
-
-/**
- * @param {Bl} buf
- * @param {Token} token
- */
-export function encodeTag (buf, token) {
-  uint.encodeUintValue(buf, Type.tag.majorEncoded, token.value)
-}
-
-encodeTag.compareTokens = uint.encodeUint.compareTokens
-
-/**
- * @param {Token} token
- * @returns {number}
- */
-encodeTag.encodedSize = function encodedSize (token) {
-  return uint.encodeUintValue.encodedSize(token.value)
-}