@fireproof/vendor 0.0.0-smoke

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

@@ -0,0 +1,111 @@
+/* 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

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

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

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

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

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