@fireproof/vendor 0.0.0-smoke → 1.0.1

package/src/@ipld/car/dist/src/reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reader.d.ts","sourceRoot":"","sources":["../../src/reader.js"],"names":[],"mappings":";AA6BA;;;GAGG;AACH;IACE;;;;;;;;;;;;;;;;;;;OAmBG;IACH,mBARW,GAAG,QAAQ,CAAC,UAAU,GAAG,MAAM,cAG/B,UAAU,GAGR,QAAQ,KAAK,CAAC,CAiB1B;CACF;AAED,8BAA4B;oBAnEf,OAAO,OAAO,EAAE,KAAK;yBACrB,OAAO,OAAO,EAAE,UAAU;6BAC1B,OAAO,OAAO,EAAE,SAAS;8CALQ,qBAAqB;eAFpD,IAAI"}

package/src/@ipld/car/{car/src → src}/reader.js

@@ -8,7 +8,24 @@ import { CarReader as BrowserCarReader } from './reader-browser.js'
  * @typedef {import('./api').CarReader} CarReaderIface
  */
 
-const fsread = promisify(fs.read)
+/**
+ * @description not happy with typing here, but it's needed for the `promisify(fs.read)` function.
+ * @type {any}
+ */
+let _fsReadFn
+/**
+ * @description This function is needed not to initialize the `fs.read` on load time. To run in cf workers without polyfill.
+ * @param {number} fd
+ * @param {Uint8Array} buffer
+ * @param {number} offset
+ * @param {number} length
+ * @param {number} position
+ * @returns {Promise<{ bytesRead: number, buffer: Uint8Array }>}
+ */
+function fsread (fd, buffer, offset, length, position) {
+  _fsReadFn = _fsReadFn || promisify(fs.read)
+  return _fsReadFn(fd, buffer, offset, length, position)
+}
 
 /**
  * @class
@@ -53,4 +70,4 @@ export class CarReader extends BrowserCarReader {
   }
 }
 
-export const __browser = false
+export const __browser = !fs

package/src/cborg/cborg/{lib/bin.js → bin.js}

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 import process from 'process'
-import { decode, encode } from '../cborg.js'
+import { decode, encode } from "@fireproof/vendor/cborg"
 import { tokensToDiagnostic, fromDiag } from './diagnostic.js'
-import { fromHex as _fromHex, toHex } from './byte-utils.js'
+import { fromHex as _fromHex, toHex } from 'cborg/utils'
 
 /**
  * @param {number} code

package/src/cborg/cborg/common.js

@@ -0,0 +1,28 @@
+// const decodeErrPrefix = 'CBOR decode error:'
+// const encodeErrPrefix = 'CBOR encode error:'
+
+const uintMinorPrefixBytes = []
+uintMinorPrefixBytes[23] = 1
+uintMinorPrefixBytes[24] = 2
+uintMinorPrefixBytes[25] = 3
+uintMinorPrefixBytes[26] = 5
+uintMinorPrefixBytes[27] = 9
+
+// /**
+//  * @param {Uint8Array} data
+//  * @param {number} pos
+//  * @param {number} need
+//  * @param {string} decodeErrPrefix
+//  */
+// function assertEnoughData (data, pos, need, decodeErrPrefix) {
+//   if (data.length - pos < need) {
+//     throw new Error(`${decodeErrPrefix} not enough data for type`)
+//   }
+// }
+
+export {
+  // decodeErrPrefix,
+  // encodeErrPrefix,
+  uintMinorPrefixBytes
+  // assertEnoughData
+}

package/{patched/cborg/lib → src/cborg/cborg}/decode.js

@@ -1,18 +1,18 @@
-import { decodeErrPrefix } from './common.js'
-import { Type } from './token.js'
-import { jump, quick } from './jump.js'
+import { jump, quick, Type } from 'cborg/utils'
 
 /**
- * @typedef {import('./token.js').Token} Token
+ * @typedef {import('cborg/utils').Token} Token
  * @typedef {import('../interface').DecodeOptions} DecodeOptions
  * @typedef {import('../interface').DecodeTokenizer} DecodeTokenizer
+ * @typedef {import('../interface').DecodeFunction} DecodeFunction
  */
 
