@fireproof/vendor 1.0.3 → 1.1.0-dev

package/src/cborg/cborg/encode.js

@@ -1,466 +0,0 @@
-import { is } from './is.js'
-import {
-  Token, Type, Bl,
-  quickEncodeToken,
-  asU8A,
-  encodeUint,
-  encodeNegint,
-  encodeBytes,
-  encodeString,
-  encodeArray,
-  encodeMap,
-  encodeTag,
-  encodeFloat
-} from "@fireproof/vendor/cborg/utils"
-
-/**
- * @typedef {import('../interface').EncodeOptions} EncodeOptions
- * @typedef {import('../interface').OptionalTypeEncoder} OptionalTypeEncoder
- * @typedef {import('../interface').Reference} Reference
- * @typedef {import('../interface').StrictTypeEncoder} StrictTypeEncoder
- * @typedef {import('../interface').TokenTypeEncoder} TokenTypeEncoder
- * @typedef {import('../interface').TokenOrNestedTokens} TokenOrNestedTokens
- */
-
-/** @type {EncodeOptions} */
-const defaultEncodeOptions = {
-  float64: false,
-  mapSorter,
-  quickEncodeToken,
-  encodeErrPrefix: 'CBOR encode error:'
-
-}
-
-/** @returns {TokenTypeEncoder[]} */
-export function makeCborEncoders () {
-  const encoders = []
-  encoders[Type.uint.major] = encodeUint
-  encoders[Type.negint.major] = encodeNegint
-  encoders[Type.bytes.major] = encodeBytes
-  encoders[Type.string.major] = encodeString
-  encoders[Type.array.major] = encodeArray
-  encoders[Type.map.major] = encodeMap
-  encoders[Type.tag.major] = encodeTag
-  encoders[Type.float.major] = encodeFloat
-  return encoders
-}
-
-const cborEncoders = makeCborEncoders()
-
-const buf = new Bl()
-
-/** @implements {Reference} */
-class Ref {
-  /**
-   * @param {object|any[]} obj
-   * @param {Reference|undefined} parent
-   */
-  constructor (obj, parent) {
-    this.obj = obj
-    this.parent = parent
-  }
-
-  /**
-   * @param {object|any[]} obj
-   * @returns {boolean}
-   */
-  includes (obj) {
-    /** @type {Reference|undefined} */
-    let p = this
-    do {
-      if (p.obj === obj) {
-        return true
-      }
-    } while (p = p.parent) // eslint-disable-line
-    return false
-  }
-
-  /**
-   * @param {Reference|undefined} stack
-   * @param {object|any[]} obj
-   * @param {EncodeOptions} options
-   * @returns {Reference}
-   */
-  static createCheck (stack, obj, { encodeErrPrefix }) {
-    if (stack && stack.includes(obj)) {
-      throw new Error(`${encodeErrPrefix} object contains circular references`)
-    }
-    return new Ref(obj, stack)
-  }
-}
-
-const simpleTokens = {
-  null: new Token(Type.null, null),
-  undefined: new Token(Type.undefined, undefined),
-  true: new Token(Type.true, true),
-  false: new Token(Type.false, false),
-  emptyArray: new Token(Type.array, 0),
-  emptyMap: new Token(Type.map, 0)
-}
-
-/** @type {{[typeName: string]: StrictTypeEncoder}} */
-const typeEncoders = {
-  /**
-   * @param {any} obj
-   * @param {string} _typ
-   * @param {EncodeOptions} _options
-   * @param {Reference} [_refStack]
-   * @returns {TokenOrNestedTokens}
-   */
-  number (obj, _typ, _options, _refStack) {
-    if (!Number.isInteger(obj) || !Number.isSafeInteger(obj)) {
-      return new Token(Type.float, obj)
-    } else if (obj >= 0) {
-      return new Token(Type.uint, obj)
-    } else {
-      return new Token(Type.negint, obj)
-    }
-  },
-
-  /**
-   * @param {any} obj
-   * @param {string} _typ
-   * @param {EncodeOptions} _options
-   * @param {Reference} [_refStack]
-   * @returns {TokenOrNestedTokens}
-   */
-  bigint (obj, _typ, _options, _refStack) {
-    if (obj >= BigInt(0)) {
-      return new Token(Type.uint, obj)
-    } else {
-      return new Token(Type.negint, obj)
-    }
-  },
-
-  /**
-   * @param {any} obj
-   * @param {string} _typ
-   * @param {EncodeOptions} _options
-   * @param {Reference} [_refStack]
-   * @returns {TokenOrNestedTokens}
-   */
-  Uint8Array (obj, _typ, _options, _refStack) {
-    return new Token(Type.bytes, obj)
-  },
-
-  /**
-   * @param {any} obj
-   * @param {string} _typ
-   * @param {EncodeOptions} _options
-   * @param {Reference} [_refStack]
-   * @returns {TokenOrNestedTokens}
-   */
-  string (obj, _typ, _options, _refStack) {
-    return new Token(Type.string, obj)
-  },
-
-  /**
-   * @param {any} obj
-   * @param {string} _typ
-   * @param {EncodeOptions} _options
-   * @param {Reference} [_refStack]
-   * @returns {TokenOrNestedTokens}
-   */
-  boolean (obj, _typ, _options, _refStack) {
-    return obj ? simpleTokens.true : simpleTokens.false
-  },
-
-  /**
-   * @param {any} _obj
-   * @param {string} _typ
-   * @param {EncodeOptions} _options
-   * @param {Reference} [_refStack]
-   * @returns {TokenOrNestedTokens}
-   */
-  null (_obj, _typ, _options, _refStack) {
-    return simpleTokens.null
-  },
-
-  /**
-   * @param {any} _obj
-   * @param {string} _typ
-   * @param {EncodeOptions} _options
-   * @param {Reference} [_refStack]
-   * @returns {TokenOrNestedTokens}
-   */
-  undefined (_obj, _typ, _options, _refStack) {
-    return simpleTokens.undefined
-  },
-
-  /**
-   * @param {any} obj
-   * @param {string} _typ
-   * @param {EncodeOptions} _options
-   * @param {Reference} [_refStack]
-   * @returns {TokenOrNestedTokens}
-   */
-  ArrayBuffer (obj, _typ, _options, _refStack) {
-    return new Token(Type.bytes, new Uint8Array(obj))
-  },
-
-  /**
-   * @param {any} obj
-   * @param {string} _typ
-   * @param {EncodeOptions} _options
-   * @param {Reference} [_refStack]
-   * @returns {TokenOrNestedTokens}
-   */
-  DataView (obj, _typ, _options, _refStack) {
-    return new Token(Type.bytes, new Uint8Array(obj.buffer, obj.byteOffset, obj.byteLength))
-  },
-
-  /**
-   * @param {any} obj
-   * @param {string} _typ
-   * @param {EncodeOptions} options
-   * @param {Reference} [refStack]
-   * @returns {TokenOrNestedTokens}
-   */
-  Array (obj, _typ, options, refStack) {
-    if (!obj.length) {
-      if (options.addBreakTokens === true) {
-        return [simpleTokens.emptyArray, new Token(Type.break)]
-      }
-      return simpleTokens.emptyArray
-    }
-    refStack = Ref.createCheck(refStack, obj, options)
-    const entries = []
-    let i = 0
-    for (const e of obj) {
-      entries[i++] = objectToTokens(e, options, refStack)
-    }
-    if (options.addBreakTokens) {
-      return [new Token(Type.array, obj.length), entries, new Token(Type.break)]
-    }
-    return [new Token(Type.array, obj.length), entries]
-  },
-
-  /**
-   * @param {any} obj
-   * @param {string} typ
-   * @param {EncodeOptions} options
-   * @param {Reference} [refStack]
-   * @returns {TokenOrNestedTokens}
-   */
-  Object (obj, typ, options, refStack) {
-    // could be an Object or a Map
-    const isMap = typ !== 'Object'
-    // it's slightly quicker to use Object.keys() than Object.entries()
-    const keys = isMap ? obj.keys() : Object.keys(obj)
-    const length = isMap ? obj.size : keys.length
-    if (!length) {
-      if (options.addBreakTokens === true) {
-        return [simpleTokens.emptyMap, new Token(Type.break)]
-      }
-      return simpleTokens.emptyMap
-    }
-    refStack = Ref.createCheck(refStack, obj, options)
-    /** @type {TokenOrNestedTokens[]} */
-    const entries = []
-    let i = 0
-    for (const key of keys) {
-      entries[i++] = [
-        objectToTokens(key, options, refStack),
-        objectToTokens(isMap ? obj.get(key) : obj[key], options, refStack)
-      ]
-    }
-    sortMapEntries(entries, options)
-    if (options.addBreakTokens) {
-      return [new Token(Type.map, length), entries, new Token(Type.break)]
-    }
-    return [new Token(Type.map, length), entries]
-  }
-}
-
-typeEncoders.Map = typeEncoders.Object
-typeEncoders.Buffer = typeEncoders.Uint8Array
-for (const typ of 'Uint8Clamped Uint16 Uint32 Int8 Int16 Int32 BigUint64 BigInt64 Float32 Float64'.split(' ')) {
-  typeEncoders[`${typ}Array`] = typeEncoders.DataView
-}
-
-/**
- * @param {any} obj
- * @param {EncodeOptions} options
- * @param {Reference} [refStack]
- * @returns {TokenOrNestedTokens}
- */
-function objectToTokens (obj, options, refStack) {
-  const typ = is(obj)
-  const customTypeEncoder = (options && options.typeEncoders && /** @type {OptionalTypeEncoder} */ options.typeEncoders[typ]) || typeEncoders[typ]
-  if (typeof customTypeEncoder === 'function') {
-    const tokens = customTypeEncoder(obj, typ, options, refStack)
-    if (tokens != null) {
-      return tokens
-    }
-  }
-  const typeEncoder = typeEncoders[typ]
-  if (!typeEncoder) {
-    throw new Error(`${options.encodeErrPrefix} unsupported type: ${typ}`)
-  }
-  return typeEncoder(obj, typ, options, refStack)
-}
-
-/*
-CBOR key sorting is a mess.
-
-The canonicalisation recommendation from https://tools.ietf.org/html/rfc7049#section-3.9
-includes the wording:
-
-> The keys in every map must be sorted lowest value to highest.
-> Sorting is performed on the bytes of the representation of the key
-> data items without paying attention to the 3/5 bit splitting for
-> major types.
-> ...
->  *  If two keys have different lengths, the shorter one sorts
-      earlier;
->  *  If two keys have the same length, the one with the lower value
-      in (byte-wise) lexical order sorts earlier.
-
-1. It is not clear what "bytes of the representation of the key" means: is it
-   the CBOR representation, or the binary representation of the object itself?
-   Consider the int and uint difference here.
-2. It is not clear what "without paying attention to" means: do we include it
-   and compare on that? Or do we omit the special prefix byte, (mostly) treating
-   the key in its plain binary representation form.
-
-The FIDO 2.0: Client To Authenticator Protocol spec takes the original CBOR
-wording and clarifies it according to their understanding.
-https://fidoalliance.org/specs/fido-v2.0-rd-20170927/fido-client-to-authenticator-protocol-v2.0-rd-20170927.html#message-encoding
-
-> The keys in every map must be sorted lowest value to highest. Sorting is
-> performed on the bytes of the representation of the key data items without
-> paying attention to the 3/5 bit splitting for major types. The sorting rules
-> are:
->  * If the major types are different, the one with the lower value in numerical
->    order sorts earlier.
->  * If two keys have different lengths, the shorter one sorts earlier;
->  * If two keys have the same length, the one with the lower value in
->    (byte-wise) lexical order sorts earlier.
-
-Some other implementations, such as borc, do a full encode then do a
-length-first, byte-wise-second comparison:
-https://github.com/dignifiedquire/borc/blob/b6bae8b0bcde7c3976b0f0f0957208095c392a36/src/encoder.js#L358
-https://github.com/dignifiedquire/borc/blob/b6bae8b0bcde7c3976b0f0f0957208095c392a36/src/utils.js#L143-L151
-
-This has the benefit of being able to easily handle arbitrary keys, including
-complex types (maps and arrays).
-
-We'll opt for the FIDO approach, since it affords some efficies since we don't
-need a full encode of each key to determine order and can defer to the types
-to determine how to most efficiently order their values (i.e. int and uint
-ordering can be done on the numbers, no need for byte-wise, for example).
-
-Recommendation: stick to single key types or you'll get into trouble, and prefer
-string keys because it's much simpler that way.
-*/
-
-/*
-(UPDATE, Dec 2020)
-https://tools.ietf.org/html/rfc8949 is the updated CBOR spec and clarifies some
-of the questions above with a new recommendation for sorting order being much
-closer to what would be expected in other environments (i.e. no length-first
-weirdness).
-This new sorting order is not yet implemented here but could be added as an
-option. "Determinism" (canonicity) is system dependent and it's difficult to
-change existing systems that are built with existing expectations. So if a new
-ordering is introduced here, the old needs to be kept as well with the user
-having the option.
-*/
-
-/**
- * @param {TokenOrNestedTokens[]} entries
- * @param {EncodeOptions} options
- */
-function sortMapEntries (entries, options) {
-  if (options.mapSorter) {
-    entries.sort(options.mapSorter)
-  }
-}
-
-/**
- * @param {(Token|Token[])[]} e1
- * @param {(Token|Token[])[]} e2
- * @returns {number}
- */
-function mapSorter (e1, e2) {
-  // the key position ([0]) could have a single token or an array
-  // almost always it'll be a single token but complex key might get involved
-  /* c8 ignore next 2 */
-  const keyToken1 = Array.isArray(e1[0]) ? e1[0][0] : e1[0]
-  const keyToken2 = Array.isArray(e2[0]) ? e2[0][0] : e2[0]
-
-  // different key types
-  if (keyToken1.type !== keyToken2.type) {
-    return keyToken1.type.compare(keyToken2.type)
-  }
-
-  const major = keyToken1.type.major
-  // TODO: handle case where cmp === 0 but there are more keyToken e. complex type)
-  const tcmp = cborEncoders[major].compareTokens(keyToken1, keyToken2)
-  /* c8 ignore next 5 */
-  if (tcmp === 0) {
-    // duplicate key or complex type where the first token matched,
-    // i.e. a map or array and we're only comparing the opening token
-    console.warn('WARNING: complex key types used, CBOR key sorting guarantees are gone')
-  }
-  return tcmp
-}
-
-/**
- * @param {Bl} buf
- * @param {TokenOrNestedTokens} tokens
- * @param {TokenTypeEncoder[]} encoders
- * @param {EncodeOptions} options
- */
-function tokensToEncoded (buf, tokens, encoders, options) {
-  if (Array.isArray(tokens)) {
-    for (const token of tokens) {
-      tokensToEncoded(buf, token, encoders, options)
-    }
-  } else {
-    encoders[tokens.type.major](buf, tokens, options)
-  }
-}
-
-/**
- * @param {any} data
- * @param {TokenTypeEncoder[]} encoders
- * @param {EncodeOptions} options
- * @returns {Uint8Array}
- */
-function encodeCustom (data, encoders, options) {
-  const tokens = objectToTokens(data, options)
-  if (!Array.isArray(tokens) && options.quickEncodeToken) {
-    const quickBytes = options.quickEncodeToken(tokens)
-    if (quickBytes) {
-      return quickBytes
-    }
-    const encoder = encoders[tokens.type.major]
-    if (encoder.encodedSize) {
-      const size = encoder.encodedSize(tokens, options)
-      const buf = new Bl(size)
-      encoder(buf, tokens, options)
-      /* c8 ignore next 4 */
-      // this would be a problem with encodedSize() functions
-      if (buf.chunks.length !== 1) {
-        throw new Error(`Unexpected error: pre-calculated length for ${tokens} was wrong`)
-      }
-      return asU8A(buf.chunks[0])
-    }
-  }
-  buf.reset()
-  tokensToEncoded(buf, tokens, encoders, options)
-  return buf.toBytes(true)
-}
-
-/**
- * @param {any} data
- * @param {EncodeOptions} [options]
- * @returns {Uint8Array}
- */
-function encode (data, options) {
-  options = Object.assign({}, defaultEncodeOptions, options)
-  return encodeCustom(data, cborEncoders, options)
-}
-
-export { objectToTokens, encode, encodeCustom, Ref }

