cborg 4.3.2 → 4.4.0

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

@@ -12,7 +12,7 @@ jobs:
       - name: Checkout Repository
         uses: actions/checkout@v6
       - name: Use Node.js ${{ matrix.node }}
-        uses: actions/setup-node@v6.1.0
+        uses: actions/setup-node@v6.2.0
         with:
           node-version: ${{ matrix.node }}
       - name: Install Dependencies
@@ -29,13 +29,18 @@ jobs:
     needs: test
     runs-on: ubuntu-latest
     if: github.event_name == 'push' && github.ref == 'refs/heads/master'
+    permissions:
+      contents: write
+      issues: write
+      pull-requests: write
+      id-token: write
     steps:
       - name: Checkout
         uses: actions/checkout@v6
         with:
           fetch-depth: 0
       - name: Setup Node.js
-        uses: actions/setup-node@v6.1.0
+        uses: actions/setup-node@v6.2.0
         with:
           node-version: lts/*
       - name: Install dependencies
@@ -47,6 +52,5 @@ jobs:
       - name: Release
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
         run: npx semantic-release
 

package/CHANGELOG.md

@@ -1,3 +1,21 @@
+## [4.4.0](https://github.com/rvagg/cborg/compare/v4.3.2...v4.4.0) (2026-01-19)
+
+### Features
+
+* **encode:** Allow ignoring `undefined` plain object properties ([a0db184](https://github.com/rvagg/cborg/commit/a0db18472e0a459b23affa60c20224f571968aa8)), closes [#155](https://github.com/rvagg/cborg/issues/155)
+* **token:** add Type.equals() for bundler-safe type comparison ([#159](https://github.com/rvagg/cborg/issues/159)) ([b3e7cf4](https://github.com/rvagg/cborg/commit/b3e7cf48122e512050ff04bd826cca59ba1fd2d2)), closes [#136](https://github.com/rvagg/cborg/issues/136)
+
+### Bug Fixes
+
+* **encode:** replace unpaired surrogates with U+FFFD in utf8ToBytes ([#157](https://github.com/rvagg/cborg/issues/157)) ([362856c](https://github.com/rvagg/cborg/commit/362856c6bf0cc85b946af9ef87f47831fe3d98f5))
+
+### Trivial Changes
+
+* **ci:** OIDC publishing ([743ecc3](https://github.com/rvagg/cborg/commit/743ecc3eed0a6dce904636a3ce0a46747418b06b))
+* **deps-dev:** bump @types/node from 24.10.3 to 25.0.0 ([#153](https://github.com/rvagg/cborg/issues/153)) ([20f9e4f](https://github.com/rvagg/cborg/commit/20f9e4f59d18382492b2f7546df2e1e17eaa3cd2))
+* **deps:** bump actions/setup-node from 6.1.0 to 6.2.0 ([#158](https://github.com/rvagg/cborg/issues/158)) ([feafeb2](https://github.com/rvagg/cborg/commit/feafeb2e74b266424cf97072a9dbfb73ea6ac3ee))
+* minor optimisation & test additions for ignoreUndefinedProperties ([55f653c](https://github.com/rvagg/cborg/commit/55f653c74eff0e7f4b766f3b6e81c90ba7e06a39))
+
 ## [4.3.2](https://github.com/rvagg/cborg/compare/v4.3.1...v4.3.2) (2025-12-04)
 
 ### Trivial Changes

package/README.md

@@ -219,6 +219,7 @@ Encode a JavaScript object and return a `Uint8Array` with the CBOR byte represen
 * `float64` (boolean, default `false`): do not attempt to store floats as their smallest possible form, store all floats as 64-bit
 * `typeEncoders` (object): a mapping of type name to function that can encode that type into cborg tokens. This may also be used to reject or transform types as objects are dissected for encoding. See the [Type encoders](#type-encoders) section below for more information.
 * `mapSorter` (function): a function taking two arguments, where each argument is a `Token`, or an array of `Token`s representing the keys of a map being encoded. Similar to other JavaScript compare functions, a `-1`, `1` or `0` (which shouldn't be possible) should be returned depending on the sorting order of the keys. See the source code for the default sorting order which uses the length-first rule recommendation from [RFC 7049](https://tools.ietf.org/html/rfc7049).
+* `ignoreUndefinedProperties` (boolean, default `false`): when encoding a plain object, properties with `undefined` values will be omitted. Does not apply to `Map`s or arrays.
 
 ### `decode(data[, options])`
 
@@ -410,7 +411,7 @@ import { decode, Tokenizer, Type } from 'cborg'
 class CustomTokeniser extends Tokenizer {
   next () {
     const nextToken = super.next()
-    if (nextToken.type === Type.bytes) {
+    if (Type.equals(nextToken.type, Type.bytes)) {
       throw new Error('Unsupported type: bytes')
     }
     return nextToken

package/example-bytestrings.js

@@ -92,7 +92,7 @@ tags[tagUint64Array] = uint64ArrayDecoder
 class ArrayBufferTransformingTokeniser extends Tokenizer {
   next () {
     const nextToken = super.next()
-    if (nextToken.type === Type.bytes) {
+    if (Type.equals(nextToken.type, Type.bytes)) {
       // Transform the (assumed) Uint8Array value to an ArrayBuffer of the same bytes, note though
       // that all tags we care about are going to be <tag><bytes>, so we're also transforming those
       // into ArrayBuffers, so our tag decoders need to also assume they are getting ArrayBuffers

package/interface.ts

@@ -53,4 +53,9 @@ export interface EncodeOptions {
   mapSorter?: MapSorter,
   quickEncodeToken?: QuickEncodeToken,
   typeEncoders?: { [typeName: string]: OptionalTypeEncoder }
+  /**
+   * If true, plain object properties with `undefined` values are ignored during
+   * encoding.
+   */
+  ignoreUndefinedProperties?: boolean,
 }

