@fireproof/vendor 0.0.0-smoke → 1.0.1

package/{patched/cborg/lib → src/cborg/utils}/5map.js

@@ -1,10 +1,9 @@
 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
+ * @typedef {import('../interface.js').DecodeOptions} DecodeOptions
  */
 
 /**
@@ -73,7 +72,7 @@ export function decodeMap32 (data, pos, _minor, options) {
 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`)
+    throw new Error(`${options.decodeErrPrefix} 64-bit integer map lengths not supported`)
   }
   return toToken(data, pos, 9, l)
 }
@@ -87,7 +86,7 @@ export function decodeMap64 (data, pos, _minor, options) {
  */
 export function decodeMapIndefinite (data, pos, _minor, options) {
   if (options.allowIndefinite === false) {
-    throw new Error(`${decodeErrPrefix} indefinite length items not allowed`)
+    throw new Error(`${options.decodeErrPrefix} indefinite length items not allowed`)
   }
   return toToken(data, pos, 1, Infinity)
 }
@@ -95,9 +94,10 @@ export function decodeMapIndefinite (data, pos, _minor, options) {
 /**
  * @param {Bl} buf
  * @param {Token} token
+ * @param {import('../interface.js').EncodeOptions} options
  */
-export function encodeMap (buf, token) {
-  uint.encodeUintValue(buf, Type.map.majorEncoded, token.value)
+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

package/{patched/cborg/lib → src/cborg/utils}/6tag.js

@@ -3,7 +3,7 @@ import * as uint from './0uint.js'
 
 /**
  * @typedef {import('./bl.js').Bl} Bl
- * @typedef {import('../interface').DecodeOptions} DecodeOptions
+ * @typedef {import('../interface.js').DecodeOptions} DecodeOptions
  */
 
 /**
@@ -64,9 +64,10 @@ export function decodeTag64 (data, pos, _minor, options) {
 /**
  * @param {Bl} buf
  * @param {Token} token
+ * @param {import('../interface.js').EncodeOptions} options
  */
-export function encodeTag (buf, token) {
-  uint.encodeUintValue(buf, Type.tag.majorEncoded, token.value)
+export function encodeTag (buf, token, { encodeErrPrefix }) {
+  uint.encodeUintValue(buf, Type.tag.majorEncoded, token.value, encodeErrPrefix)
 }
 
 encodeTag.compareTokens = uint.encodeUint.compareTokens

package/src/cborg/{cborg/lib → utils}/7float.js

@@ -2,13 +2,12 @@
 // where possible
 
 import { Token, Type } from './token.js'
-import { decodeErrPrefix } from './common.js'
 import { encodeUint } from './0uint.js'
 
 /**
  * @typedef {import('./bl.js').Bl} Bl
- * @typedef {import('../interface').DecodeOptions} DecodeOptions
- * @typedef {import('../interface').EncodeOptions} EncodeOptions
+ * @typedef {import('../interface.js').DecodeOptions} DecodeOptions
+ * @typedef {import('../interface.js').EncodeOptions} EncodeOptions
  */
 
 const MINOR_FALSE = 20
@@ -25,7 +24,7 @@ const MINOR_UNDEFINED = 23
  */
 export function decodeUndefined (_data, _pos, _minor, options) {
   if (options.allowUndefined === false) {
-    throw new Error(`${decodeErrPrefix} undefined values are not supported`)
+    throw new Error(`${options.decodeErrPrefix} undefined values are not supported`)
   } else if (options.coerceUndefinedToNull === true) {
     return new Token(Type.null, null, 1)
   }
@@ -41,7 +40,7 @@ export function decodeUndefined (_data, _pos, _minor, options) {
  */
 export function decodeBreak (_data, _pos, _minor, options) {
   if (options.allowIndefinite === false) {
-    throw new Error(`${decodeErrPrefix} indefinite length items not allowed`)
+    throw new Error(`${options.decodeErrPrefix} indefinite length items not allowed`)
   }
   return new Token(Type.break, undefined, 1)
 }
@@ -55,10 +54,10 @@ export function decodeBreak (_data, _pos, _minor, options) {
 function createToken (value, bytes, options) {
   if (options) {
     if (options.allowNaN === false && Number.isNaN(value)) {
-      throw new Error(`${decodeErrPrefix} NaN values are not supported`)
+      throw new Error(`${options.decodeErrPrefix} NaN values are not supported`)
     }
     if (options.allowInfinity === false && (value === Infinity || value === -Infinity)) {
-      throw new Error(`${decodeErrPrefix} Infinity values are not supported`)
+      throw new Error(`${options.decodeErrPrefix} Infinity values are not supported`)
     }
   }
   return new Token(Type.float, value, bytes)
@@ -72,7 +71,7 @@ function createToken (value, bytes, options) {
  * @returns {Token}
  */
 export function decodeFloat16 (data, pos, _minor, options) {
-  return createToken(readFloat16(data, pos + 1), 3, options)
+  return createToken(readFloat16(data, pos + 1, options.decodeErrPrefix), 3, options)
 }
 
 /**
@@ -83,7 +82,7 @@ export function decodeFloat16 (data, pos, _minor, options) {
  * @returns {Token}
  */
 export function decodeFloat32 (data, pos, _minor, options) {
-  return createToken(readFloat32(data, pos + 1), 5, options)
+  return createToken(readFloat32(data, pos + 1, options.decodeErrPrefix), 5, options)
 }
 
 /**
@@ -94,7 +93,7 @@ export function decodeFloat32 (data, pos, _minor, options) {
  * @returns {Token}
  */
 export function decodeFloat64 (data, pos, _minor, options) {
-  return createToken(readFloat64(data, pos + 1), 9, options)
+  return createToken(readFloat64(data, pos + 1, options.decodeErrPrefix), 9, options)
 }
 
 /**
@@ -118,14 +117,14 @@ export function encodeFloat (buf, token, options) {
     let success = false
     if (!options || options.float64 !== true) {
       encodeFloat16(float)
-      decoded = readFloat16(ui8a, 1)
+      decoded = readFloat16(ui8a, 1, options.encodeErrPrefix)
       if (float === decoded || Number.isNaN(float)) {
         ui8a[0] = 0xf9
         buf.push(ui8a.slice(0, 3))
         success = true
       } else {
         encodeFloat32(float)
-        decoded = readFloat32(ui8a, 1)
+        decoded = readFloat32(ui8a, 1, options.encodeErrPrefix)
         if (float === decoded) {
           ui8a[0] = 0xfa
           buf.push(ui8a.slice(0, 5))
@@ -135,7 +134,7 @@ export function encodeFloat (buf, token, options) {
     }
     if (!success) {
       encodeFloat64(float)
-      decoded = readFloat64(ui8a, 1)
+      decoded = readFloat64(ui8a, 1, options.encodeErrPrefix)
       ui8a[0] = 0xfb
       buf.push(ui8a.slice(0, 9))
     }
@@ -156,12 +155,12 @@ encodeFloat.encodedSize = function encodedSize (token, options) {
 
   if (!options || options.float64 !== true) {
     encodeFloat16(float)
-    let decoded = readFloat16(ui8a, 1)
+    let decoded = readFloat16(ui8a, 1, options.encodeErrPrefix)
     if (float === decoded || Number.isNaN(float)) {
       return 3
     }
     encodeFloat32(float)
-    decoded = readFloat32(ui8a, 1)
+    decoded = readFloat32(ui8a, 1, options.encodeErrPrefix)
     if (float === decoded) {
       return 5
     }
@@ -222,11 +221,12 @@ function encodeFloat16 (inp) {
 /**
  * @param {Uint8Array} ui8a
  * @param {number} pos
+ * @param {string} encodeErrPrefix
  * @returns {number}
  */
-function readFloat16 (ui8a, pos) {
+function readFloat16 (ui8a, pos, encodeErrPrefix) {
   if (ui8a.length - pos < 2) {
-    throw new Error(`${decodeErrPrefix} not enough data for float16`)
+    throw new Error(`${encodeErrPrefix} not enough data for float16`)
   }
 
   const half = (ui8a[pos] << 8) + ui8a[pos + 1]
@@ -264,11 +264,12 @@ function encodeFloat32 (inp) {
 /**
  * @param {Uint8Array} ui8a
  * @param {number} pos
+ * @param {string} encodeErrPrefix
  * @returns {number}
  */
-function readFloat32 (ui8a, pos) {
+function readFloat32 (ui8a, pos, encodeErrPrefix) {
   if (ui8a.length - pos < 4) {
-    throw new Error(`${decodeErrPrefix} not enough data for float32`)
+    throw new Error(`${encodeErrPrefix} not enough data for float32`)
   }
   const offset = (ui8a.byteOffset || 0) + pos
   return new DataView(ui8a.buffer, offset, 4).getFloat32(0, false)
@@ -284,11 +285,12 @@ function encodeFloat64 (inp) {
 /**
  * @param {Uint8Array} ui8a
  * @param {number} pos
+ * @param {string} encodeErrPrefix
  * @returns {number}
  */
-function readFloat64 (ui8a, pos) {
+function readFloat64 (ui8a, pos, encodeErrPrefix) {
   if (ui8a.length - pos < 8) {
-    throw new Error(`${decodeErrPrefix} not enough data for float64`)
+    throw new Error(`${encodeErrPrefix} not enough data for float64`)
   }
   const offset = (ui8a.byteOffset || 0) + pos
   return new DataView(ui8a.buffer, offset, 8).getFloat64(0, false)

package/{patched/cborg/lib → src/cborg/utils}/bl.js

@@ -16,7 +16,7 @@
  */
 
 // TODO: ipjs doesn't support this, only for test files: https://github.com/mikeal/ipjs/blob/master/src/package/testFile.js#L39
-import { alloc, concat, slice } from './byte-utils.js'
+import { alloc, concat, slice } from 'cborg/utils'
 
 // the ts-ignores in this file are almost all for the `Uint8Array|number[]` duality that exists
 // for perf reasons. Consider better approaches to this or removing it entirely, it is quite

package/src/cborg/utils/common.js

@@ -0,0 +1,11 @@
+/**
+ * @param {Uint8Array} data
+ * @param {number} pos
+ * @param {number} need
+ * @param {string} decodeErrPrefix
+ */
+export function assertEnoughData (data, pos, need, decodeErrPrefix) {
+  if (data.length - pos < need) {
+    throw new Error(`${decodeErrPrefix} not enough data for type`)
+  }
+}

package/src/cborg/utils/index.js

@@ -0,0 +1,12 @@
+export * from './byte-utils.js'
+export { encodeUint, uintBoundaries } from './0uint.js'
+export { encodeNegint } from './1negint.js'
+export { encodeBytes } from './2bytes.js'
+export { encodeString } from './3string.js'
+export { encodeArray } from './4array.js'
+export { encodeMap } from './5map.js'
+export { encodeTag } from './6tag.js'
+export { encodeFloat } from './7float.js'
+export { Bl } from './bl.js'
+export { Token, Type } from './token.js'
+export * from './jump.js'

package/src/cborg/utils/jump.js

@@ -0,0 +1,222 @@
+import { Token, Type } from './token.js'
+import * as uint from './0uint.js'
+import * as negint from './1negint.js'
+import * as bytes from './2bytes.js'
+import * as string from './3string.js'
+import * as array from './4array.js'
+import * as map from './5map.js'
+import * as tag from './6tag.js'
+import * as float from './7float.js'
+import { fromArray } from './byte-utils.js'
+
+/**
+ * @typedef {import('../interface.js').DecodeOptions} DecodeOptions
+ * @typedef {import('../interface.js').DecodeFunction} DecodeFunction
+ */
+
+/**
+ * @param {string} decodeErrPrefix
+ * @returns {DecodeFunction}
+ */
+function invalidMinorWithPrefix (decodeErrPrefix) {
+  /**
+   * @param {Uint8Array} data
+   * @param {number} pos
+   * @param {number} minor
+   */
+  return (data, pos, minor) => {
+    throw new Error(`${decodeErrPrefix} encountered invalid minor (${minor}) for major ${data[pos] >>> 5}`)
+  }
+}
+
+/**
+ * @param {string} msg
+ * @param {string} decodeErrPrefix
+ * @returns {()=>any}
+ */
+function errorer (msg, decodeErrPrefix) {
+  return () => { throw new Error(`${decodeErrPrefix} ${msg}`) }
+}
+
+/**
+ * @param {string} decodeErrPrefix
+ * @return {DecodeFunction[]}
+ */
+export function jump (decodeErrPrefix) {
+  const invalidMinor = invalidMinorWithPrefix(decodeErrPrefix)
+  const jump = Array(256).fill(invalidMinor)
+  // unsigned integer, 0x00..0x17 (0..23)
+  // for (let i = 0; i <= 0x17; i++) {
+  // jump[i] = invalidMinor // uint.decodeUintCompact, handled by quick[]
+  // }
+  jump[0x18] = uint.decodeUint8 // unsigned integer, one-byte uint8_t follows
+  jump[0x19] = uint.decodeUint16 // unsigned integer, two-byte uint16_t follows
+  jump[0x1a] = uint.decodeUint32 // unsigned integer, four-byte uint32_t follows
+  jump[0x1b] = uint.decodeUint64 // unsigned integer, eight-byte uint64_t follows
+  // jump[0x1c] = invalidMinor
+  // jump[0x1d] = invalidMinor
+  // jump[0x1e] = invalidMinor
+  // jump[0x1f] = invalidMinor
+  // negative integer, -1-0x00..-1-0x17 (-1..-24)
+  // for (let i = 0x20; i <= 0x37; i++) {
+  // jump[i] = invalidMinor // negintDecode, handled by quick[]
+  // }
+  jump[0x38] = negint.decodeNegint8 // negative integer, -1-n one-byte uint8_t for n follows
+  jump[0x39] = negint.decodeNegint16 // negative integer, -1-n two-byte uint16_t for n follows
+  jump[0x3a] = negint.decodeNegint32 // negative integer, -1-n four-byte uint32_t for follows
+  jump[0x3b] = negint.decodeNegint64 // negative integer, -1-n eight-byte uint64_t for follows
+  // jump[0x3c] = invalidMinor
+  // jump[0x3d] = invalidMinor
+  // jump[0x3e] = invalidMinor
+  // jump[0x3f] = invalidMinor
+  // byte string, 0x00..0x17 bytes follow
+  for (let i = 0x40; i <= 0x57; i++) {
+    jump[i] = bytes.decodeBytesCompact
+  }
+  jump[0x58] = bytes.decodeBytes8 // byte string, one-byte uint8_t for n, and then n bytes follow
+  jump[0x59] = bytes.decodeBytes16 // byte string, two-byte uint16_t for n, and then n bytes follow
+  jump[0x5a] = bytes.decodeBytes32 // byte string, four-byte uint32_t for n, and then n bytes follow
+  jump[0x5b] = bytes.decodeBytes64 // byte string, eight-byte uint64_t for n, and then n bytes follow
+  // jump[0x5c] = invalidMinor
+  // jump[0x5d] = invalidMinor
+  // jump[0x5e] = invalidMinor
+  jump[0x5f] = errorer('indefinite length bytes/strings are not supported', decodeErrPrefix) // byte string, byte strings follow, terminated by "break"
+  // UTF-8 string 0x00..0x17 bytes follow
+  for (let i = 0x60; i <= 0x77; i++) {
+    jump[i] = string.decodeStringCompact
+  }
+  jump[0x78] = string.decodeString8 // UTF-8 string, one-byte uint8_t for n, and then n bytes follow
+  jump[0x79] = string.decodeString16 // UTF-8 string, two-byte uint16_t for n, and then n bytes follow
+  jump[0x7a] = string.decodeString32 // UTF-8 string, four-byte uint32_t for n, and then n bytes follow
+  jump[0x7b] = string.decodeString64 // UTF-8 string, eight-byte uint64_t for n, and then n bytes follow
+  // jump[0x7c] = invalidMinor
+  // jump[0x7d] = invalidMinor
+  // jump[0x7e] = invalidMinor
+  jump[0x7f] = errorer('indefinite length bytes/strings are not supported', decodeErrPrefix) // UTF-8 strings follow, terminated by "break"
+  // array, 0x00..0x17 data items follow
+  for (let i = 0x80; i <= 0x97; i++) {
+    jump[i] = array.decodeArrayCompact
+  }
+  jump[0x98] = array.decodeArray8 // array, one-byte uint8_t for n, and then n data items follow
+  jump[0x99] = array.decodeArray16 // array, two-byte uint16_t for n, and then n data items follow
+  jump[0x9a] = array.decodeArray32 // array, four-byte uint32_t for n, and then n data items follow
+  jump[0x9b] = array.decodeArray64 // array, eight-byte uint64_t for n, and then n data items follow
+  // jump[0x9c] = invalidMinor
+  // jump[0x9d] = invalidMinor
+  // jump[0x9e] = invalidMinor
+  jump[0x9f] = array.decodeArrayIndefinite // array, data items follow, terminated by "break"
+  // map, 0x00..0x17 pairs of data items follow
+  for (let i = 0xa0; i <= 0xb7; i++) {
+    jump[i] = map.decodeMapCompact
+  }
+  jump[0xb8] = map.decodeMap8 // map, one-byte uint8_t for n, and then n pairs of data items follow
+  jump[0xb9] = map.decodeMap16 // map, two-byte uint16_t for n, and then n pairs of data items follow
+  jump[0xba] = map.decodeMap32 // map, four-byte uint32_t for n, and then n pairs of data items follow
+  jump[0xbb] = map.decodeMap64 // map, eight-byte uint64_t for n, and then n pairs of data items follow
+  // jump[0xbc] = invalidMinor
+  // jump[0xbd] = invalidMinor
+  // jump[0xbe] = invalidMinor
+  jump[0xbf] = map.decodeMapIndefinite // map, pairs of data items follow, terminated by "break"
+  // tags
+  for (let i = 0xc0; i <= 0xd7; i++) {
+    jump[i] = tag.decodeTagCompact
+  }
+  jump[0xd8] = tag.decodeTag8
+  jump[0xd9] = tag.decodeTag16
+  jump[0xda] = tag.decodeTag32
+  jump[0xdb] = tag.decodeTag64
+  // jump[0xdc] = invalidMinor
+  // jump[0xdd] = invalidMinor
+  // jump[0xde] = invalidMinor
+  // jump[0xdf] = invalidMinor
+  // 0xe0..0xf3 simple values, unsupported
+  for (let i = 0xe0; i <= 0xf3; i++) {
+    jump[i] = errorer('simple values are not supported', decodeErrPrefix)
+  }
+  // jump[0xf4] = invalidMinor // false, handled by quick[]
+  // jump[0xf5] = invalidMinor // true, handled by quick[]
+  // jump[0xf6] = invalidMinor // null, handled by quick[]
+  jump[0xf7] = float.decodeUndefined // undefined
+  jump[0xf8] = errorer('simple values are not supported', decodeErrPrefix) // simple value, one byte follows, unsupported
+  jump[0xf9] = float.decodeFloat16 // half-precision float (two-byte IEEE 754)
+  jump[0xfa] = float.decodeFloat32 // single-precision float (four-byte IEEE 754)
+  jump[0xfb] = float.decodeFloat64 // double-precision float (eight-byte IEEE 754)
+  // jump[0xfc] = invalidMinor
+  // jump[0xfd] = invalidMinor
+  // jump[0xfe] = invalidMinor
+  jump[0xff] = float.decodeBreak // "break" stop code
+  return jump
+}
+
+/** @type {Token[]} */
+export const quick = []
+// ints <24
+for (let i = 0; i < 24; i++) {
+  quick[i] = new Token(Type.uint, i, 1)
+}
+// negints >= -24
+for (let i = -1; i >= -24; i--) {
+  quick[31 - i] = new Token(Type.negint, i, 1)
+}
+// empty bytes
+quick[0x40] = new Token(Type.bytes, new Uint8Array(0), 1)
+// empty string
+quick[0x60] = new Token(Type.string, '', 1)
+// empty list
+quick[0x80] = new Token(Type.array, 0, 1)
+// empty map
+quick[0xa0] = new Token(Type.map, 0, 1)
+// false
+quick[0xf4] = new Token(Type.false, false, 1)
+// true
+quick[0xf5] = new Token(Type.true, true, 1)
+// null
+quick[0xf6] = new Token(Type.null, null, 1)
+
+/**
+ * @param {Token} token
+ * @returns {Uint8Array|undefined}
+ */
+export function quickEncodeToken (token) {
+  switch (token.type) {
+    case Type.false:
+      return fromArray([0xf4])
+    case Type.true:
+      return fromArray([0xf5])
+    case Type.null:
+      return fromArray([0xf6])
+    case Type.bytes:
+      if (!token.value.length) {
+        return fromArray([0x40])
+      }
+      return
+    case Type.string:
+      if (token.value === '') {
+        return fromArray([0x60])
+      }
+      return
+    case Type.array:
+      if (token.value === 0) {
+        return fromArray([0x80])
+      }
+      /* c8 ignore next 2 */
+      // shouldn't be possible if this were called when there was only one token
+      return
+    case Type.map:
+      if (token.value === 0) {
+        return fromArray([0xa0])
+      }
+      /* c8 ignore next 2 */
+      // shouldn't be possible if this were called when there was only one token
+      return
+    case Type.uint:
+      if (token.value < 24) {
+        return fromArray([Number(token.value)])
+      }
+      return
+    case Type.negint:
+      if (token.value >= -24) {
+        return fromArray([31 - Number(token.value)])
+      }
+  }
+}

package/patched/@ipld/dag-json/.github/dependabot.yml

@@ -1,11 +0,0 @@
-version: 2
-updates:
-- package-ecosystem: npm
-  directory: "/"
-  schedule:
-    interval: daily
-    time: "10:00"
-  open-pull-requests-limit: 10
-  commit-message:
-    prefix: "deps"
-    prefix-development: "deps(dev)"

package/patched/@ipld/dag-json/.github/workflows/js-test-and-release.yml

@@ -1,28 +0,0 @@
-name: test & maybe release
-
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-  workflow_dispatch:
-
-permissions:
-  contents: write
-  id-token: write
-  packages: write
-  pull-requests: write
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event_name }}-${{ github.event_name == 'push' && github.sha || github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  js-test-and-release:
-    uses: ipdxco/unified-github-workflows/.github/workflows/js-test-and-release.yml@v1.0
-    secrets:
-      DOCKER_TOKEN: ${{ secrets.DOCKER_TOKEN }}
-      DOCKER_USERNAME: ${{ secrets.DOCKER_USERNAME }}
-      NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
-      UCI_GITHUB_TOKEN: ${{ secrets.UCI_GITHUB_TOKEN }}
-      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}