cborg 3.0.0 → 4.0.1

package/.github/workflows/test-and-release.yml

@@ -44,17 +44,6 @@ jobs:
       - name: Build
         run: |
           npm run build
-      - name: Install plugins
-        run: |
-          npm install \
-            @semantic-release/commit-analyzer \
-            conventional-changelog-conventionalcommits \
-            @semantic-release/release-notes-generator \
-            @semantic-release/npm \
-            @semantic-release/github \
-            @semantic-release/git \
-            @semantic-release/changelog \
-            --no-progress --no-package-lock --no-save
       - name: Release
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

package/CHANGELOG.md

@@ -1,3 +1,27 @@
+## [4.0.1](https://github.com/rvagg/cborg/compare/v4.0.0...v4.0.1) (2023-09-12)
+
+## [4.0.0](https://github.com/rvagg/cborg/compare/v3.0.0...v4.0.0) (2023-09-12)
+
+
+### ⚠ BREAKING CHANGES
+
+* decodeFirst(), & require DecodeTokenizer to implement pos()
+
+### Features
+
+* add decodeFirst to json decoder ([a1bd349](https://github.com/rvagg/cborg/commit/a1bd349a6eb382737716ec1fc6c1061e710358d1))
+* decodeFirst(), & require DecodeTokenizer to implement pos() ([1b35871](https://github.com/rvagg/cborg/commit/1b358712d51bfd941382b6baab333722dafdada5))
+
+
+### Bug Fixes
+
+* make semantic-release work again ([7ab7a4e](https://github.com/rvagg/cborg/commit/7ab7a4eac21bfd3c98bf8836c3dccca9c56a41e4))
+
+
+### Trivial Changes
+
+* recompile types ([06133db](https://github.com/rvagg/cborg/commit/06133dbf73025b3e1af8065702d7d65ef03be407))
+
 ## [2.0.5](https://github.com/rvagg/cborg/compare/v2.0.4...v2.0.5) (2023-08-25)
 
 

package/README.md

@@ -27,6 +27,7 @@
     * [Options](#options)
   * [`decode(data[, options])`](#decodedata-options)
     * [Options](#options-1)
+  * [`decodeFirst(data[, options])`](#decodefirstdata-options)
   * [`encodedLength(data[, options])`](#encodedlengthdata-options)
   * [Type encoders](#type-encoders)
   * [Tag decoders](#tag-decoders)
@@ -196,10 +197,6 @@ $ cborg json2hex '["a", "b", 1, "😀"]'
 import { encode } from 'cborg'
 ```
 
-```js
-const { encode } = require('cborg')
-```
-
 Encode a JavaScript object and return a `Uint8Array` with the CBOR byte representation.
 
 * Objects containing circular references will be rejected.
@@ -226,10 +223,6 @@ Encode a JavaScript object and return a `Uint8Array` with the CBOR byte represen
 import { decode } from 'cborg'
 ```
 
-```js
-const { decode } = require('cborg')
-```
-
 Decode valid CBOR bytes from a `Uint8Array` (or `Buffer`) and return a JavaScript object.
 
 * Integers (major 0 and 1) that are outside of the safe integer range will be converted to a `BigInt`.
@@ -252,14 +245,47 @@ Decode valid CBOR bytes from a `Uint8Array` (or `Buffer`) and return a JavaScrip
 * `tags` (array): a mapping of tag number to tag decoder function. By default no tags are supported. See [Tag decoders](#tag-decoders).
 * `tokenizer` (object): an object with two methods, `next()` which returns a `Token` and `done()` which returns a `boolean`. Can be used to implement custom input decoding. See the source code for examples.
 
-### `encodedLength(data[, options])`
+### `decodeFirst(data[, options])`
 
 ```js
-import { encodedLength } from 'cborg/length'
+import { decodeFirst } from 'cborg'
 ```
 
+Decode valid CBOR bytes from a `Uint8Array` (or `Buffer`) and return a JavaScript object ***and*** the remainder of the original byte array that was not consumed by the decode. This can be useful for decoding concatenated CBOR objects, which is often used in streaming modes of CBOR.
+
+The returned remainder `Uint8Array` is a subarray of the original input `Uint8Array` and will share the same underlying buffer. This means that there are no new allocations performed by this function and it is as efficient to use as `decode` but without the additional byte-consumption check.
+
+The options for `decodeFirst` are the same as for [`decode()`](#decodedata-options), but the return type is different and `decodeFirst()` will not error if a decode operation doesn't consume all of the input bytes.
+
+The return value is an array with two elements:
+
+* `value`: the decoded JavaScript object
+* `remainder`: a `Uint8Array` containing the bytes that were not consumed by the decode operation
+
 ```js
-const { encodedLength } = require('cborg/length')
+import { decodeFirst } from 'cborg'
+
+let buf = Buffer.from('a16474686973a26269736543424f522163796179f564746869736269736543424f522163796179f5', 'hex')
+while (buf.length) {
+  const [value, remainder] = decodeFirst(buf)
+  console.log('decoded:', value)
+  buf = remainder
+}
+```
+
+```
+decoded: { this: { is: 'CBOR!', yay: true } }
+decoded: this
+decoded: is
+decoded: CBOR!
+decoded: yay
+decoded: true
+```
+
+### `encodedLength(data[, options])`
+
+```js
+import { encodedLength } from 'cborg/length'
 ```
 
 Calculate the byte length of the given data when encoded as CBOR with the options provided. The options are the same as for an `encode()` call. This calculation will be accurate if the same options are used as when performing a normal `encode()`. Some encode options can change the encoding output length.
@@ -400,7 +426,7 @@ There are a number of forms where an object will not round-trip precisely, if th
 
 **cborg** can also encode and decode JSON using the same pipeline and many of the same settings. For most (but not all) cases it will be faster to use `JSON.parse()` and `JSON.stringify()`, however **cborg** provides much more control over the process to handle determinism and be more restrictive in allowable forms. It also operates natively with Uint8Arrays rather than strings which may also offer some minor efficiency or usability gains in some circumstances.
 
-Use `import { encode, decode } from 'cborg/json'` or `const { encode, decode } = require('cborg/json')` to access the JSON handling encoder and decoder.
+Use `import { encode, decode, decodeFirst } from 'cborg/json'` to access the JSON handling encoder and decoder.
 
 Many of the same encode and decode options available for CBOR can be used to manage JSON handling. These include strictness requirements for decode and custom tag encoders for encode. Tag encoders can't create new tags as there are no tags in JSON, but they can replace JavaScript object forms with custom JSON forms (e.g. convert a `Uint8Array` to a valid JSON form rather than having the encoder throw an error). The inverse is also possible, turning specific JSON forms into JavaScript forms, by using a custom tokenizer on decode.
 

package/cborg.js

@@ -1,5 +1,5 @@
 import { encode } from './lib/encode.js'
-import { decode } from './lib/decode.js'
+import { decode, decodeFirst } from './lib/decode.js'
 import { Token, Type } from './lib/token.js'
 
 /**
@@ -13,6 +13,7 @@ import { Token, Type } from './lib/token.js'
 
 export {
   decode,
+  decodeFirst,
   encode,
   Token,
   Type

package/interface.ts

@@ -26,7 +26,8 @@ export type QuickEncodeToken = (token: Token) => Uint8Array | undefined
 
 export interface DecodeTokenizer {
   done(): boolean,
-  next(): Token
+  next(): Token,
+  pos(): number,
 }
 
 export type TagDecoder = (inner: any) => any

package/lib/byte-utils.js

@@ -275,101 +275,44 @@ export function compare (b1, b2) {
   return 0
 }
 
-// The below code is mostly taken from https://github.com/feross/buffer
-// Licensed MIT. Copyright (c) Feross Aboukhadijeh
+// The below code is taken from https://github.com/google/closure-library/blob/8598d87242af59aac233270742c8984e2b2bdbe0/closure/goog/crypt/crypt.js#L117-L143
+// Licensed Apache-2.0.
 
 /**
- * @param {string} string
- * @param {number} [units]
+ * @param {string} str
  * @returns {number[]}
  */
-function utf8ToBytes (string, units = Infinity) {
-  let codePoint
-  const length = string.length
-  let leadSurrogate = null
-  const bytes = []
-
-  for (let i = 0; i < length; ++i) {
-    codePoint = string.charCodeAt(i)
-
-    // is surrogate component
-    if (codePoint > 0xd7ff && codePoint < 0xe000) {
-      // last char was a lead
-      if (!leadSurrogate) {
-        // no lead yet
-        /* c8 ignore next 9 */
-        if (codePoint > 0xdbff) {
-          // unexpected trail
-          if ((units -= 3) > -1) bytes.push(0xef, 0xbf, 0xbd)
-          continue
-        } else if (i + 1 === length) {
-          // unpaired lead
-          if ((units -= 3) > -1) bytes.push(0xef, 0xbf, 0xbd)
-          continue
-        }
-
-        // valid lead
-        leadSurrogate = codePoint
-
-        continue
-      }
-
-      // 2 leads in a row
-      /* c8 ignore next 5 */
-      if (codePoint < 0xdc00) {
-        if ((units -= 3) > -1) bytes.push(0xef, 0xbf, 0xbd)
-        leadSurrogate = codePoint
-        continue
-      }
-
-      // valid surrogate pair
-      codePoint = (leadSurrogate - 0xd800 << 10 | codePoint - 0xdc00) + 0x10000
-    /* c8 ignore next 4 */
-    } else if (leadSurrogate) {
-      // valid bmp char, but last char was a lead
-      if ((units -= 3) > -1) bytes.push(0xef, 0xbf, 0xbd)
-    }
-
-    leadSurrogate = null
-
-    // encode utf8
-    if (codePoint < 0x80) {
-      /* c8 ignore next 1 */
-      if ((units -= 1) < 0) break
-      bytes.push(codePoint)
-    } else if (codePoint < 0x800) {
-      /* c8 ignore next 1 */
-      if ((units -= 2) < 0) break
-      bytes.push(
-        codePoint >> 0x6 | 0xc0,
-        codePoint & 0x3f | 0x80
-      )
-    } else if (codePoint < 0x10000) {
-      /* c8 ignore next 1 */
-      if ((units -= 3) < 0) break
-      bytes.push(
-        codePoint >> 0xc | 0xe0,
-        codePoint >> 0x6 & 0x3f | 0x80,
-        codePoint & 0x3f | 0x80
-      )
-    /* c8 ignore next 9 */
-    } else if (codePoint < 0x110000) {
-      if ((units -= 4) < 0) break
-      bytes.push(
-        codePoint >> 0x12 | 0xf0,
-        codePoint >> 0xc & 0x3f | 0x80,
-        codePoint >> 0x6 & 0x3f | 0x80,
-        codePoint & 0x3f | 0x80
-      )
+function utf8ToBytes (str) {
+  const out = []
+  let p = 0
+  for (let i = 0; i < str.length; i++) {
+    let c = str.charCodeAt(i)
+    if (c < 128) {
+      out[p++] = c
+    } else if (c < 2048) {
+      out[p++] = (c >> 6) | 192
+      out[p++] = (c & 63) | 128
+    } else if (
+      ((c & 0xFC00) === 0xD800) && (i + 1) < str.length &&
+      ((str.charCodeAt(i + 1) & 0xFC00) === 0xDC00)) {
+      // Surrogate Pair
+      c = 0x10000 + ((c & 0x03FF) << 10) + (str.charCodeAt(++i) & 0x03FF)
+      out[p++] = (c >> 18) | 240
+      out[p++] = ((c >> 12) & 63) | 128
+      out[p++] = ((c >> 6) & 63) | 128
+      out[p++] = (c & 63) | 128
     } else {
-      /* c8 ignore next 2 */
-      throw new Error('Invalid code point')
+      out[p++] = (c >> 12) | 224
+      out[p++] = ((c >> 6) & 63) | 128
+      out[p++] = (c & 63) | 128
     }
   }
-
-  return bytes
+  return out
 }
 
+// The below code is mostly taken from https://github.com/feross/buffer
+// Licensed MIT. Copyright (c) Feross Aboukhadijeh
+
 /**
  * @param {Uint8Array} buf
  * @param {number} offset

package/lib/decode.js

@@ -24,17 +24,21 @@ class Tokeniser {
    * @param {DecodeOptions} options
    */
   constructor (data, options = {}) {
-    this.pos = 0
+    this._pos = 0
     this.data = data
     this.options = options
   }
 
+  pos () {
+    return this._pos
+  }
+
   done () {
-    return this.pos >= this.data.length
+    return this._pos >= this.data.length
   }
 
   next () {
-    const byt = this.data[this.pos]
+    const byt = this.data[this._pos]
     let token = quick[byt]
     if (token === undefined) {
       const decoder = jump[byt]
@@ -44,10 +48,10 @@ class Tokeniser {
         throw new Error(`${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)
+      token = decoder(this.data, this._pos, minor, this.options)
     }
     // @ts-ignore we get to assume encodedLength is set (crossing fingers slightly)
-    this.pos += token.encodedLength
+    this._pos += token.encodedLength
     return token
   }
 }
@@ -171,9 +175,9 @@ function tokensToObject (tokeniser, options) {
 /**
  * @param {Uint8Array} data
  * @param {DecodeOptions} [options]
- * @returns {any}
+ * @returns {[any, Uint8Array]}
  */
-function decode (data, options) {
+function decodeFirst (data, options) {
   if (!(data instanceof Uint8Array)) {
     throw new Error(`${decodeErrPrefix} data to decode must be a Uint8Array`)
   }
@@ -186,10 +190,20 @@ function decode (data, options) {
   if (decoded === BREAK) {
     throw new Error(`${decodeErrPrefix} got unexpected break`)
   }
-  if (!tokeniser.done()) {
+  return [decoded, data.subarray(tokeniser.pos())]
+}
+
+/**
+ * @param {Uint8Array} data
+ * @param {DecodeOptions} [options]
+ * @returns {any}
+ */
+function decode (data, options) {
+  const [decoded, remainder] = decodeFirst(data, options)
+  if (remainder.length > 0) {
     throw new Error(`${decodeErrPrefix} too many terminals, data makes no sense`)
   }
   return decoded
 }
 
-export { Tokeniser, tokensToObject, decode }
+export { Tokeniser, tokensToObject, decode, decodeFirst }

package/lib/json/decode.js

@@ -1,4 +1,4 @@
-import { decode as _decode } from '../decode.js'
+import { decode as _decode, decodeFirst as _decodeFirst } from '../decode.js'
 import { Token, Type } from '../token.js'
 import { decodeCodePointsArray } from '../byte-utils.js'
 import { decodeErrPrefix } from '../common.js'
@@ -17,7 +17,7 @@ class Tokenizer {
    * @param {DecodeOptions} options
    */
   constructor (data, options = {}) {
-    this.pos = 0
+    this._pos = 0
     this.data = data
     this.options = options
     /** @type {string[]} */
@@ -25,18 +25,22 @@ class Tokenizer {
     this.lastToken = ''
   }
 
+  pos () {
+    return this._pos
+  }
+
   /**
    * @returns {boolean}
    */
   done () {
-    return this.pos >= this.data.length
+    return this._pos >= this.data.length
   }
 
   /**
    * @returns {number}
    */
   ch () {
-    return this.data[this.pos]
+    return this.data[this._pos]
   }
 
   /**
@@ -50,7 +54,7 @@ class Tokenizer {
     let c = this.ch()
     // @ts-ignore
     while (c === 32 /* ' ' */ || c === 9 /* '\t' */ || c === 13 /* '\r' */ || c === 10 /* '\n' */) {
-      c = this.data[++this.pos]
+      c = this.data[++this._pos]
     }
   }
 
@@ -58,18 +62,18 @@ class Tokenizer {
    * @param {number[]} str
    */
   expect (str) {
-    if (this.data.length - this.pos < str.length) {
-      throw new Error(`${decodeErrPrefix} unexpected end of input at position ${this.pos}`)
+    if (this.data.length - this._pos < str.length) {
+      throw new Error(`${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)}'`)
+      if (this.data[this._pos++] !== str[i]) {
+        throw new Error(`${decodeErrPrefix} unexpected token at position ${this._pos}, expected to find '${String.fromCharCode(...str)}'`)
       }
     }
   }
 
   parseNumber () {
-    const startPos = this.pos
+    const startPos = this._pos
     let negative = false
     let float = false
 
@@ -80,7 +84,7 @@ class Tokenizer {
       while (!this.done()) {
         const ch = this.ch()
         if (chars.includes(ch)) {
-          this.pos++
+          this._pos++
         } else {
           break
         }
@@ -90,47 +94,47 @@ class Tokenizer {
     // lead
     if (this.ch() === 45) { // '-'
       negative = true
-      this.pos++
+      this._pos++
     }
     if (this.ch() === 48) { // '0'
-      this.pos++
+      this._pos++
       if (this.ch() === 46) { // '.'
-        this.pos++
+        this._pos++
         float = true
       } else {
-        return new Token(Type.uint, 0, this.pos - startPos)
+        return new Token(Type.uint, 0, this._pos - startPos)
       }
     }
     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}`)
+    if (negative && this._pos === startPos + 1) {
+      throw new Error(`${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(`${decodeErrPrefix} unexpected token at position ${this._pos}`)
       }
       float = true
-      this.pos++
+      this._pos++
       swallow([48, 49, 50, 51, 52, 53, 54, 55, 56, 57]) // DIGIT
     }
     if (!this.done() && (this.ch() === 101 || this.ch() === 69)) { // '[eE]'
       float = true
-      this.pos++
+      this._pos++
       if (!this.done() && (this.ch() === 43 || this.ch() === 45)) { // '+', '-'
-        this.pos++
+        this._pos++
       }
       swallow([48, 49, 50, 51, 52, 53, 54, 55, 56, 57]) // DIGIT
     }
     // @ts-ignore
-    const numStr = String.fromCharCode.apply(null, this.data.subarray(startPos, this.pos))
+    const numStr = String.fromCharCode.apply(null, this.data.subarray(startPos, this._pos))
     const num = parseFloat(numStr)
     if (float) {
-      return new Token(Type.float, num, this.pos - startPos)
+      return new Token(Type.float, num, this._pos - startPos)
     }
     if (this.options.allowBigInt !== true || Number.isSafeInteger(num)) {
-      return new Token(num >= 0 ? Type.uint : Type.negint, num, this.pos - startPos)
+      return new Token(num >= 0 ? Type.uint : Type.negint, num, this._pos - startPos)
     }
-    return new Token(num >= 0 ? Type.uint : Type.negint, BigInt(numStr), this.pos - startPos)
+    return new Token(num >= 0 ? Type.uint : Type.negint, BigInt(numStr), this._pos - startPos)
   }
 
   /**
@@ -140,31 +144,31 @@ 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(`${decodeErrPrefix} unexpected character at position ${this._pos}; this shouldn't happen`)
     }
-    this.pos++
+    this._pos++
 
     // check for simple fast-path, all printable ascii, no escapes
     // >0x10000 elements may fail fn.apply() (http://stackoverflow.com/a/22747272/680742)
-    for (let i = this.pos, l = 0; i < this.data.length && l < 0x10000; i++, l++) {
+    for (let i = this._pos, l = 0; i < this.data.length && l < 0x10000; i++, l++) {
       const ch = this.data[i]
       if (ch === 92 || ch < 32 || ch >= 128) { // '\', ' ', control-chars or non-trivial
         break
       }
       if (ch === 34) { // '"'
         // @ts-ignore
-        const str = String.fromCharCode.apply(null, this.data.subarray(this.pos, i))
-        this.pos = i + 1
+        const str = String.fromCharCode.apply(null, this.data.subarray(this._pos, i))
+        this._pos = i + 1
         return new Token(Type.string, str, l)
       }
     }
 
-    const startPos = this.pos
+    const startPos = this._pos
     const chars = []
 
     const readu4 = () => {
-      if (this.pos + 4 >= this.data.length) {
-        throw new Error(`${decodeErrPrefix} unexpected end of unicode escape sequence at position ${this.pos}`)
+      if (this._pos + 4 >= this.data.length) {
+        throw new Error(`${decodeErrPrefix} unexpected end of unicode escape sequence at position ${this._pos}`)
       }
       let u4 = 0
       for (let i = 0; i < 4; i++) {
@@ -176,10 +180,10 @@ 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(`${decodeErrPrefix} unexpected unicode escape character at position ${this._pos}`)
         }
         u4 = u4 * 16 + ch
-        this.pos++
+        this._pos++
       }
       return u4
     }
@@ -191,8 +195,8 @@ class Tokenizer {
       /* c8 ignore next 1 */
       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}`)
+      if (this._pos + bytesPerSequence > this.data.length) {
+        throw new Error(`${decodeErrPrefix} unexpected unicode sequence at position ${this._pos}`)
       }
 
       let secondByte, thirdByte, fourthByte, tempCodePoint
@@ -206,7 +210,7 @@ class Tokenizer {
           }
           break
         case 2:
-          secondByte = this.data[this.pos + 1]
+          secondByte = this.data[this._pos + 1]
           if ((secondByte & 0xc0) === 0x80) {
             tempCodePoint = (firstByte & 0x1f) << 0x6 | (secondByte & 0x3f)
             if (tempCodePoint > 0x7f) {
@@ -215,8 +219,8 @@ class Tokenizer {
           }
           break
         case 3:
-          secondByte = this.data[this.pos + 1]
-          thirdByte = this.data[this.pos + 2]
+          secondByte = this.data[this._pos + 1]
+          thirdByte = this.data[this._pos + 2]
           if ((secondByte & 0xc0) === 0x80 && (thirdByte & 0xc0) === 0x80) {
             tempCodePoint = (firstByte & 0xf) << 0xc | (secondByte & 0x3f) << 0x6 | (thirdByte & 0x3f)
             /* c8 ignore next 3 */
@@ -226,9 +230,9 @@ class Tokenizer {
           }
           break
         case 4:
-          secondByte = this.data[this.pos + 1]
-          thirdByte = this.data[this.pos + 2]
-          fourthByte = this.data[this.pos + 3]
+          secondByte = this.data[this._pos + 1]
+          thirdByte = this.data[this._pos + 2]
+          fourthByte = this.data[this._pos + 3]
           if ((secondByte & 0xc0) === 0x80 && (thirdByte & 0xc0) === 0x80 && (fourthByte & 0xc0) === 0x80) {
             tempCodePoint = (firstByte & 0xf) << 0x12 | (secondByte & 0x3f) << 0xc | (thirdByte & 0x3f) << 0x6 | (fourthByte & 0x3f)
             if (tempCodePoint > 0xffff && tempCodePoint < 0x110000) {
@@ -251,7 +255,7 @@ class Tokenizer {
       }
 
       chars.push(codePoint)
-      this.pos += bytesPerSequence
+      this._pos += bytesPerSequence
     }
 
     // TODO: could take the approach of a quick first scan for special chars like encoding/json/decode.go#unquoteBytes
@@ -261,12 +265,12 @@ class Tokenizer {
       let ch1
       switch (ch) {
         case 92: // '\'
-          this.pos++
+          this._pos++
           if (this.done()) {
-            throw new Error(`${decodeErrPrefix} unexpected string termination at position ${this.pos}`)
+            throw new Error(`${decodeErrPrefix} unexpected string termination at position ${this._pos}`)
           }
           ch1 = this.ch()
-          this.pos++
+          this._pos++
           switch (ch1) {
             case 34: // '"'
             case 39: // '\''
@@ -293,25 +297,25 @@ class Tokenizer {
               chars.push(readu4())
               break
             default:
-              throw new Error(`${decodeErrPrefix} unexpected string escape character at position ${this.pos}`)
+              throw new Error(`${decodeErrPrefix} unexpected string escape character at position ${this._pos}`)
           }
           break
         case 34: // '"'
-          this.pos++
-          return new Token(Type.string, decodeCodePointsArray(chars), this.pos - startPos)
+          this._pos++
+          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(`${decodeErrPrefix} invalid control character at position ${this._pos}`)
           } else if (ch < 0x80) {
             chars.push(ch)
-            this.pos++
+            this._pos++
           } else {
             readUtf8Char()
           }
       }
     }
 
-    throw new Error(`${decodeErrPrefix} unexpected end of string at position ${this.pos}`)
+    throw new Error(`${decodeErrPrefix} unexpected end of string at position ${this._pos}`)
   }
 
   /**
@@ -321,11 +325,11 @@ class Tokenizer {
     switch (this.ch()) {
       case 123: // '{'
         this.modeStack.push('obj-start')
-        this.pos++
+        this._pos++
         return new Token(Type.map, Infinity, 1)
       case 91: // '['
         this.modeStack.push('array-start')
-        this.pos++
+        this._pos++
         return new Token(Type.array, Infinity, 1)
       case 34: { // '"'
         return this.parseString()
@@ -352,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(`${decodeErrPrefix} unexpected character at position ${this._pos}`)
     }
   }
 
@@ -368,14 +372,14 @@ class Tokenizer {
       case 'array-value': {
         this.modeStack.pop()
         if (this.ch() === 93) { // ']'
-          this.pos++
+          this._pos++
           this.skipWhitespace()
           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(`${decodeErrPrefix} unexpected character at position ${this._pos}, was expecting array delimiter but found '${String.fromCharCode(this.ch())}'`)
         }
-        this.pos++
+        this._pos++
         this.modeStack.push('array-value')
         this.skipWhitespace()
         return this.parseValue()
@@ -383,7 +387,7 @@ class Tokenizer {
       case 'array-start': {
         this.modeStack.pop()
         if (this.ch() === 93) { // ']'
-          this.pos++
+          this._pos++
           this.skipWhitespace()
           return new Token(Type.break, undefined, 1)
         }
@@ -395,28 +399,28 @@ class Tokenizer {
       case 'obj-key':
         if (this.ch() === 125) { // '}'
           this.modeStack.pop()
-          this.pos++
+          this._pos++
           this.skipWhitespace()
           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(`${decodeErrPrefix} unexpected character at position ${this._pos}, was expecting object delimiter but found '${String.fromCharCode(this.ch())}'`)
         }
-        this.pos++
+        this._pos++
         this.skipWhitespace()
       case 'obj-start': { // eslint-disable-line no-fallthrough
         this.modeStack.pop()
         if (this.ch() === 125) { // '}'
-          this.pos++
+          this._pos++
           this.skipWhitespace()
           return new Token(Type.break, undefined, 1)
         }
         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(`${decodeErrPrefix} unexpected character at position ${this._pos}, was expecting key/value delimiter ':' but found '${String.fromCharCode(this.ch())}'`)
         }
-        this.pos++
+        this._pos++
         this.modeStack.push('obj-value')
         return token
       }
@@ -428,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(`${decodeErrPrefix} unexpected parse state at position ${this._pos}; this shouldn't happen`)
     }
   }
 }
@@ -443,4 +447,14 @@ function decode (data, options) {
   return _decode(data, options)
 }
 
-export { decode, Tokenizer }
+/**
+ * @param {Uint8Array} data
+ * @param {DecodeOptions} [options]
+ * @returns {[any, Uint8Array]}
+ */
+function decodeFirst (data, options) {
+  options = Object.assign({ tokenizer: new Tokenizer(data, options) }, options)
+  return _decodeFirst(data, options)
+}
+
+export { decode, decodeFirst, Tokenizer }

package/lib/json/json.js

@@ -1,4 +1,4 @@
 import { encode } from './encode.js'
-import { decode, Tokenizer } from './decode.js'
+import { decode, decodeFirst, Tokenizer } from './decode.js'
 
-export { encode, decode, Tokenizer }
+export { encode, decode, decodeFirst, Tokenizer }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cborg",
-  "version": "3.0.0",
+  "version": "4.0.1",
   "description": "Fast CBOR with a focus on strictness",
   "main": "cborg.js",
   "type": "module",
@@ -20,7 +20,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/rvagg/cborg.git"
+    "url": "git@github.com:rvagg/cborg.git"
   },
   "keywords": [
     "cbor"
@@ -28,14 +28,22 @@
   "author": "Rod <rod@vagg.org> (http://r.va.gg/)",
   "license": "Apache-2.0",
   "devDependencies": {
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/commit-analyzer": "^10.0.4",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^9.0.5",
+    "@semantic-release/npm": "^10.0.5",
+    "@semantic-release/release-notes-generator": "^11.0.7",
     "@types/chai": "^4.3.6",
     "@types/mocha": "^10.0.1",
     "@types/node": "^20.5.9",
     "c8": "^8.0.1",
     "chai": "^4.3.8",
+    "conventional-changelog-conventionalcommits": "^6.1.0",
     "ipld-garbage": "^5.0.0",
     "mocha": "^10.2.0",
     "polendina": "^3.2.1",
+    "semantic-release": "^21.1.1",
     "standard": "^17.1.0",
     "typescript": "^5.2.2"
   },

package/test/test-json.js

@@ -1,7 +1,7 @@
 /* eslint-env mocha,es2020 */
 
 import { assert } from 'chai'
-import { decode, encode } from 'cborg/json'
+import { decode, decodeFirst, encode } from 'cborg/json'
 
 const toBytes = (str) => new TextEncoder().encode(str)
 
@@ -188,4 +188,32 @@ describe('json basics', () => {
     assert.deepStrictEqual(decode(toBytes('{"foo":1,"foo":2}')), { foo: 2 })
     assert.throws(() => decode(toBytes('{"foo":1,"foo":2}'), { rejectDuplicateMapKeys: true }), /CBOR decode error: found repeat map key "foo"/)
   })
+
+  it('decodeFirst', () => {
+    /*
+    const encoded = new TextDecoder().decode(encode(obj, sorting === false ? { mapSorter: null } : undefined))
+    const json = JSON.stringify(obj)
+    assert.strictEqual(encoded, json)
+    const decoded = decode(toBytes(JSON.stringify(obj)))
+    assert.deepStrictEqual(decoded, obj)
+    */
+    let buf = new TextEncoder().encode('{"foo":1,"bar":2}1"ping"2null3[1,2,3]""[[],[],{"boop":true}]')
+    const expected = [
+      { foo: 1, bar: 2 },
+      1,
+      'ping',
+      2,
+      null,
+      3,
+      [1, 2, 3],
+      '',
+      [[], [], { boop: true }]
+    ]
+    for (const exp of expected) {
+      const [obj, rest] = decodeFirst(buf)
+      assert.deepStrictEqual(exp, obj)
+      buf = rest
+    }
+    assert.strictEqual(buf.length, 0)
+  })
 })

package/test/test-partial.js

@@ -0,0 +1,111 @@
+/* eslint-env mocha */
+
+import chai from 'chai'
+import { garbage } from 'ipld-garbage'
+import { uintBoundaries } from '../lib/0uint.js'
+import { encode, decodeFirst } from '../cborg.js'
+import { dateDecoder, dateEncoder } from './common.js'
+
+const { assert } = chai
+
+function verifyPartial (objects, options) {
+  const encoded = []
+  const lengths = []
+  let length = 0
+  for (const object of Array.isArray(objects) ? objects : [objects]) {
+    encoded.push(encode(object, options))
+    const l = encoded[encoded.length - 1].length
+    length += l
+    lengths.push(l)
+  }
+  const buf = new Uint8Array(length)
+  let offset = 0
+  for (const enc of encoded) {
+    buf.set(enc, offset)
+    offset += enc.length
+  }
+  let partial = buf
+  for (let ii = 0; ii < encoded.length; ii++) {
+    const [decoded, remainder] = decodeFirst(partial, options)
+    assert.deepEqual(decoded, objects[ii])
+    assert.equal(remainder.length, partial.length - lengths[ii])
+    partial = remainder
+  }
+  assert.equal(partial.length, 0) // just to be sure
+}
+
+describe('decodePartial', () => {
+  describe('multiple', () => {
+    it('simple', () => {
+      verifyPartial([1, 2, 3])
+      verifyPartial([8.940696716308594e-08, 1])
+      verifyPartial([
+        [],
+        [1, 2, { obj: 1.5 }, null, new Uint8Array([1, 2, 3])],
+        { boop: true, bop: 1 },
+        'nope',
+        { o: 'nope' },
+        new Uint8Array([1, 2, 3]),
+        true,
+        null
+      ])
+    })
+
+    it('options', () => {
+      const m = new Map()
+      m.set('a', 1)
+      m.set('b', null)
+      m.set('c', 'grok')
+      m.set('date', new Date('2013-03-21T20:04:00Z'))
+      verifyPartial(
+        [8.940696716308594e-08, 1, null, 'grok', new Date('2013-03-21T20:04:00Z'),
+          [8.940696716308594e-08, 1, null, 'grok', new Date('2013-03-21T20:04:00Z')],
+          m
+        ],
+        { typeEncoders: { Date: dateEncoder }, useMaps: true, tags: { 0: dateDecoder } })
+    })
+
+    it('garbage', function () {
+      this.timeout(10000)
+      for (let ii = 0; ii < 10; ii++) {
+        const gbg = []
+        for (let ii = 0; ii < 100; ii++) {
+          gbg.push(garbage(1 << 6, { weights: { CID: 0 } }))
+        }
+        verifyPartial(gbg)
+      }
+    })
+  })
+
+  it('singular', () => {
+    it('int boundaries', () => {
+      for (let ii = 0; ii < 4; ii++) {
+        verifyPartial(uintBoundaries[ii])
+        verifyPartial(uintBoundaries[ii] - 1)
+        verifyPartial(uintBoundaries[ii] + 1)
+        verifyPartial(-1 * uintBoundaries[ii])
+        verifyPartial(-1 * uintBoundaries[ii] - 1)
+        verifyPartial(-1 * uintBoundaries[ii] + 1)
+      }
+    })
+
+    it('tags', () => {
+      verifyPartial({ date: new Date('2013-03-21T20:04:00Z') }, { typeEncoders: { Date: dateEncoder } })
+    })
+
+    it('floats', () => {
+      verifyPartial(0.5)
+      verifyPartial(0.5, { float64: true })
+      verifyPartial(8.940696716308594e-08)
+      verifyPartial(8.940696716308594e-08, { float64: true })
+    })
+
+    it('small garbage', function () {
+      this.timeout(10000)
+      for (let ii = 0; ii < 1000; ii++) {
+        const gbg = garbage(1 << 6, { weights: { CID: 0 } })
+        verifyPartial(gbg)
+      }
+    })
+  })
+})

package/types/cborg.d.ts

@@ -15,8 +15,9 @@ export type DecodeOptions = import('./interface').DecodeOptions;
  */
 export type EncodeOptions = import('./interface').EncodeOptions;
 import { decode } from './lib/decode.js';
+import { decodeFirst } from './lib/decode.js';
 import { encode } from './lib/encode.js';
 import { Token } from './lib/token.js';
 import { Type } from './lib/token.js';
-export { decode, encode, Token, Type };
+export { decode, decodeFirst, encode, Token, Type };
 //# sourceMappingURL=cborg.d.ts.map

package/types/cborg.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cborg.d.ts","sourceRoot":"","sources":["../cborg.js"],"names":[],"mappings":";;;yBAMa,OAAO,aAAa,EAAE,UAAU;;;;0BAEhC,OAAO,aAAa,EAAE,mBAAmB;;;;4BACzC,OAAO,aAAa,EAAE,aAAa;;;;4BACnC,OAAO,aAAa,EAAE,aAAa;uBATzB,iBAAiB;uBADjB,iBAAiB;sBAEZ,gBAAgB;qBAAhB,gBAAgB"}
+{"version":3,"file":"cborg.d.ts","sourceRoot":"","sources":["../cborg.js"],"names":[],"mappings":";;;yBAMa,OAAO,aAAa,EAAE,UAAU;;;;0BAEhC,OAAO,aAAa,EAAE,mBAAmB;;;;4BACzC,OAAO,aAAa,EAAE,aAAa;;;;4BACnC,OAAO,aAAa,EAAE,aAAa;uBATZ,iBAAiB;4BAAjB,iBAAiB;uBAD9B,iBAAiB;sBAEZ,gBAAgB;qBAAhB,gBAAgB"}

package/types/interface.d.ts

@@ -18,6 +18,7 @@ export type QuickEncodeToken = (token: Token) => Uint8Array | undefined;
 export interface DecodeTokenizer {
     done(): boolean;
     next(): Token;
+    pos(): number;
 }
 export type TagDecoder = (inner: any) => any;
 export interface DecodeOptions {

package/types/interface.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AACnC,OAAO,EAAE,EAAE,EAAE,MAAM,UAAU,CAAA;AAE7B,MAAM,MAAM,mBAAmB,GAAG,KAAK,GAAG,KAAK,EAAE,GAAG,mBAAmB,EAAE,CAAA;AAEzE,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,SAAS,GAAG,SAAS,CAAA;IAC7B,GAAG,EAAE,MAAM,GAAG,GAAG,EAAE,CAAA;IACnB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,EAAE,GAAG,OAAO,CAAA;CACvC;AAED,MAAM,MAAM,mBAAmB,GAAG,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,QAAQ,CAAC,EAAE,SAAS,KAAK,mBAAmB,GAAG,IAAI,CAAA;AAEtI,MAAM,MAAM,iBAAiB,GAAG,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,QAAQ,CAAC,EAAE,SAAS,KAAK,mBAAmB,CAAA;AAE7H,MAAM,MAAM,gBAAgB,GAAG;IAC7B,CAAC,GAAG,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;IACvD,aAAa,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,GAAG,MAAM,CAAC;IAE5C,WAAW,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,MAAM,CAAC;CAC7D,CAAA;AAED,MAAM,MAAM,SAAS,GAAG,CAAC,EAAE,EAAE,CAAC,KAAK,GAAG,KAAK,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,KAAK,GAAG,KAAK,EAAE,CAAC,EAAE,KAAK,MAAM,CAAA;AAEpF,MAAM,MAAM,gBAAgB,GAAG,CAAC,KAAK,EAAE,KAAK,KAAK,UAAU,GAAG,SAAS,CAAA;AAEvE,MAAM,WAAW,eAAe;IAC9B,IAAI,IAAI,OAAO,CAAC;IAChB,IAAI,IAAI,KAAK,CAAA;CACd;AAED,MAAM,MAAM,UAAU,GAAG,CAAC,KAAK,EAAE,GAAG,KAAK,GAAG,CAAA;AAE5C,MAAM,WAAW,aAAa;IAC5B,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,qBAAqB,CAAC,EAAE,OAAO,CAAA;IAC/B,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,sBAAsB,CAAC,EAAE,OAAO,CAAA;IAChC,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B,IAAI,CAAC,EAAE,UAAU,EAAE,CAAC;IACpB,SAAS,CAAC,EAAE,eAAe,CAAA;CAC5B;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC,YAAY,CAAC,EAAE;QAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,mBAAmB,CAAA;KAAE,CAAA;CAC3D"}
+{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AACnC,OAAO,EAAE,EAAE,EAAE,MAAM,UAAU,CAAA;AAE7B,MAAM,MAAM,mBAAmB,GAAG,KAAK,GAAG,KAAK,EAAE,GAAG,mBAAmB,EAAE,CAAA;AAEzE,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,SAAS,GAAG,SAAS,CAAA;IAC7B,GAAG,EAAE,MAAM,GAAG,GAAG,EAAE,CAAA;IACnB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,EAAE,GAAG,OAAO,CAAA;CACvC;AAED,MAAM,MAAM,mBAAmB,GAAG,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,QAAQ,CAAC,EAAE,SAAS,KAAK,mBAAmB,GAAG,IAAI,CAAA;AAEtI,MAAM,MAAM,iBAAiB,GAAG,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,QAAQ,CAAC,EAAE,SAAS,KAAK,mBAAmB,CAAA;AAE7H,MAAM,MAAM,gBAAgB,GAAG;IAC7B,CAAC,GAAG,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;IACvD,aAAa,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,GAAG,MAAM,CAAC;IAE5C,WAAW,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,MAAM,CAAC;CAC7D,CAAA;AAED,MAAM,MAAM,SAAS,GAAG,CAAC,EAAE,EAAE,CAAC,KAAK,GAAG,KAAK,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,KAAK,GAAG,KAAK,EAAE,CAAC,EAAE,KAAK,MAAM,CAAA;AAEpF,MAAM,MAAM,gBAAgB,GAAG,CAAC,KAAK,EAAE,KAAK,KAAK,UAAU,GAAG,SAAS,CAAA;AAEvE,MAAM,WAAW,eAAe;IAC9B,IAAI,IAAI,OAAO,CAAC;IAChB,IAAI,IAAI,KAAK,CAAC;IACd,GAAG,IAAI,MAAM,CAAC;CACf;AAED,MAAM,MAAM,UAAU,GAAG,CAAC,KAAK,EAAE,GAAG,KAAK,GAAG,CAAA;AAE5C,MAAM,WAAW,aAAa;IAC5B,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,qBAAqB,CAAC,EAAE,OAAO,CAAA;IAC/B,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,sBAAsB,CAAC,EAAE,OAAO,CAAA;IAChC,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B,IAAI,CAAC,EAAE,UAAU,EAAE,CAAC;IACpB,SAAS,CAAC,EAAE,eAAe,CAAA;CAC5B;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC,YAAY,CAAC,EAAE;QAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,mBAAmB,CAAA;KAAE,CAAA;CAC3D"}

package/types/lib/decode.d.ts

@@ -10,9 +10,10 @@ export class Tokeniser implements DecodeTokenizer {
      * @param {DecodeOptions} options
      */
     constructor(data: Uint8Array, options?: DecodeOptions);
-    pos: number;
+    _pos: number;
     data: Uint8Array;
     options: import("../interface").DecodeOptions;
+    pos(): number;
     done(): boolean;
     next(): import("./token.js").Token;
 }
@@ -28,6 +29,12 @@ export function tokensToObject(tokeniser: DecodeTokenizer, options: DecodeOption
  * @returns {any}
  */
 export function decode(data: Uint8Array, options?: import("../interface").DecodeOptions | undefined): any;
+/**
+ * @param {Uint8Array} data
+ * @param {DecodeOptions} [options]
+ * @returns {[any, Uint8Array]}
+ */
+export function decodeFirst(data: Uint8Array, options?: import("../interface").DecodeOptions | undefined): [any, Uint8Array];
 declare const BREAK: unique symbol;
 declare const DONE: unique symbol;
 export {};

package/types/lib/decode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decode.d.ts","sourceRoot":"","sources":["../../lib/decode.js"],"names":[],"mappings":"oBAKa,OAAO,YAAY,EAAE,KAAK;4BAC1B,OAAO,cAAc,EAAE,aAAa;8BACpC,OAAO,cAAc,EAAE,eAAe;AAUnD;;GAEG;AACH;IACE;;;OAGG;IACH,kBAHW,UAAU,YACV,aAAa,EAMvB;IAHC,YAAY;IACZ,iBAAgB;IAChB,8CAAsB;IAGxB,gBAEC;IAED,mCAgBC;CACF;AA6ED;;;;GAIG;AACH,0CAJW,eAAe,WACf,aAAa,GACX,GAAG,6BAAW,CAoC1B;AAED;;;;GAIG;AACH,6BAJW,UAAU,+DAER,GAAG,CAmBf;AAzID,mCAAiC;AADjC,kCAA+B"}
+{"version":3,"file":"decode.d.ts","sourceRoot":"","sources":["../../lib/decode.js"],"names":[],"mappings":"oBAKa,OAAO,YAAY,EAAE,KAAK;4BAC1B,OAAO,cAAc,EAAE,aAAa;8BACpC,OAAO,cAAc,EAAE,eAAe;AAUnD;;GAEG;AACH;IACE;;;OAGG;IACH,kBAHW,UAAU,YACV,aAAa,EAMvB;IAHC,aAAa;IACb,iBAAgB;IAChB,8CAAsB;IAGxB,cAEC;IAED,gBAEC;IAED,mCAgBC;CACF;AA6ED;;;;GAIG;AACH,0CAJW,eAAe,WACf,aAAa,GACX,GAAG,6BAAW,CAoC1B;AAuBD;;;;GAIG;AACH,6BAJW,UAAU,+DAER,GAAG,CAQf;AAhCD;;;;GAIG;AACH,kCAJW,UAAU,+DAER,CAAC,GAAG,EAAE,UAAU,CAAC,CAgB7B;AAtID,mCAAiC;AADjC,kCAA+B"}

package/types/lib/json/decode.d.ts

@@ -6,6 +6,12 @@ export type DecodeTokenizer = import('../../interface').DecodeTokenizer;
  * @returns {any}
  */
 export function decode(data: Uint8Array, options?: import("../../interface").DecodeOptions | undefined): any;
+/**
+ * @param {Uint8Array} data
+ * @param {DecodeOptions} [options]
+ * @returns {[any, Uint8Array]}
+ */
+export function decodeFirst(data: Uint8Array, options?: import("../../interface").DecodeOptions | undefined): [any, Uint8Array];
 /**
  * @typedef {import('../../interface').DecodeOptions} DecodeOptions
  * @typedef {import('../../interface').DecodeTokenizer} DecodeTokenizer
@@ -19,12 +25,13 @@ export class Tokenizer implements DecodeTokenizer {
      * @param {DecodeOptions} options
      */
     constructor(data: Uint8Array, options?: DecodeOptions);
-    pos: number;
+    _pos: number;
     data: Uint8Array;
     options: import("../../interface").DecodeOptions;
     /** @type {string[]} */
     modeStack: string[];
     lastToken: string;
+    pos(): number;
     /**
      * @returns {boolean}
      */

package/types/lib/json/decode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decode.d.ts","sourceRoot":"","sources":["../../../lib/json/decode.js"],"names":[],"mappings":"4BAMa,OAAO,iBAAiB,EAAE,aAAa;8BACvC,OAAO,iBAAiB,EAAE,eAAe;AA4atD;;;;GAIG;AACH,6BAJW,UAAU,kEAER,GAAG,CAKf;AAtbD;;;GAGG;AAEH;;GAEG;AACH;IACE;;;OAGG;IACH,kBAHW,UAAU,YACV,aAAa,EASvB;IANC,YAAY;IACZ,iBAAgB;IAChB,iDAAsB;IACtB,uBAAuB;IACvB,WADW,MAAM,EAAE,CACO;IAC1B,kBAAmB;IAGrB;;OAEG;IACH,QAFa,OAAO,CAInB;IAED;;OAEG;IACH,MAFa,MAAM,CAIlB;IAED;;OAEG;IACH,eAFa,MAAM,CAIlB;IAED,uBAMC;IAED;;OAEG;IACH,YAFW,MAAM,EAAE,QAWlB;IAED,qBA+DC;IAED;;OAEG;IACH,eAFa,KAAK,CAkLjB;IAED;;OAEG;IACH,cAFa,KAAK,CAuCjB;IAED;;OAEG;IACH,QAFa,KAAK,CAyEjB;CACF;sBAhb2B,aAAa"}
+{"version":3,"file":"decode.d.ts","sourceRoot":"","sources":["../../../lib/json/decode.js"],"names":[],"mappings":"4BAMa,OAAO,iBAAiB,EAAE,aAAa;8BACvC,OAAO,iBAAiB,EAAE,eAAe;AAgbtD;;;;GAIG;AACH,6BAJW,UAAU,kEAER,GAAG,CAKf;AAED;;;;GAIG;AACH,kCAJW,UAAU,kEAER,CAAC,GAAG,EAAE,UAAU,CAAC,CAK7B;AApcD;;;GAGG;AAEH;;GAEG;AACH;IACE;;;OAGG;IACH,kBAHW,UAAU,YACV,aAAa,EASvB;IANC,aAAa;IACb,iBAAgB;IAChB,iDAAsB;IACtB,uBAAuB;IACvB,WADW,MAAM,EAAE,CACO;IAC1B,kBAAmB;IAGrB,cAEC;IAED;;OAEG;IACH,QAFa,OAAO,CAInB;IAED;;OAEG;IACH,MAFa,MAAM,CAIlB;IAED;;OAEG;IACH,eAFa,MAAM,CAIlB;IAED,uBAMC;IAED;;OAEG;IACH,YAFW,MAAM,EAAE,QAWlB;IAED,qBA+DC;IAED;;OAEG;IACH,eAFa,KAAK,CAkLjB;IAED;;OAEG;IACH,cAFa,KAAK,CAuCjB;IAED;;OAEG;IACH,QAFa,KAAK,CAyEjB;CACF;sBApb2B,aAAa"}

package/types/lib/json/json.d.ts

@@ -1,5 +1,6 @@
 import { encode } from './encode.js';
 import { decode } from './decode.js';
+import { decodeFirst } from './decode.js';
 import { Tokenizer } from './decode.js';
-export { encode, decode, Tokenizer };
+export { encode, decode, decodeFirst, Tokenizer };
 //# sourceMappingURL=json.d.ts.map

package/types/lib/json/json.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../../lib/json/json.js"],"names":[],"mappings":"uBAAuB,aAAa;uBACF,aAAa;0BAAb,aAAa"}
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../../lib/json/json.js"],"names":[],"mappings":"uBAAuB,aAAa;uBACW,aAAa;4BAAb,aAAa;0BAAb,aAAa"}