-const defaultDecodeOptions = {
+const /** @type {DecodeOptions} */defaultDecodeOptions = {
   strict: false,
   allowIndefinite: true,
   allowUndefined: true,
-  allowBigInt: true
+  allowBigInt: true,
+  decodeErrPrefix: 'CBOR decode error:'
 }
 
 /**
@@ -23,10 +23,11 @@ class Tokeniser {
    * @param {Uint8Array} data
    * @param {DecodeOptions} options
    */
-  constructor (data, options = {}) {
+  constructor (data, options) {
     this._pos = 0
     this.data = data
     this.options = options
+    this.jump = jump(options.decodeErrPrefix)
   }
 
   pos () {
@@ -41,11 +42,11 @@ class Tokeniser {
     const byt = this.data[this._pos]
     let token = quick[byt]
     if (token === undefined) {
-      const decoder = jump[byt]
+      const decoder = this.jump[byt]
       /* c8 ignore next 4 */
       // if we're here then there's something wrong with our jump or quick lists!
       if (!decoder) {
-        throw new Error(`${decodeErrPrefix} no decoder for major type ${byt >>> 5} (byte 0x${byt.toString(16).padStart(2, '0')})`)
+        throw new Error(`${this.options.decodeErrPrefix} no decoder for major type ${byt >>> 5} (byte 0x${byt.toString(16).padStart(2, '0')})`)
       }
       const minor = byt & 31
       token = decoder(this.data, this._pos, minor, this.options)
@@ -74,10 +75,10 @@ function tokenToArray (token, tokeniser, options) {
         // normal end to indefinite length array
         break
       }
-      throw new Error(`${decodeErrPrefix} got unexpected break to lengthed array`)
+      throw new Error(`${options.decodeErrPrefix} got unexpected break to lengthed array`)
     }
     if (value === DONE) {
-      throw new Error(`${decodeErrPrefix} found array but not enough entries (got ${i}, expected ${token.value})`)
+      throw new Error(`${options.decodeErrPrefix} found array but not enough entries (got ${i}, expected ${token.value})`)
     }
     arr[i] = value
   }
@@ -101,23 +102,23 @@ function tokenToMap (token, tokeniser, options) {
         // normal end to indefinite length map
         break
       }
-      throw new Error(`${decodeErrPrefix} got unexpected break to lengthed map`)
+      throw new Error(`${options.decodeErrPrefix} got unexpected break to lengthed map`)
     }
     if (key === DONE) {
-      throw new Error(`${decodeErrPrefix} found map but not enough entries (got ${i} [no key], expected ${token.value})`)
+      throw new Error(`${options.decodeErrPrefix} found map but not enough entries (got ${i} [no key], expected ${token.value})`)
     }
     if (useMaps !== true && typeof key !== 'string') {
-      throw new Error(`${decodeErrPrefix} non-string keys not supported (got ${typeof key})`)
+      throw new Error(`${options.decodeErrPrefix} non-string keys not supported (got ${typeof key})`)
     }
     if (options.rejectDuplicateMapKeys === true) {
       // @ts-ignore
       if ((useMaps && m.has(key)) || (!useMaps && (key in obj))) {
-        throw new Error(`${decodeErrPrefix} found repeat map key "${key}"`)
+        throw new Error(`${options.decodeErrPrefix} found repeat map key "${key}"`)
       }
     }
     const value = tokensToObject(tokeniser, options)
     if (value === DONE) {
-      throw new Error(`${decodeErrPrefix} found map but not enough entries (got ${i} [no value], expected ${token.value})`)
+      throw new Error(`${options.decodeErrPrefix} found map but not enough entries (got ${i} [no value], expected ${token.value})`)
     }
     if (useMaps) {
       // @ts-ignore TODO reconsider this .. maybe needs to be strict about key types
@@ -166,7 +167,7 @@ function tokensToObject (tokeniser, options) {
       const tagged = tokensToObject(tokeniser, options)
       return options.tags[token.value](tagged)
     }
-    throw new Error(`${decodeErrPrefix} tag not supported (${token.value})`)
+    throw new Error(`${options.decodeErrPrefix} tag not supported (${token.value})`)
   }
   /* c8 ignore next */
   throw new Error('unsupported')
@@ -178,17 +179,17 @@ function tokensToObject (tokeniser, options) {
  * @returns {[any, Uint8Array]}
  */
 function decodeFirst (data, options) {
+  options = Object.assign({}, defaultDecodeOptions, options)
   if (!(data instanceof Uint8Array)) {
-    throw new Error(`${decodeErrPrefix} data to decode must be a Uint8Array`)
+    throw new Error(`${options.decodeErrPrefix} data to decode must be a Uint8Array`)
   }
-  options = Object.assign({}, defaultDecodeOptions, options)
   const tokeniser = options.tokenizer || new Tokeniser(data, options)
   const decoded = tokensToObject(tokeniser, options)
   if (decoded === DONE) {
-    throw new Error(`${decodeErrPrefix} did not find any content to decode`)
+    throw new Error(`${options.decodeErrPrefix} did not find any content to decode`)
   }
   if (decoded === BREAK) {
-    throw new Error(`${decodeErrPrefix} got unexpected break`)
+    throw new Error(`${options.decodeErrPrefix} got unexpected break`)
   }
   return [decoded, data.subarray(tokeniser.pos())]
 }
@@ -199,9 +200,10 @@ function decodeFirst (data, options) {
  * @returns {any}
  */
 function decode (data, options) {
+  options = Object.assign({}, defaultDecodeOptions, options)
   const [decoded, remainder] = decodeFirst(data, options)
   if (remainder.length > 0) {
-    throw new Error(`${decodeErrPrefix} too many terminals, data makes no sense`)
+    throw new Error(`${options.decodeErrPrefix} too many terminals, data makes no sense:${remainder.length}`)
   }
   return decoded
 }

package/src/cborg/cborg/{lib/diagnostic.js → diagnostic.js}

@@ -1,7 +1,5 @@
 import { Tokeniser } from './decode.js'
-import { Type } from './token.js'
-import { toHex, fromHex } from './byte-utils.js'
-import { uintBoundaries } from './0uint.js'
+import { uintBoundaries, toHex, fromHex, Type } from 'cborg/utils'
 
 const utf8Encoder = new TextEncoder()
 const utf8Decoder = new TextDecoder()
@@ -11,7 +9,11 @@ const utf8Decoder = new TextDecoder()
  * @param {number} [width]
  */
 function * tokensToDiagnostic (inp, width = 100) {
-  const tokeniser = new Tokeniser(inp, { retainStringBytes: true, allowBigInt: true })
+  const tokeniser = new Tokeniser(inp, {
+    decodeErrPrefix: 'Diagnostic decode error: ',
+    retainStringBytes: true,
+    allowBigInt: true
+  })
   let pos = 0
   const indent = []
 

package/{patched/cborg/lib → src/cborg/cborg}/diagnostic_test.js

@@ -1,5 +1,5 @@
 import { tokensToDiagnostic } from './diagnostic.js'
-import { fromHex } from './byte-utils.js'
+import { fromHex } from 'cborg/utils'
 
 const inp = `
 a7

package/src/cborg/cborg/{lib/encode.js → encode.js}

@@ -1,18 +1,17 @@
 import { is } from './is.js'
-import { Token, Type } from './token.js'
-import { Bl } from './bl.js'
-import { encodeErrPrefix } from './common.js'
-import { quickEncodeToken } from './jump.js'
-import { asU8A } from './byte-utils.js'
-
-import { encodeUint } from './0uint.js'
-import { encodeNegint } from './1negint.js'
-import { encodeBytes } from './2bytes.js'
-import { encodeString } from './3string.js'
-import { encodeArray } from './4array.js'
-import { encodeMap } from './5map.js'
-import { encodeTag } from './6tag.js'
-import { encodeFloat } from './7float.js'
+import {
+  Token, Type, Bl,
+  quickEncodeToken,
+  asU8A,
+  encodeUint,
+  encodeNegint,
+  encodeBytes,
+  encodeString,
+  encodeArray,
+  encodeMap,
+  encodeTag,
+  encodeFloat
+} from 'cborg/utils'
 
 /**
  * @typedef {import('../interface').EncodeOptions} EncodeOptions
@@ -27,7 +26,9 @@ import { encodeFloat } from './7float.js'
 const defaultEncodeOptions = {
   float64: false,
   mapSorter,
-  quickEncodeToken
+  quickEncodeToken,
+  encodeErrPrefix: 'CBOR encode error:'
+
 }
 
 /** @returns {TokenTypeEncoder[]} */
@@ -77,9 +78,10 @@ class Ref {
   /**
    * @param {Reference|undefined} stack
    * @param {object|any[]} obj
+   * @param {EncodeOptions} options
    * @returns {Reference}
    */
-  static createCheck (stack, obj) {
+  static createCheck (stack, obj, { encodeErrPrefix }) {
     if (stack && stack.includes(obj)) {
       throw new Error(`${encodeErrPrefix} object contains circular references`)
     }
@@ -221,7 +223,7 @@ const typeEncoders = {
       }
       return simpleTokens.emptyArray
     }
-    refStack = Ref.createCheck(refStack, obj)
+    refStack = Ref.createCheck(refStack, obj, options)
     const entries = []
     let i = 0
     for (const e of obj) {
@@ -252,7 +254,7 @@ const typeEncoders = {
       }
       return simpleTokens.emptyMap
     }
-    refStack = Ref.createCheck(refStack, obj)
+    refStack = Ref.createCheck(refStack, obj, options)
     /** @type {TokenOrNestedTokens[]} */
     const entries = []
     let i = 0
@@ -278,11 +280,11 @@ for (const typ of 'Uint8Clamped Uint16 Uint32 Int8 Int16 Int32 BigUint64 BigInt6
 
 /**
  * @param {any} obj
- * @param {EncodeOptions} [options]
+ * @param {EncodeOptions} options
  * @param {Reference} [refStack]
  * @returns {TokenOrNestedTokens}
  */
-function objectToTokens (obj, options = {}, refStack) {
+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') {
@@ -293,7 +295,7 @@ function objectToTokens (obj, options = {}, refStack) {
   }
   const typeEncoder = typeEncoders[typ]
   if (!typeEncoder) {
-    throw new Error(`${encodeErrPrefix} unsupported type: ${typ}`)
+    throw new Error(`${options.encodeErrPrefix} unsupported type: ${typ}`)
   }
   return typeEncoder(obj, typ, options, refStack)
 }

package/{patched/cborg/cborg.js → src/cborg/cborg/index.js}

@@ -1,19 +1,21 @@
-import { encode } from './lib/encode.js'
-import { decode, decodeFirst, Tokeniser, tokensToObject } from './lib/decode.js'
-import { Token, Type } from './lib/token.js'
+import { encode } from './encode.js'
+import { decode, decodeFirst, Tokeniser, tokensToObject } from './decode.js'
+import { Token, Type } from 'cborg/utils'
 
 // is this needed for the json module and other independ encoders
-export { encodeCustom } from './lib/encode.js'
-export { encodeErrPrefix, decodeErrPrefix } from './lib/common.js'
-export { asU8A, fromString, decodeCodePointsArray } from './lib/byte-utils.js'
+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
+ * @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
+ * @typedef {import('../interface').OptionalTypeEncoder} TypeEncoder
+ * @typedef {import('../interface').DecodeOptions} DecodeOptions
+ * @typedef {import('../interface').EncodeOptions} EncodeOptions
  */
 
 export {

package/src/cborg/cborg/{lib/length.js → length.js}

@@ -1,5 +1,5 @@
 import { makeCborEncoders, objectToTokens } from './encode.js'
-import { quickEncodeToken } from './jump.js'
+import { quickEncodeToken } from 'cborg/utils'
 
 /**
  * @typedef {import('../interface').EncodeOptions} EncodeOptions
@@ -12,7 +12,8 @@ const cborEncoders = makeCborEncoders()
 /** @type {EncodeOptions} */
 const defaultEncodeOptions = {
   float64: false,
-  quickEncodeToken
+  quickEncodeToken,
+  encodeErrPrefix: 'CBOR encode error: '
 }
 
 /**

package/{patched → src}/cborg/interface.ts

@@ -1,5 +1,4 @@
-import { Token } from './lib/token'
-import { Bl } from './lib/bl'
+import type { Token, Bl } from 'cborg/utils'
 
 export type TokenOrNestedTokens = Token | Token[] | TokenOrNestedTokens[]
 
@@ -14,12 +13,14 @@ export type OptionalTypeEncoder = (data: any, typ: string, options: EncodeOption
 export type StrictTypeEncoder = (data: any, typ: string, options: EncodeOptions, refStack?: Reference) => TokenOrNestedTokens
 
 export type TokenTypeEncoder = {
-  (buf: Bl, token: Token, options?: EncodeOptions): void;
+  (buf: Bl, token: Token, options: EncodeOptions): void;
   compareTokens(t1: Token, t2: Token): number;
   // TODO: make this non-optional as a breaking change and remove the throw in length.js
-  encodedSize?(token: Token, options?: EncodeOptions): number;
+  encodedSize?(token: Token, options: EncodeOptions): number;
 }
 
+export type DecodeFunction = (data:Uint8Array, pos:number, minor:number, options:DecodeOptions) => any
+
 export type MapSorter = (e1: (Token | Token[])[], e2: (Token | Token[])[]) => number
 
 export type QuickEncodeToken = (token: Token) => Uint8Array | undefined
@@ -45,6 +46,7 @@ export interface DecodeOptions {
   retainStringBytes?: boolean
   tags?: TagDecoder[],
   tokenizer?: DecodeTokenizer
+  decodeErrPrefix: string
 }
 
 export interface EncodeOptions {
@@ -53,4 +55,5 @@ export interface EncodeOptions {
   mapSorter?: MapSorter,
   quickEncodeToken?: QuickEncodeToken,
   typeEncoders?: { [typeName: string]: OptionalTypeEncoder }
+  encodeErrPrefix: string
 }

package/src/cborg/{cborg/lib/json → json}/decode.js

@@ -1,13 +1,11 @@
 // never reference the file directly to ensure the
 // indepency of the json module
 import { decode as _decode, decodeFirst as _decodeFirst } from "@fireproof/vendor/cborg"
-import { Token, Type } from "@fireproof/vendor/cborg"
-import { decodeCodePointsArray } from "@fireproof/vendor/cborg"
-import { decodeErrPrefix } from "@fireproof/vendor/cborg"
+import { Token, Type, decodeCodePointsArray } from 'cborg/utils'
 
 /**
- * @typedef {import('../../interface').DecodeOptions} DecodeOptions
- * @typedef {import('../../interface').DecodeTokenizer} DecodeTokenizer
+ * @typedef {import('../interface').DecodeOptions} DecodeOptions
+ * @typedef {import('../interface').DecodeTokenizer} DecodeTokenizer
  */
 
 /**
@@ -18,7 +16,7 @@ class Tokenizer {
    * @param {Uint8Array} data
    * @param {DecodeOptions} options
    */
-  constructor (data, options = {}) {
+  constructor (data, options) {
     this._pos = 0
     this.data = data
     this.options = options
@@ -65,11 +63,11 @@ class Tokenizer {
    */
   expect (str) {
     if (this.data.length - this._pos < str.length) {
-      throw new Error(`${decodeErrPrefix} unexpected end of input at position ${this._pos}`)
+      throw new Error(`${this.options.decodeErrPrefix} unexpected end of input at position ${this._pos}`)
     }
     for (let i = 0; i < str.length; i++) {
       if (this.data[this._pos++] !== str[i]) {
-        throw new Error(`${decodeErrPrefix} unexpected token at position ${this._pos}, expected to find '${String.fromCharCode(...str)}'`)
+        throw new Error(`${this.options.decodeErrPrefix} unexpected token at position ${this._pos}, expected to find '${String.fromCharCode(...str)}'`)
       }
     }
   }
@@ -109,11 +107,11 @@ class Tokenizer {
     }
     swallow([48, 49, 50, 51, 52, 53, 54, 55, 56, 57]) // DIGIT
     if (negative && this._pos === startPos + 1) {
-      throw new Error(`${decodeErrPrefix} unexpected token at position ${this._pos}`)
+      throw new Error(`${this.options.decodeErrPrefix} unexpected token at position ${this._pos}`)
     }
     if (!this.done() && this.ch() === 46) { // '.'
       if (float) {
-        throw new Error(`${decodeErrPrefix} unexpected token at position ${this._pos}`)
+        throw new Error(`${this.options.decodeErrPrefix} unexpected token at position ${this._pos}`)
       }
       float = true
       this._pos++
@@ -146,7 +144,7 @@ class Tokenizer {
     /* c8 ignore next 4 */
     if (this.ch() !== 34) { // '"'
       // this would be a programming error
-      throw new Error(`${decodeErrPrefix} unexpected character at position ${this._pos}; this shouldn't happen`)
+      throw new Error(`${this.options.decodeErrPrefix} unexpected character at position ${this._pos}; this shouldn't happen`)
     }
     this._pos++
 
@@ -170,7 +168,7 @@ class Tokenizer {
 
     const readu4 = () => {
       if (this._pos + 4 >= this.data.length) {
-        throw new Error(`${decodeErrPrefix} unexpected end of unicode escape sequence at position ${this._pos}`)
+        throw new Error(`${this.options.decodeErrPrefix} unexpected end of unicode escape sequence at position ${this._pos}`)
       }
       let u4 = 0
       for (let i = 0; i < 4; i++) {
@@ -182,7 +180,7 @@ class Tokenizer {
         } else if (ch >= 65 && ch <= 70) { // 'A' && 'F'
           ch = ch - 65 + 10
         } else {
-          throw new Error(`${decodeErrPrefix} unexpected unicode escape character at position ${this._pos}`)
+          throw new Error(`${this.options.decodeErrPrefix} unexpected unicode escape character at position ${this._pos}`)
         }
         u4 = u4 * 16 + ch
         this._pos++
@@ -198,7 +196,7 @@ class Tokenizer {
       let bytesPerSequence = (firstByte > 0xef) ? 4 : (firstByte > 0xdf) ? 3 : (firstByte > 0xbf) ? 2 : 1
 
       if (this._pos + bytesPerSequence > this.data.length) {
-        throw new Error(`${decodeErrPrefix} unexpected unicode sequence at position ${this._pos}`)
+        throw new Error(`${this.options.decodeErrPrefix} unexpected unicode sequence at position ${this._pos}`)
       }
 
       let secondByte, thirdByte, fourthByte, tempCodePoint
@@ -269,7 +267,7 @@ class Tokenizer {
         case 92: // '\'
           this._pos++
           if (this.done()) {
-            throw new Error(`${decodeErrPrefix} unexpected string termination at position ${this._pos}`)
+            throw new Error(`${this.options.decodeErrPrefix} unexpected string termination at position ${this._pos}`)
           }
           ch1 = this.ch()
           this._pos++
@@ -299,7 +297,7 @@ class Tokenizer {
               chars.push(readu4())
               break
             default:
-              throw new Error(`${decodeErrPrefix} unexpected string escape character at position ${this._pos}`)
+              throw new Error(`${this.options.decodeErrPrefix} unexpected string escape character at position ${this._pos}`)
           }
           break
         case 34: // '"'
@@ -307,7 +305,7 @@ class Tokenizer {
           return new Token(Type.string, decodeCodePointsArray(chars), this._pos - startPos)
         default:
           if (ch < 32) { // ' '
-            throw new Error(`${decodeErrPrefix} invalid control character at position ${this._pos}`)
+            throw new Error(`${this.options.decodeErrPrefix} invalid control character at position ${this._pos}`)
           } else if (ch < 0x80) {
             chars.push(ch)
             this._pos++
@@ -317,7 +315,7 @@ class Tokenizer {
       }
     }
 
-    throw new Error(`${decodeErrPrefix} unexpected end of string at position ${this._pos}`)
+    throw new Error(`${this.options.decodeErrPrefix} unexpected end of string at position ${this._pos}`)
   }
 
   /**
@@ -358,7 +356,7 @@ class Tokenizer {
       case 57: // '9'
         return this.parseNumber()
       default:
-        throw new Error(`${decodeErrPrefix} unexpected character at position ${this._pos}`)
+        throw new Error(`${this.options.decodeErrPrefix} unexpected character at position ${this._pos}`)
     }
   }
 
@@ -379,7 +377,7 @@ class Tokenizer {
           return new Token(Type.break, undefined, 1)
         }
         if (this.ch() !== 44) { // ','
-          throw new Error(`${decodeErrPrefix} unexpected character at position ${this._pos}, was expecting array delimiter but found '${String.fromCharCode(this.ch())}'`)
+          throw new Error(`${this.options.decodeErrPrefix} unexpected character at position ${this._pos}, was expecting array delimiter but found '${String.fromCharCode(this.ch())}'`)
         }
         this._pos++
         this.modeStack.push('array-value')
@@ -406,7 +404,7 @@ class Tokenizer {
           return new Token(Type.break, undefined, 1)
         }
         if (this.ch() !== 44) { // ','
-          throw new Error(`${decodeErrPrefix} unexpected character at position ${this._pos}, was expecting object delimiter but found '${String.fromCharCode(this.ch())}'`)
+          throw new Error(`${this.options.decodeErrPrefix} unexpected character at position ${this._pos}, was expecting object delimiter but found '${String.fromCharCode(this.ch())}'`)
         }
         this._pos++
         this.skipWhitespace()
@@ -420,7 +418,7 @@ class Tokenizer {
         const token = this.parseString()
         this.skipWhitespace()
         if (this.ch() !== 58) { // ':'
-          throw new Error(`${decodeErrPrefix} unexpected character at position ${this._pos}, was expecting key/value delimiter ':' but found '${String.fromCharCode(this.ch())}'`)
+          throw new Error(`${this.options.decodeErrPrefix} unexpected character at position ${this._pos}, was expecting key/value delimiter ':' but found '${String.fromCharCode(this.ch())}'`)
         }
         this._pos++
         this.modeStack.push('obj-value')
@@ -434,7 +432,7 @@ class Tokenizer {
       }
       /* c8 ignore next 2 */
       default:
-        throw new Error(`${decodeErrPrefix} unexpected parse state at position ${this._pos}; this shouldn't happen`)
+        throw new Error(`${this.options.decodeErrPrefix} unexpected parse state at position ${this._pos}; this shouldn't happen`)
     }
   }
 }
@@ -445,7 +443,8 @@ class Tokenizer {
  * @returns {any}
  */
 function decode (data, options) {
-  options = Object.assign({ tokenizer: new Tokenizer(data, options) }, options)
+  options = { decodeErrPrefix: 'JSON decode error:', ...options }
+  options.tokenizer = options.tokenizer || new Tokenizer(data, options)
   return _decode(data, options)
 }
 
@@ -455,7 +454,8 @@ function decode (data, options) {
  * @returns {[any, Uint8Array]}
  */
 function decodeFirst (data, options) {
-  options = Object.assign({ tokenizer: new Tokenizer(data, options) }, options)
+  options = { decodeErrPrefix: 'JSON decode error:', ...options }
+  options.tokenizer = options.tokenizer || new Tokenizer(data, options)
   return _decodeFirst(data, options)
 }