package/src/cborg/cborg/index.js

@@ -1,33 +0,0 @@
-import { encode } from './encode.js'
-import { decode, decodeFirst, Tokeniser, tokensToObject } from './decode.js'
-import { Token, Type } from "@fireproof/vendor/cborg/utils"
-
-// is this needed for the json module and other independ encoders
-export { encodeCustom } from './encode.js'
-// export { asU8A, fromString, decodeCodePointsArray } from './utils/byte-utils.js'
-// export { quickEncodeToken } from './utils/jump.js'
-// export { encodeErrPrefix, decodeErrPrefix } from './lib/common.js'
-// export { makeCborEncoders, objectToTokens } from './lib/encode.js'
-
-/**
- * Export the types that were present in the original manual cborg.d.ts
- * @typedef {import('../interface').TagDecoder} TagDecoder
- * There was originally just `TypeEncoder` so don't break types by renaming or not exporting
- * @typedef {import('../interface').OptionalTypeEncoder} TypeEncoder
- * @typedef {import('../interface').DecodeOptions} DecodeOptions
- * @typedef {import('../interface').EncodeOptions} EncodeOptions
- */
-
-export {
-  // this is needed to prevent the bundleing trouble which happens
-  // due to the fact that token.js is used in lib/json and so in
-  // cborg/json which ends up on bundling to have two copies of token.js
-  // which will fail stmts like token.type === Type.array
-  decode,
-  decodeFirst,
-  Tokeniser as Tokenizer,
-  tokensToObject,
-  encode,
-  Token,
-  Type
-}

package/src/cborg/cborg/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/length.js

@@ -1,62 +0,0 @@
-import { makeCborEncoders, objectToTokens } from './encode.js'
-import { quickEncodeToken } from "@fireproof/vendor/cborg/utils"
-
-/**
- * @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,
-  encodeErrPrefix: 'CBOR encode error: '
-}
-
-/**
- * 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)
-  }
-}