package/lib/2bytes.js

@@ -89,7 +89,7 @@ export function decodeBytes64 (data, pos, _minor, options) {
  */
 function tokenBytes (token) {
   if (token.encodedBytes === undefined) {
-    token.encodedBytes = token.type === Type.string ? fromString(token.value) : token.value
+    token.encodedBytes = Type.equals(token.type, Type.string) ? fromString(token.value) : token.value
   }
   // @ts-ignore c'mon
   return token.encodedBytes

package/lib/byte-utils.js

@@ -302,6 +302,9 @@ function utf8ToBytes (str) {
       out[p++] = ((c >> 6) & 63) | 128
       out[p++] = (c & 63) | 128
     } else {
+      if ((c >= 0xD800) && (c <= 0xDFFF)) {
+        c = 0xFFFD // Unpaired Surrogate
+      }
       out[p++] = (c >> 12) | 224
       out[p++] = ((c >> 6) & 63) | 128
       out[p++] = (c & 63) | 128

package/lib/decode.js

@@ -145,7 +145,7 @@ function tokensToObject (tokeniser, options) {
 
   const token = tokeniser.next()
 
-  if (token.type === Type.break) {
+  if (Type.equals(token.type, Type.break)) {
     return BREAK
   }
 
@@ -153,15 +153,15 @@ function tokensToObject (tokeniser, options) {
     return token.value
   }
 
-  if (token.type === Type.array) {
+  if (Type.equals(token.type, Type.array)) {
     return tokenToArray(token, tokeniser, options)
   }
 
-  if (token.type === Type.map) {
+  if (Type.equals(token.type, Type.map)) {
     return tokenToMap(token, tokeniser, options)
   }
 
-  if (token.type === Type.tag) {
+  if (Type.equals(token.type, Type.tag)) {
     if (options.tags && typeof options.tags[token.value] === 'function') {
       const tagged = tokensToObject(tokeniser, options)
       return options.tags[token.value](tagged)

package/lib/encode.js

@@ -252,28 +252,47 @@ const typeEncoders = {
     const isMap = typ !== 'Object'
     // it's slightly quicker to use Object.keys() than Object.entries()
     const keys = isMap ? obj.keys() : Object.keys(obj)
-    const length = isMap ? obj.size : keys.length
-    if (!length) {
+    const maxLength = isMap ? obj.size : keys.length
+
+    /** @type {undefined | [TokenOrNestedTokens, TokenOrNestedTokens][]} */
+    let entries
+
+    if (maxLength) {
+      // Pre-allocate the array with the expected size
+      entries = new Array(maxLength)
+      refStack = Ref.createCheck(refStack, obj)
+      const skipUndefined = !isMap && options.ignoreUndefinedProperties
+
+      let i = 0
+      for (const key of keys) {
+        const value = isMap ? obj.get(key) : obj[key]
+        if (skipUndefined && value === undefined) {
+          continue
+        }
+        entries[i++] = [
+          objectToTokens(key, options, refStack),
+          objectToTokens(value, options, refStack)
+        ]
+      }
+
+      // Truncate only if properties were skipped
+      if (i < maxLength) {
+        entries.length = i
+      }
+    }
+
+    if (!entries?.length) {
       if (options.addBreakTokens === true) {
         return [simpleTokens.emptyMap, new Token(Type.break)]
       }
       return simpleTokens.emptyMap
     }
-    refStack = Ref.createCheck(refStack, obj)
-    /** @type {TokenOrNestedTokens[]} */
-    const entries = []
-    let i = 0
-    for (const key of keys) {
-      entries[i++] = [
-        objectToTokens(key, options, refStack),
-        objectToTokens(isMap ? obj.get(key) : obj[key], options, refStack)
-      ]
-    }
+
     sortMapEntries(entries, options)
     if (options.addBreakTokens) {
-      return [new Token(Type.map, length), entries, new Token(Type.break)]
+      return [new Token(Type.map, entries.length), entries, new Token(Type.break)]
     }
-    return [new Token(Type.map, length), entries]
+    return [new Token(Type.map, entries.length), entries]
   }
 }
 

package/lib/json/encode.js

@@ -22,13 +22,13 @@ class JSONEncoder extends Array {
   prefix (buf) {
     const recurs = this.inRecursive[this.inRecursive.length - 1]
     if (recurs) {
-      if (recurs.type === Type.array) {
+      if (Type.equals(recurs.type, Type.array)) {
         recurs.elements++
         if (recurs.elements !== 1) { // >first
           buf.push([44]) // ','
         }
       }
-      if (recurs.type === Type.map) {
+      if (Type.equals(recurs.type, Type.map)) {
         recurs.elements++
         if (recurs.elements !== 1) { // >first
           if (recurs.elements % 2 === 1) { // key
@@ -119,9 +119,9 @@ class JSONEncoder extends Array {
     if (token.type.name === 'break') {
       const recurs = this.inRecursive.pop()
       if (recurs) {
-        if (recurs.type === Type.array) {
+        if (Type.equals(recurs.type, Type.array)) {
           buf.push([93]) // ']'
-        } else if (recurs.type === Type.map) {
+        } else if (Type.equals(recurs.type, Type.map)) {
           buf.push([125]) // '}'
         /* c8 ignore next 3 */
         } else {

package/lib/token.js

@@ -24,6 +24,18 @@ class Type {
     /* c8 ignore next 1 */
     return this.major < typ.major ? -1 : this.major > typ.major ? 1 : 0
   }
+
+  /**
+   * Check equality between two Type instances. Safe to use across different
+   * copies of the Type class (e.g., when bundlers duplicate the module).
+   * (major, name) uniquely identifies a Type; terminal is implied by these.
+   * @param {Type} a
+   * @param {Type} b
+   * @returns {boolean}
+   */
+  static equals (a, b) {
+    return a === b || (a.major === b.major && a.name === b.name)
+  }
 }
 
 // convert to static fields when better supported

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cborg",
-  "version": "4.3.2",
+  "version": "4.4.0",
   "description": "Fast CBOR with a focus on strictness",
   "main": "cborg.js",
   "type": "module",
@@ -36,7 +36,7 @@
     "@semantic-release/release-notes-generator": "^14.0.1",
     "@types/chai": "^5.0.0",
     "@types/mocha": "^10.0.8",
-    "@types/node": "^24.0.0",
+    "@types/node": "^25.0.0",
     "c8": "^10.1.2",
     "chai": "^6.0.1",
     "conventional-changelog-conventionalcommits": "^9.0.0",

package/test/test-3string.js

@@ -109,6 +109,10 @@ describe('string', () => {
           () => decode(fromHex('7ba5f702b3a5f702b34c6f72656d20697073756d20646f6c6f722073697420616d65742c20636f6e73656374657475722061646970697363696e6720656c69742e20446f6e6563206d692074656c6c75732c20696163756c6973206e656320766573746962756c756d20717569732c206665726d656e74756d206e6f6e2066656c69732e204d616563656e6173207574206a7573746f20706f73756572652e')),
           /CBOR decode error: 64-bit integer string lengths not supported/)
       })
+
+      it('decodes unpaired surrogates as U+FFFD', () => {
+        assert.strictEqual(decode(fromHex('63edb88e')), '\uFFFD\uFFFD\uFFFD')
+      })
     }
   })
 
@@ -131,6 +135,20 @@ describe('string', () => {
           assert.strictEqual(toHex(encode(data)), expectedHex, `encode ${fixture.type}`)
         }
       })
+
+      it('should encode unpaired surrogates as U+FFFD', () => {
+        // short strings
+        assert.strictEqual(
+          toHex(encode('😎'.slice(1))),
+          toHex(encode('\uFFFD'))
+        )
+
+        // long strings (>64)
+        assert.strictEqual(
+          toHex(encode('A'.repeat(65) + '😎'.slice(1))),
+          toHex(encode('A'.repeat(65) + '\uFFFD'))
+        )
+      })
     }
   })
 })

package/test/test-encode-undefined.js

@@ -0,0 +1,112 @@
+/* eslint-env mocha */
+
+import * as chai from 'chai'
+
+import { encode, decode } from '../cborg.js'
+
+const { assert } = chai
+
+describe('ignoreUndefinedProperties option', () => {
+  it('should include undefined properties when option is not set', () => {
+    const obj = {
+      a: 1,
+      b: undefined,
+      c: 3,
+      d: undefined
+    }
+
+    const encoded = encode(obj)
+    const decoded = decode(encoded)
+
+    assert.deepStrictEqual(decoded, { a: 1, b: undefined, c: 3, d: undefined })
+  })
+
+  it('should ignore undefined plain object properties when option is set', () => {
+    const obj = {
+      a: 1,
+      b: undefined,
+      c: 3,
+      d: undefined
+    }
+
+    const encoded = encode(obj, { ignoreUndefinedProperties: true })
+    const decoded = decode(encoded)
+
+    assert.deepStrictEqual(decoded, { a: 1, c: 3 })
+  })
+
+  it('should include undefined Map values when option is set', () => {
+    const obj = new Map()
+    obj.set('a', 1)
+    obj.set('b', undefined)
+    obj.set('c', 3)
+    obj.set('d', undefined)
+
+    const encoded = encode(obj, { ignoreUndefinedProperties: true })
+    const decoded = decode(encoded)
+
+    assert.deepStrictEqual(decoded, { a: 1, b: undefined, c: 3, d: undefined })
+  })
+
+  it('should return empty object when all properties are undefined', () => {
+    const obj = {
+      a: undefined,
+      b: undefined,
+      c: undefined
+    }
+
+    const encoded = encode(obj, { ignoreUndefinedProperties: true })
+    const decoded = decode(encoded)
+
+    assert.deepStrictEqual(decoded, {})
+  })
+
+  it('should handle nested objects with undefined properties', () => {
+    const obj = {
+      a: 1,
+      b: undefined,
+      c: {
+        d: 2,
+        e: undefined,
+        f: {
+          g: 3,
+          h: undefined
+        }
+      }
+    }
+
+    const encoded = encode(obj, { ignoreUndefinedProperties: true })
+    const decoded = decode(encoded)
+
+    assert.deepStrictEqual(decoded, {
+      a: 1,
+      c: {
+        d: 2,
+        f: {
+          g: 3
+        }
+      }
+    })
+  })
+
+  it('should handle empty object', () => {
+    const obj = {}
+
+    const encoded = encode(obj, { ignoreUndefinedProperties: true })
+    const decoded = decode(encoded)
+
+    assert.deepStrictEqual(decoded, {})
+  })
+
+  it('should not affect undefined values in arrays', () => {
+    const obj = {
+      a: [1, undefined, 3],
+      b: undefined
+    }
+
+    const encoded = encode(obj, { ignoreUndefinedProperties: true })
+    const decoded = decode(encoded)
+
+    assert.deepStrictEqual(decoded, { a: [1, undefined, 3] })
+  })
+})

package/test/test-type-equals.js

@@ -0,0 +1,87 @@
+/* eslint-env mocha */
+
+import * as chai from 'chai'
+
+import { Type } from '../lib/token.js'
+import { Tokeniser } from '../lib/decode.js'
+import { encode } from '../cborg.js'
+
+const { assert } = chai
+
+describe('Type.equals', () => {
+  describe('same instance', () => {
+    it('should return true for identical references', () => {
+      assert.strictEqual(Type.equals(Type.map, Type.map), true)
+      assert.strictEqual(Type.equals(Type.array, Type.array), true)
+      assert.strictEqual(Type.equals(Type.uint, Type.uint), true)
+    })
+  })
+
+  describe('duplicate instances (bundler simulation)', () => {
+    // Simulate what happens when a bundler creates duplicate Type instances
+    // These have the same properties but are different objects
+    const duplicateTypes = {
+      uint: { major: 0, name: 'uint', terminal: true },
+      negint: { major: 1, name: 'negint', terminal: true },
+      bytes: { major: 2, name: 'bytes', terminal: true },
+      string: { major: 3, name: 'string', terminal: true },
+      array: { major: 4, name: 'array', terminal: false },
+      map: { major: 5, name: 'map', terminal: false },
+      tag: { major: 6, name: 'tag', terminal: false },
+      float: { major: 7, name: 'float', terminal: true },
+      false: { major: 7, name: 'false', terminal: true },
+      true: { major: 7, name: 'true', terminal: true },
+      null: { major: 7, name: 'null', terminal: true },
+      undefined: { major: 7, name: 'undefined', terminal: true },
+      break: { major: 7, name: 'break', terminal: true }
+    }
+
+    it('should return true for duplicate instances with same major/name', () => {
+      assert.strictEqual(Type.equals(duplicateTypes.map, Type.map), true)
+      assert.strictEqual(Type.equals(Type.map, duplicateTypes.map), true)
+      assert.strictEqual(Type.equals(duplicateTypes.array, Type.array), true)
+      assert.strictEqual(Type.equals(duplicateTypes.uint, Type.uint), true)
+      assert.strictEqual(Type.equals(duplicateTypes.string, Type.string), true)
+    })
+
+    it('should correctly distinguish major-7 types', () => {
+      // All these share major 7, must be distinguished by name
+      assert.strictEqual(Type.equals(duplicateTypes.float, Type.float), true)
+      assert.strictEqual(Type.equals(duplicateTypes.false, Type.false), true)
+      assert.strictEqual(Type.equals(duplicateTypes.true, Type.true), true)
+      assert.strictEqual(Type.equals(duplicateTypes.null, Type.null), true)
+      assert.strictEqual(Type.equals(duplicateTypes.undefined, Type.undefined), true)
+      assert.strictEqual(Type.equals(duplicateTypes.break, Type.break), true)
+
+      // Cross-checks: same major, different name
+      assert.strictEqual(Type.equals(duplicateTypes.float, Type.null), false)
+      assert.strictEqual(Type.equals(duplicateTypes.true, Type.false), false)
+      assert.strictEqual(Type.equals(duplicateTypes.break, Type.undefined), false)
+    })
+
+    it('should return false for different types', () => {
+      assert.strictEqual(Type.equals(duplicateTypes.map, Type.array), false)
+      assert.strictEqual(Type.equals(duplicateTypes.uint, Type.negint), false)
+      assert.strictEqual(Type.equals(duplicateTypes.string, Type.bytes), false)
+    })
+  })
+
+  describe('decode with simulated duplicate types', () => {
+    it('should handle tokens with duplicate Type instances', () => {
+      // Create a token with a "duplicate" Type (simulating bundler scenario)
+      const duplicateMapType = { major: 5, name: 'map', terminal: false }
+
+      // Encode a simple object
+      const encoded = encode({ foo: 'bar' })
+
+      // Decode using standard tokeniser
+      const tokeniser = new Tokeniser(encoded, {})
+      const firstToken = tokeniser.next()
+
+      // The token should have our real Type.map
+      assert.strictEqual(Type.equals(firstToken.type, Type.map), true)
+      // And should also match a "duplicate" type
+      assert.strictEqual(Type.equals(firstToken.type, duplicateMapType), true)
+    })
+  })
+})

package/types/interface.d.ts

@@ -43,5 +43,10 @@ export interface EncodeOptions {
     typeEncoders?: {
         [typeName: string]: OptionalTypeEncoder;
     };
+    /**
+     * If true, plain object properties with `undefined` values are ignored during
+     * encoding.
+     */
+    ignoreUndefinedProperties?: boolean;
 }
 //# sourceMappingURL=interface.d.ts.map

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,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"}
+{"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;IAC1D;;;OAGG;IACH,yBAAyB,CAAC,EAAE,OAAO,CAAC;CACrC"}

package/types/lib/byte-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"byte-utils.d.ts","sourceRoot":"","sources":["../../lib/byte-utils.js"],"names":[],"mappings":"AAwBA;;;GAGG;AACH,2BAHW,UAAU,GAAC,MAAM,EAAE,GACjB,UAAU,CAQtB;AA8ND;;;;GAIG;AACH,4BAJW,UAAU,MACV,UAAU,GACR,MAAM,CAgBlB;AAyHD;;;GAGG;AACH,kDAHW,MAAM,EAAE,GACN,MAAM,CAkBlB;AA5ZD,gCAMkD;AA4B9C;;;;GAIG;AACH,gCAJW,UAAU,SACV,MAAM,OACN,MAAM,UAQhB;AAcL,mCAGe,MAAM,iDAYN,MAAM,yCAIhB;AAOE,+BAHI,MAAM,EAAE,GACN,UAAU,CAItB;AAIG;;;;GAIG;AACH,6BAJW,UAAU,SACV,MAAM,OACN,MAAM,2BAOhB;AAcD;;;;GAIG;AACH,+BAJW,UAAU,EAAE,UACZ,MAAM,GACJ,UAAU,CActB;AAwBD;;;GAGG;AACH,4BAHW,MAAM,GACJ,UAAU,CAMtB;AAaD;;;GAGG;AACH,yBAHW,UAAU,GACR,MAAM,CAQlB;AAiBH;;;GAGG;AACD,6BAHS,MAAM,GAAC,UAAU,GACf,UAAU,CAQpB"}
+{"version":3,"file":"byte-utils.d.ts","sourceRoot":"","sources":["../../lib/byte-utils.js"],"names":[],"mappings":"AAwBA;;;GAGG;AACH,2BAHW,UAAU,GAAC,MAAM,EAAE,GACjB,UAAU,CAQtB;AA8ND;;;;GAIG;AACH,4BAJW,UAAU,MACV,UAAU,GACR,MAAM,CAgBlB;AA4HD;;;GAGG;AACH,kDAHW,MAAM,EAAE,GACN,MAAM,CAkBlB;AA/ZD,gCAMkD;AA4B9C;;;;GAIG;AACH,gCAJW,UAAU,SACV,MAAM,OACN,MAAM,UAQhB;AAcL,mCAGe,MAAM,iDAYN,MAAM,yCAIhB;AAOE,+BAHI,MAAM,EAAE,GACN,UAAU,CAItB;AAIG;;;;GAIG;AACH,6BAJW,UAAU,SACV,MAAM,OACN,MAAM,2BAOhB;AAcD;;;;GAIG;AACH,+BAJW,UAAU,EAAE,UACZ,MAAM,GACJ,UAAU,CActB;AAwBD;;;GAGG;AACH,4BAHW,MAAM,GACJ,UAAU,CAMtB;AAaD;;;GAGG;AACH,yBAHW,UAAU,GACR,MAAM,CAQlB;AAiBH;;;GAGG;AACD,6BAHS,MAAM,GAAC,UAAU,GACf,UAAU,CAQpB"}

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

@@ -1 +1 @@
-{"version":3,"file":"encode.d.ts","sourceRoot":"","sources":["../../lib/encode.js"],"names":[],"mappings":"AAuCA,oCAAoC;AACpC,oCADc,gBAAgB,EAAE,CAY/B;AAnBD,4BAA4B;AAC5B,mCADW,aAAa,CAKtB;sBA4WW,KAAK,GAAG;IAAE,SAAS,CAAC,EAAE,UAAU,CAAA;CAAE;4BAhYlC,OAAO,cAAc,EAAE,aAAa;kCACpC,OAAO,cAAc,EAAE,mBAAmB;wBAC1C,OAAO,cAAc,EAAE,SAAS;gCAChC,OAAO,cAAc,EAAE,iBAAiB;+BACxC,OAAO,cAAc,EAAE,gBAAgB;kCACvC,OAAO,cAAc,EAAE,mBAAmB;AAuQvD;;;;;GAKG;AACH,oCALW,GAAG,YACH,aAAa,aACb,SAAS,GACP,mBAAmB,CAgB/B;AAgLD;;;;GAIG;AACH,6BAJW,GAAG,YACH,aAAa,GACX,UAAU,CAKtB;AAvCD;;;;;GAKG;AACH,mCALW,GAAG,YACH,gBAAgB,EAAE,WAClB,aAAa,GACX,UAAU,CAyBtB;AAtaD,8BAA8B;AAC9B,4BADiB,SAAS;IA0BxB;;;;OAIG;IACH,0BAJW,SAAS,GAAC,SAAS,OACnB,MAAM,GAAC,GAAG,EAAE,GACV,SAAS,CAOrB;IAlCD;;;OAGG;IACH,iBAHW,MAAM,GAAC,GAAG,EAAE,UACZ,SAAS,GAAC,SAAS,EAK7B;IAFC,oBAAc;IACd,qDAAoB;IAGtB;;;OAGG;IACH,cAHW,MAAM,GAAC,GAAG,EAAE,GACV,OAAO,CAWnB;CAaF;sBA7F2B,YAAY"}
+{"version":3,"file":"encode.d.ts","sourceRoot":"","sources":["../../lib/encode.js"],"names":[],"mappings":"AAuCA,oCAAoC;AACpC,oCADc,gBAAgB,EAAE,CAY/B;AAnBD,4BAA4B;AAC5B,mCADW,aAAa,CAKtB;sBA+XW,KAAK,GAAG;IAAE,SAAS,CAAC,EAAE,UAAU,CAAA;CAAE;4BAnZlC,OAAO,cAAc,EAAE,aAAa;kCACpC,OAAO,cAAc,EAAE,mBAAmB;wBAC1C,OAAO,cAAc,EAAE,SAAS;gCAChC,OAAO,cAAc,EAAE,iBAAiB;+BACxC,OAAO,cAAc,EAAE,gBAAgB;kCACvC,OAAO,cAAc,EAAE,mBAAmB;AA0RvD;;;;;GAKG;AACH,oCALW,GAAG,YACH,aAAa,aACb,SAAS,GACP,mBAAmB,CAgB/B;AAgLD;;;;GAIG;AACH,6BAJW,GAAG,YACH,aAAa,GACX,UAAU,CAKtB;AAvCD;;;;;GAKG;AACH,mCALW,GAAG,YACH,gBAAgB,EAAE,WAClB,aAAa,GACX,UAAU,CAyBtB;AAzbD,8BAA8B;AAC9B,4BADiB,SAAS;IA0BxB;;;;OAIG;IACH,0BAJW,SAAS,GAAC,SAAS,OACnB,MAAM,GAAC,GAAG,EAAE,GACV,SAAS,CAOrB;IAlCD;;;OAGG;IACH,iBAHW,MAAM,GAAC,GAAG,EAAE,UACZ,SAAS,GAAC,SAAS,EAK7B;IAFC,oBAAc;IACd,qDAAoB;IAGtB;;;OAGG;IACH,cAHW,MAAM,GAAC,GAAG,EAAE,GACV,OAAO,CAWnB;CAaF;sBA7F2B,YAAY"}

package/types/lib/token.d.ts

@@ -1,4 +1,13 @@
 export class Type {
+    /**
+     * Check equality between two Type instances. Safe to use across different
+     * copies of the Type class (e.g., when bundlers duplicate the module).
+     * (major, name) uniquely identifies a Type; terminal is implied by these.
+     * @param {Type} a
+     * @param {Type} b
+     * @returns {boolean}
+     */
+    static equals(a: Type, b: Type): boolean;
     /**
      * @param {number} major
      * @param {string} name

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

@@ -1 +1 @@
-{"version":3,"file":"token.d.ts","sourceRoot":"","sources":["../../lib/token.js"],"names":[],"mappings":"AAAA;IACE;;;;OAIG;IACH,mBAJW,MAAM,QACN,MAAM,YACN,OAAO,EAOjB;IAJC,cAAkB;IAClB,qBAA8B;IAC9B,aAAgB;IAChB,kBAAwB;IAI1B,mBAEC;IAED;;;OAGG;IACH,aAHW,IAAI,GACF,MAAM,CAKlB;CACF;;;;;;;;;;;;;;;;;;;;AAkBD;IACE;;;;OAIG;IACH,kBAJW,IAAI,UACJ,GAAG,kBACH,MAAM,EAUhB;IAPC,WAAgB;IAChB,WAAkB;IAClB,kCAAkC;IAClC,mCAAmC;IACnC,cADW,UAAU,GAAC,SAAS,CACF;IAC7B,mCAAmC;IACnC,WADW,UAAU,GAAC,SAAS,CACL;IAI5B,mBAEC;CACF"}
+{"version":3,"file":"token.d.ts","sourceRoot":"","sources":["../../lib/token.js"],"names":[],"mappings":"AAAA;IA2BE;;;;;;;OAOG;IACH,iBAJW,IAAI,KACJ,IAAI,GACF,OAAO,CAInB;IApCD;;;;OAIG;IACH,mBAJW,MAAM,QACN,MAAM,YACN,OAAO,EAOjB;IAJC,cAAkB;IAClB,qBAA8B;IAC9B,aAAgB;IAChB,kBAAwB;IAI1B,mBAEC;IAED;;;OAGG;IACH,aAHW,IAAI,GACF,MAAM,CAKlB;CAaF;;;;;;;;;;;;;;;;;;;;AAkBD;IACE;;;;OAIG;IACH,kBAJW,IAAI,UACJ,GAAG,kBACH,MAAM,EAUhB;IAPC,WAAgB;IAChB,WAAkB;IAClB,kCAAkC;IAClC,mCAAmC;IACnC,cADW,UAAU,GAAC,SAAS,CACF;IAC7B,mCAAmC;IACnC,WADW,UAAU,GAAC,SAAS,CACL;IAI5B,mBAEC;CACF"}