cborg 4.5.3 → 4.5.5

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## [4.5.5](https://github.com/rvagg/cborg/compare/v4.5.4...v4.5.5) (2026-01-20)
+
+### Trivial Changes
+
+* **bench:** output json to file ([ca32690](https://github.com/rvagg/cborg/commit/ca326908643ce9bc2ac56dd06b6c64502b8a4f03))
+
+## [4.5.4](https://github.com/rvagg/cborg/compare/v4.5.3...v4.5.4) (2026-01-20)
+
 ## [4.5.3](https://github.com/rvagg/cborg/compare/v4.5.2...v4.5.3) (2026-01-20)
 
 ## [4.5.2](https://github.com/rvagg/cborg/compare/v4.5.1...v4.5.2) (2026-01-20)

package/bench/bench.js

@@ -5,12 +5,12 @@
  * Works in both Node.js and browser environments.
  *
  * Usage:
- *   node bench/bench-new.js                    # run all benchmarks (dag-cbor mode)
- *   node bench/bench-new.js --mode=raw         # run with raw cborg (no tags)
- *   node bench/bench-new.js --suite=bsky       # run only bluesky suite
- *   node bench/bench-new.js --json             # output JSON for comparison
- *   node bench/bench-new.js --compare=baseline.json  # compare to baseline
- *   node bench/bench-new.js --encode-into      # use encodeInto instead of encode
+ *   node bench/bench.js                           # run all benchmarks (dag-cbor mode)
+ *   node bench/bench.js --mode=raw                # run with raw cborg (no tags)
+ *   node bench/bench.js --suite=bsky              # run only bluesky suite
+ *   node bench/bench.js --json=output.json        # write JSON results to file
+ *   node bench/bench.js --compare=baseline.json   # compare to baseline
+ *   node bench/bench.js --encode-into             # use encodeInto instead of encode
  */
 
 import { encode, decode, encodeInto, Token, Type } from '../cborg.js'
@@ -129,7 +129,7 @@ const FIXTURE_SEED = 12345
 // Parse CLI args (Node.js only, ignored in browser)
 const args = typeof process !== 'undefined' ? process.argv.slice(2) : []
 const opts = {
-  json: args.includes('--json'),
+  json: args.find(a => a.startsWith('--json='))?.split('=')[1] || null,
   suite: args.find(a => a.startsWith('--suite='))?.split('=')[1] || null,
   compare: args.find(a => a.startsWith('--compare='))?.split('=')[1] || null,
   duration: parseInt(args.find(a => a.startsWith('--duration='))?.split('=')[1] || DEFAULT_DURATION_MS),
@@ -184,11 +184,11 @@ function getOptions (suiteType = 'default') {
   }
 }
 
-// Output helpers
-const log = opts.json ? () => {} : console.log.bind(console)
+// Output helpers - always show progress to console
+const log = console.log.bind(console)
 const write = typeof process !== 'undefined' && process.stdout
   ? (s) => process.stdout.write(s)
-  : (s) => log(s)
+  : (s) => console.log(s)
 
 /**
  * Run a benchmark function for a duration, return ops/sec
@@ -364,7 +364,7 @@ async function main () {
   const avgDecode = Math.round(allDecodeRates.reduce((a, b) => a + b, 0) / allDecodeRates.length * 10) / 10
   log(`Average throughput: encode ${avgEncode} MB/s, decode ${avgDecode} MB/s`)
 
-  // JSON output
+  // JSON output to file
   if (opts.json) {
     const output = {
       timestamp: new Date().toISOString(),
@@ -375,7 +375,11 @@ async function main () {
       suites: allResults,
       summary: { avgEncodeMBps: avgEncode, avgDecodeMBps: avgDecode }
     }
-    console.log(JSON.stringify(output, null, 2))
+    if (typeof process !== 'undefined') {
+      const fs = await import('fs')
+      fs.writeFileSync(opts.json, JSON.stringify(output, null, 2) + '\n')
+      log(`\nResults written to ${opts.json}`)
+    }
   }
 
   // Compare to baseline

package/lib/3string.js

@@ -2,13 +2,43 @@ import { Token, Type } from './token.js'
 import { assertEnoughData, decodeErrPrefix } from './common.js'
 import * as uint from './0uint.js'
 import { encodeBytes } from './2bytes.js'
-import { toString, slice } from './byte-utils.js'
+import { slice } from './byte-utils.js'
+
+const textDecoder = new TextDecoder()
+
+// Threshold for ASCII fast-path vs TextDecoder. Short ASCII strings (common for
+// map keys) are faster to decode with a simple loop than TextDecoder overhead.
+const ASCII_THRESHOLD = 32
 
 /**
  * @typedef {import('../interface').ByteWriter} ByteWriter
  * @typedef {import('../interface').DecodeOptions} DecodeOptions
  */
 
+/**
+ * Decode UTF-8 bytes to string. For short ASCII strings (common case for map keys),
+ * a simple loop is faster than TextDecoder.
+ * @param {Uint8Array} bytes
+ * @param {number} start
+ * @param {number} end
+ * @returns {string}
+ */
+function toStr (bytes, start, end) {
+  const len = end - start
+  if (len < ASCII_THRESHOLD) {
+    let str = ''
+    for (let i = start; i < end; i++) {
+      const c = bytes[i]
+      if (c & 0x80) { // non-ASCII, fall back to TextDecoder
+        return textDecoder.decode(bytes.subarray(start, end))
+      }
+      str += String.fromCharCode(c)
+    }
+    return str
+  }
+  return textDecoder.decode(bytes.subarray(start, end))
+}
+
 /**
  * @param {Uint8Array} data
  * @param {number} pos
@@ -20,7 +50,7 @@ import { toString, slice } from './byte-utils.js'
 function toToken (data, pos, prefix, length, options) {
   const totLength = prefix + length
   assertEnoughData(data, pos, totLength)
-  const tok = new Token(Type.string, toString(data, pos + prefix, pos + totLength), totLength)
+  const tok = new Token(Type.string, toStr(data, pos + prefix, pos + totLength), totLength)
   if (options.retainStringBytes === true) {
     tok.byteValue = slice(data, pos + prefix, pos + totLength)
   }

package/lib/7float.js

@@ -11,10 +11,10 @@ import { encodeUint } from './0uint.js'
  * @typedef {import('../interface').EncodeOptions} EncodeOptions
  */
 
-const MINOR_FALSE = 20
-const MINOR_TRUE = 21
-const MINOR_NULL = 22
-const MINOR_UNDEFINED = 23
+export const MINOR_FALSE = 20
+export const MINOR_TRUE = 21
+export const MINOR_NULL = 22
+export const MINOR_UNDEFINED = 23
 
 /**
  * @param {Uint8Array} _data

package/lib/byte-utils.js

@@ -10,7 +10,6 @@ export const useBuffer = globalThis.process &&
   // @ts-ignore
   typeof globalThis.Buffer.isBuffer === 'function'
 
-const textDecoder = new TextDecoder()
 const textEncoder = new TextEncoder()
 
 /**
@@ -34,37 +33,6 @@ export function asU8A (buf) {
   return isBuffer(buf) ? new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength) : buf
 }
 
-// Threshold for switching between manual utf8Slice and native TextDecoder/Buffer
-// Manual decoding has overhead from array building; native is fast for strings > 32 bytes
-const UTF8_THRESHOLD = 32
-
-export const toString = useBuffer
-  ? // eslint-disable-line operator-linebreak
-    /**
-     * @param {Uint8Array} bytes
-     * @param {number} start
-     * @param {number} end
-     */
-    (bytes, start, end) => {
-      return end - start > UTF8_THRESHOLD
-        ? // eslint-disable-line operator-linebreak
-      // @ts-ignore
-        globalThis.Buffer.from(bytes.subarray(start, end)).toString('utf8')
-        : utf8Slice(bytes, start, end)
-    }
-  /* c8 ignore next 11 */
-  : // eslint-disable-line operator-linebreak
-    /**
-     * @param {Uint8Array} bytes
-     * @param {number} start
-     * @param {number} end
-     */
-    (bytes, start, end) => {
-      return end - start > UTF8_THRESHOLD
-        ? textDecoder.decode(bytes.subarray(start, end))
-        : utf8Slice(bytes, start, end)
-    }
-
 export const fromString = useBuffer
   ? // eslint-disable-line operator-linebreak
     /**
@@ -102,6 +70,7 @@ export const slice = useBuffer
      * @param {number} start
      * @param {number} end
      */
+    // Buffer.slice() returns a view, not a copy, so we need special handling
     (bytes, start, end) => {
       if (isBuffer(bytes)) {
         return new Uint8Array(bytes.subarray(start, end))
@@ -317,85 +286,6 @@ function utf8ToBytes (str) {
   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
- * @param {number} end
- * @returns {string}
- */
-function utf8Slice (buf, offset, end) {
-  const res = []
-
-  while (offset < end) {
-    const firstByte = buf[offset]
-    let codePoint = null
-    let bytesPerSequence = (firstByte > 0xef) ? 4 : (firstByte > 0xdf) ? 3 : (firstByte > 0xbf) ? 2 : 1
-
-    if (offset + bytesPerSequence <= end) {
-      let secondByte, thirdByte, fourthByte, tempCodePoint
-
-      switch (bytesPerSequence) {
-        case 1:
-          if (firstByte < 0x80) {
-            codePoint = firstByte
-          }
-          break
-        case 2:
-          secondByte = buf[offset + 1]
-          if ((secondByte & 0xc0) === 0x80) {
-            tempCodePoint = (firstByte & 0x1f) << 0x6 | (secondByte & 0x3f)
-            if (tempCodePoint > 0x7f) {
-              codePoint = tempCodePoint
-            }
-          }
-          break
-        case 3:
-          secondByte = buf[offset + 1]
-          thirdByte = buf[offset + 2]
-          if ((secondByte & 0xc0) === 0x80 && (thirdByte & 0xc0) === 0x80) {
-            tempCodePoint = (firstByte & 0xf) << 0xc | (secondByte & 0x3f) << 0x6 | (thirdByte & 0x3f)
-            /* c8 ignore next 3 */
-            if (tempCodePoint > 0x7ff && (tempCodePoint < 0xd800 || tempCodePoint > 0xdfff)) {
-              codePoint = tempCodePoint
-            }
-          }
-          break
-        case 4:
-          secondByte = buf[offset + 1]
-          thirdByte = buf[offset + 2]
-          fourthByte = buf[offset + 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) {
-              codePoint = tempCodePoint
-            }
-          }
-      }
-    }
-
-    /* c8 ignore next 5 */
-    if (codePoint === null) {
-      // we did not generate a valid codePoint so insert a
-      // replacement char (U+FFFD) and advance only 1 byte
-      codePoint = 0xfffd
-      bytesPerSequence = 1
-    } else if (codePoint > 0xffff) {
-      // encode to utf16 (surrogate pair dance)
-      codePoint -= 0x10000
-      res.push(codePoint >>> 10 & 0x3ff | 0xd800)
-      codePoint = 0xdc00 | codePoint & 0x3ff
-    }
-
-    res.push(codePoint)
-    offset += bytesPerSequence
-  }
-
-  return decodeCodePointsArray(res)
-}
-
 // Based on http://stackoverflow.com/a/22747272/680742, the browser with
 // the lowest limit is Chrome, with 0x10000 args.
 // We go 1 magnitude less, for safety

package/lib/encode.js

@@ -3,16 +3,16 @@ import { Token, Type } from './token.js'
 import { Bl, U8Bl } from './bl.js'
 import { encodeErrPrefix } from './common.js'
 import { quickEncodeToken } from './jump.js'
-import { asU8A, compare } from './byte-utils.js'
+import { asU8A, compare, fromString } from './byte-utils.js'
 
-import { encodeUint } from './0uint.js'
+import { encodeUint, encodeUintValue } 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 { encodeFloat, MINOR_FALSE, MINOR_TRUE, MINOR_NULL, MINOR_UNDEFINED } from './7float.js'
 
 /**
  * @typedef {import('../interface').EncodeOptions} EncodeOptions
@@ -468,6 +468,139 @@ function tokensToEncoded (writer, tokens, encoders, options) {
   }
 }
 
+// CBOR major type prefixes, cached from Type for hot path performance
+const MAJOR_UINT = Type.uint.majorEncoded
+const MAJOR_NEGINT = Type.negint.majorEncoded
+const MAJOR_BYTES = Type.bytes.majorEncoded
+const MAJOR_STRING = Type.string.majorEncoded
+const MAJOR_ARRAY = Type.array.majorEncoded
+
+// Simple value bytes (CBOR major type 7 + minor value)
+const SIMPLE_FALSE = Type.float.majorEncoded | MINOR_FALSE
+const SIMPLE_TRUE = Type.float.majorEncoded | MINOR_TRUE
+const SIMPLE_NULL = Type.float.majorEncoded | MINOR_NULL
+const SIMPLE_UNDEFINED = Type.float.majorEncoded | MINOR_UNDEFINED
+
+const neg1b = BigInt(-1)
+const pos1b = BigInt(1)
+
+/**
+ * Check if direct encoding can be used for the given options.
+ * Direct encoding bypasses token creation for most values.
+ * @param {EncodeOptions} options
+ * @returns {boolean}
+ */
+function canDirectEncode (options) {
+  // Cannot use direct encode with addBreakTokens (needs special break token handling).
+  // Direct encode checks typeEncoders per-value, falling back to tokens as needed.
+  // Maps fall back to token-based encoding for efficient key sorting.
+  return options.addBreakTokens !== true
+}
+
+/**
+ * Direct encode a value to the writer, bypassing token creation for most types.
+ * Falls back to token-based encoding for custom type encoders.
+ * @param {ByteWriter} writer
+ * @param {any} data
+ * @param {EncodeOptions} options
+ * @param {Reference|undefined} refStack
+ */
+function directEncode (writer, data, options, refStack) {
+  const typ = is(data)
+
+  // Check for custom encoder for THIS specific type
+  const customEncoder = options.typeEncoders && options.typeEncoders[typ]
+  if (customEncoder) {
+    const tokens = customEncoder(data, typ, options, refStack)
+    if (tokens != null) {
+      // Custom encoder returned tokens, serialize immediately
+      tokensToEncoded(writer, tokens, cborEncoders, options)
+      return
+    }
+    // Custom encoder returned null, fall through to default handling
+  }
+
+  // Direct encode based on type
+  switch (typ) {
+    case 'null':
+      writer.push([SIMPLE_NULL])
+      return
+
+    case 'undefined':
+      writer.push([SIMPLE_UNDEFINED])
+      return
+
+    case 'boolean':
+      writer.push([data ? SIMPLE_TRUE : SIMPLE_FALSE])
+      return
+
+    case 'number':
+      if (!Number.isInteger(data) || !Number.isSafeInteger(data)) {
+        // Float, use token encoder for complex float encoding
+        encodeFloat(writer, new Token(Type.float, data), options)
+      } else if (data >= 0) {
+        encodeUintValue(writer, MAJOR_UINT, data)
+      } else {
+        // Negative integer
+        encodeUintValue(writer, MAJOR_NEGINT, data * -1 - 1)
+      }
+      return
+
+    case 'bigint':
+      if (data >= BigInt(0)) {
+        encodeUintValue(writer, MAJOR_UINT, data)
+      } else {
+        encodeUintValue(writer, MAJOR_NEGINT, data * neg1b - pos1b)
+      }
+      return
+
+    case 'string': {
+      const bytes = fromString(data)
+      encodeUintValue(writer, MAJOR_STRING, bytes.length)
+      writer.push(bytes)
+      return
+    }
+
+    case 'Uint8Array':
+      encodeUintValue(writer, MAJOR_BYTES, data.length)
+      writer.push(data)
+      return
+
+    case 'Array':
+      if (!data.length) {
+        writer.push([MAJOR_ARRAY]) // Empty array: 0x80
+        return
+      }
+      refStack = Ref.createCheck(refStack, data)
+      encodeUintValue(writer, MAJOR_ARRAY, data.length)
+      for (const elem of data) {
+        directEncode(writer, elem, options, refStack)
+      }
+      return
+
+    case 'Object':
+    case 'Map':
+      // Maps require key sorting, use token-based encoding for efficiency
+      // (pre-encoding all keys for sorting is expensive)
+      {
+        const tokens = typeEncoders.Object(data, typ, options, refStack)
+        tokensToEncoded(writer, tokens, cborEncoders, options)
+      }
+      return
+
+    default:
+    // Fall back to token-based encoding for other types (DataView, TypedArrays, etc.)
+    {
+      const typeEncoder = typeEncoders[typ]
+      if (!typeEncoder) {
+        throw new Error(`${encodeErrPrefix} unsupported type: ${typ}`)
+      }
+      const tokens = typeEncoder(data, typ, options, refStack)
+      tokensToEncoded(writer, tokens, cborEncoders, options)
+    }
+  }
+}
+
 /**
  * @param {any} data
  * @param {TokenTypeEncoder[]} encoders
@@ -518,6 +651,14 @@ function encodeCustom (data, encoders, options, destination) {
  */
 function encode (data, options) {
   options = Object.assign({}, defaultEncodeOptions, options)
+
+  // Use direct encode path when possible
+  if (canDirectEncode(options)) {
+    defaultWriter.reset()
+    directEncode(defaultWriter, data, options, undefined)
+    return defaultWriter.toBytes(true)
+  }
+
   return encodeCustom(data, cborEncoders, options)
 }
 
@@ -529,6 +670,14 @@ function encode (data, options) {
  */
 function encodeInto (data, destination, options) {
   options = Object.assign({}, defaultEncodeOptions, options)
+
+  // Use direct encode path when possible
+  if (canDirectEncode(options)) {
+    const writer = new U8Bl(destination)
+    directEncode(writer, data, options, undefined)
+    return { written: writer.toBytes().length }
+  }
+
   const result = encodeCustom(data, cborEncoders, options, destination)
   return { written: result.length }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cborg",
-  "version": "4.5.3",
+  "version": "4.5.5",
   "description": "Fast CBOR with a focus on strictness",
   "main": "cborg.js",
   "type": "module",

package/types/lib/3string.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"3string.d.ts","sourceRoot":"","sources":["../../lib/3string.js"],"names":[],"mappings":"AA6BA;;;;;;GAMG;AACH,0CANW,UAAU,OACV,MAAM,SACN,MAAM,WACN,aAAa,GACX,KAAK,CAIjB;AAED;;;;;;GAMG;AACH,oCANW,UAAU,OACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CAIjB;AAED;;;;;;GAMG;AACH,qCANW,UAAU,OACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CAIjB;AAED;;;;;;GAMG;AACH,qCANW,UAAU,OACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CAIjB;AAGD;;;;;;GAMG;AACH,qCANW,UAAU,OACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CAQjB;AAED,8CAAuC;yBAlF1B,OAAO,cAAc,EAAE,UAAU;4BACjC,OAAO,cAAc,EAAE,aAAa;sBARrB,YAAY;4BAGZ,aAAa"}
+{"version":3,"file":"3string.d.ts","sourceRoot":"","sources":["../../lib/3string.js"],"names":[],"mappings":"AA2DA;;;;;;GAMG;AACH,0CANW,UAAU,OACV,MAAM,SACN,MAAM,WACN,aAAa,GACX,KAAK,CAIjB;AAED;;;;;;GAMG;AACH,oCANW,UAAU,OACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CAIjB;AAED;;;;;;GAMG;AACH,qCANW,UAAU,OACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CAIjB;AAED;;;;;;GAMG;AACH,qCANW,UAAU,OACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CAIjB;AAGD;;;;;;GAMG;AACH,qCANW,UAAU,OACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CAQjB;AAED,8CAAuC;yBA1G1B,OAAO,cAAc,EAAE,UAAU;4BACjC,OAAO,cAAc,EAAE,aAAa;sBAdrB,YAAY;4BAGZ,aAAa"}

package/types/lib/7float.d.ts

@@ -53,6 +53,15 @@ export namespace encodeFloat {
     function encodedSize(token: Token, options: EncodeOptions): number;
     let compareTokens: (tok1: Token, tok2: Token) => number;
 }
+/**
+ * @typedef {import('../interface').ByteWriter} ByteWriter
+ * @typedef {import('../interface').DecodeOptions} DecodeOptions
+ * @typedef {import('../interface').EncodeOptions} EncodeOptions
+ */
+export const MINOR_FALSE: 20;
+export const MINOR_TRUE: 21;
+export const MINOR_NULL: 22;
+export const MINOR_UNDEFINED: 23;
 export type ByteWriter = import("../interface").ByteWriter;
 export type DecodeOptions = import("../interface").DecodeOptions;
 export type EncodeOptions = import("../interface").EncodeOptions;

package/types/lib/7float.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"7float.d.ts","sourceRoot":"","sources":["../../lib/7float.js"],"names":[],"mappings":"AAkBA;;;;;;GAMG;AACH,uCANW,UAAU,QACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CASjB;AAED;;;;;;GAMG;AACH,mCANW,UAAU,QACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CAOjB;AAoBD;;;;;;GAMG;AACH,oCANW,UAAU,OACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CAIjB;AAED;;;;;;GAMG;AACH,oCANW,UAAU,OACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CAIjB;AAED;;;;;;GAMG;AACH,oCANW,UAAU,OACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CAIjB;AAED;;;;GAIG;AACH,oCAJW,UAAU,SACV,KAAK,WACL,aAAa,QAwCvB;;IAED;;;;OAIG;IACH,4BAJW,KAAK,WACL,aAAa,GACX,MAAM,CAsBlB;;;yBAjKY,OAAO,cAAc,EAAE,UAAU;4BACjC,OAAO,cAAc,EAAE,aAAa;4BACpC,OAAO,cAAc,EAAE,aAAa;sBAPrB,YAAY"}
+{"version":3,"file":"7float.d.ts","sourceRoot":"","sources":["../../lib/7float.js"],"names":[],"mappings":"AAkBA;;;;;;GAMG;AACH,uCANW,UAAU,QACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CASjB;AAED;;;;;;GAMG;AACH,mCANW,UAAU,QACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CAOjB;AAoBD;;;;;;GAMG;AACH,oCANW,UAAU,OACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CAIjB;AAED;;;;;;GAMG;AACH,oCANW,UAAU,OACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CAIjB;AAED;;;;;;GAMG;AACH,oCANW,UAAU,OACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CAIjB;AAED;;;;GAIG;AACH,oCAJW,UAAU,SACV,KAAK,WACL,aAAa,QAwCvB;;IAED;;;;OAIG;IACH,4BAJW,KAAK,WACL,aAAa,GACX,MAAM,CAsBlB;;;AAlKD;;;;GAIG;AAEH,0BAA2B,EAAE,CAAA;AAC7B,yBAA0B,EAAE,CAAA;AAC5B,yBAA0B,EAAE,CAAA;AAC5B,8BAA+B,EAAE,CAAA;yBARpB,OAAO,cAAc,EAAE,UAAU;4BACjC,OAAO,cAAc,EAAE,aAAa;4BACpC,OAAO,cAAc,EAAE,aAAa;sBAPrB,YAAY"}

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

@@ -15,12 +15,6 @@ export function compare(b1: Uint8Array, b2: Uint8Array): number;
  */
 export function decodeCodePointsArray(codePoints: number[]): string;
 export const useBuffer: boolean;
-/**
- * @param {Uint8Array} bytes
- * @param {number} start
- * @param {number} end
- */
-export function toString(bytes: Uint8Array, start: number, end: number): string;
 export const fromString: ((string: string) => number[] | Buffer<ArrayBuffer>) | ((string: string) => number[] | Uint8Array<ArrayBuffer>);
 export function fromArray(arr: number[]): Uint8Array;
 /**

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;AAkOD;;;;GAIG;AACH,4BAJW,UAAU,MACV,UAAU,GACR,MAAM,CAgBlB;AA4HD;;;GAGG;AACH,kDAHW,MAAM,EAAE,GACN,MAAM,CAkBlB;AAnaD,gCAMkD;AAgC9C;;;;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":"AAuBA;;;GAGG;AACH,2BAHW,UAAU,GAAC,MAAM,EAAE,GACjB,UAAU,CAQtB;AAoMD;;;;GAIG;AACH,4BAJW,UAAU,MACV,UAAU,GACR,MAAM,CAgBlB;AA6CD;;;GAGG;AACH,kDAHW,MAAM,EAAE,GACN,MAAM,CAkBlB;AArTD,gCAMkD;AAyBlD,mCAGe,MAAM,iDAYN,MAAM,yCAIhB;AAOE,+BAHI,MAAM,EAAE,GACN,UAAU,CAItB;AAIG;;;;GAIG;AAEH,6BALW,UAAU,SACV,MAAM,OACN,MAAM,2BAQhB;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":"AAwCA,oCAAoC;AACpC,oCADc,gBAAgB,EAAE,CAY/B;AAnBD,4BAA4B;AAC5B,mCADW,aAAa,CAKtB;sBA+XW,KAAK,GAAG;IAAE,SAAS,CAAC,EAAE,UAAU,CAAA;CAAE;4BApZlC,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;yBAC1C,OAAO,cAAc,EAAE,UAAU;AA0R9C;;;;;GAKG;AACH,oCALW,GAAG,YACH,aAAa,aACb,SAAS,GACP,mBAAmB,CAgB/B;AA4LD;;;;GAIG;AACH,6BAJW,GAAG,YACH,aAAa,GACX,UAAU,CAKtB;AAnDD;;;;;;GAMG;AACH,mCANW,GAAG,YACH,gBAAgB,EAAE,WAClB,aAAa,gBACb,UAAU,GACR,UAAU,CAoCtB;AAYD;;;;;GAKG;AACH,iCALW,GAAG,eACH,UAAU,YACV,aAAa,GACX;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAM/B;AA3dD,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;sBA9F2B,YAAY"}
+{"version":3,"file":"encode.d.ts","sourceRoot":"","sources":["../../lib/encode.js"],"names":[],"mappings":"AAwCA,oCAAoC;AACpC,oCADc,gBAAgB,EAAE,CAY/B;AAnBD,4BAA4B;AAC5B,mCADW,aAAa,CAKtB;sBA+XW,KAAK,GAAG;IAAE,SAAS,CAAC,EAAE,UAAU,CAAA;CAAE;4BApZlC,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;yBAC1C,OAAO,cAAc,EAAE,UAAU;AA0R9C;;;;;GAKG;AACH,oCALW,GAAG,YACH,aAAa,aACb,SAAS,GACP,mBAAmB,CAgB/B;AAiUD;;;;GAIG;AACH,6BAJW,GAAG,YACH,aAAa,GACX,UAAU,CAatB;AA3DD;;;;;;GAMG;AACH,mCANW,GAAG,YACH,gBAAgB,EAAE,WAClB,aAAa,gBACb,UAAU,GACR,UAAU,CAoCtB;AAoBD;;;;;GAKG;AACH,iCALW,GAAG,eACH,UAAU,YACV,aAAa,GACX;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAc/B;AAhnBD,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;sBA9F2B,YAAY"}