@fireproof/vendor 1.0.3 → 1.1.0-dev

package/src/cborg/utils/2bytes.js

@@ -1,135 +0,0 @@
-import { Token, Type } from './token.js'
-import { assertEnoughData } 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.js').DecodeOptions} DecodeOptions
- */
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} prefix
- * @param {number} length
- * @param {string} decodeErrPrefix
- * @returns {Token}
- */
-function toToken (data, pos, prefix, length, decodeErrPrefix) {
-  assertEnoughData(data, pos, prefix + length, decodeErrPrefix)
-  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, options.decodeErrPrefix)
-}
-
-/**
- * @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), options.decodeErrPrefix)
-}
-
-/**
- * @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), options.decodeErrPrefix)
-}
-
-/**
- * @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), options.decodeErrPrefix)
-}
-
-// 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(`${options.decodeErrPrefix} 64-bit integer bytes lengths not supported`)
-  }
-  return toToken(data, pos, 9, l, options.decodeErrPrefix)
-}
-
-/**
- * `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
- * @param {import('../interface.js').EncodeOptions} options
- */
-export function encodeBytes (buf, token, { encodeErrPrefix }) {
-  const bytes = tokenBytes(token)
-  uint.encodeUintValue(buf, token.type.majorEncoded, bytes.length, encodeErrPrefix)
-  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/src/cborg/utils/3string.js

@@ -1,90 +0,0 @@
-import { Token, Type } from './token.js'
-import { assertEnoughData } 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.js').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, options.decodeErrPrefix)
-  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(`${options.decodeErrPrefix} 64-bit integer string lengths not supported`)
-  }
-  return toToken(data, pos, 9, l, options)
-}
-
-export const encodeString = encodeBytes

package/src/cborg/utils/4array.js

@@ -1,114 +0,0 @@
-import { Token, Type } from './token.js'
-import * as uint from './0uint.js'
-// import { decodeErrPrefix } from '../lib/common.js'
-
-/**
- * @typedef {import('./bl.js').Bl} Bl
- * @typedef {import('../interface.js').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(`${options.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(`${options.decodeErrPrefix} indefinite length items not allowed`)
-  }
-  return toToken(data, pos, 1, Infinity)
-}
-
-/**
- * @param {Bl} buf
- * @param {Token} token
- * @param {import('../interface.js').EncodeOptions} options
- */
-export function encodeArray (buf, token, { encodeErrPrefix }) {
-  uint.encodeUintValue(buf, Type.array.majorEncoded, token.value, encodeErrPrefix)
-}
-
-// 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/src/cborg/utils/5map.js

@@ -1,113 +0,0 @@
-import { Token, Type } from './token.js'
-import * as uint from './0uint.js'
-
-/**
- * @typedef {import('./bl.js').Bl} Bl
- * @typedef {import('../interface.js').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(`${options.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(`${options.decodeErrPrefix} indefinite length items not allowed`)
-  }
-  return toToken(data, pos, 1, Infinity)
-}
-
-/**
- * @param {Bl} buf
- * @param {Token} token
- * @param {import('../interface.js').EncodeOptions} options
- */
-export function encodeMap (buf, token, { encodeErrPrefix }) {
-  uint.encodeUintValue(buf, Type.map.majorEncoded, token.value, encodeErrPrefix)
-}
-
-// 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/src/cborg/utils/6tag.js

@@ -1,81 +0,0 @@
-import { Token, Type } from './token.js'
-import * as uint from './0uint.js'
-
-/**
- * @typedef {import('./bl.js').Bl} Bl
- * @typedef {import('../interface.js').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
- * @param {import('../interface.js').EncodeOptions} options
- */
-export function encodeTag (buf, token, { encodeErrPrefix }) {
-  uint.encodeUintValue(buf, Type.tag.majorEncoded, token.value, encodeErrPrefix)
-}
-
-encodeTag.compareTokens = uint.encodeUint.compareTokens
-
-/**
- * @param {Token} token
- * @returns {number}
- */
-encodeTag.encodedSize = function encodedSize (token) {
-  return uint.encodeUintValue.encodedSize(token.value)
-}