@fireproof/vendor 1.1.1 → 1.2.0

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

@@ -0,0 +1,135 @@
+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

@@ -0,0 +1,90 @@
+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

@@ -0,0 +1,114 @@
+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

@@ -0,0 +1,113 @@
+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

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