bson 5.3.0 → 6.0.0-alpha

package/src/binary.ts

@@ -1,4 +1,4 @@
-import { isUint8Array } from './parser/utils';
+import { isAnyArrayBuffer, isUint8Array } from './parser/utils';
 import type { EJSONOptions } from './extended_json';
 import { BSONError } from './error';
 import { BSON_BINARY_SUBTYPE_UUID_NEW } from './constants';
@@ -65,27 +65,19 @@ export class Binary extends BSONValue {
 
   /**
    * Create a new Binary instance.
-   *
-   * This constructor can accept a string as its first argument. In this case,
-   * this string will be encoded using ISO-8859-1, **not** using UTF-8.
-   * This is almost certainly not what you want. Use `new Binary(Buffer.from(string))`
-   * instead to convert the string to a Buffer using UTF-8 first.
-   *
    * @param buffer - a buffer object containing the binary data.
    * @param subType - the option binary type.
    */
-  constructor(buffer?: string | BinarySequence, subType?: number) {
+  constructor(buffer?: BinarySequence, subType?: number) {
     super();
     if (
       !(buffer == null) &&
-      !(typeof buffer === 'string') &&
+      typeof buffer === 'string' &&
       !ArrayBuffer.isView(buffer) &&
-      !(buffer instanceof ArrayBuffer) &&
+      !isAnyArrayBuffer(buffer) &&
       !Array.isArray(buffer)
     ) {
-      throw new BSONError(
-        'Binary can only be constructed from string, Buffer, TypedArray, or Array<number>'
-      );
+      throw new BSONError('Binary can only be constructed from Uint8Array or number[]');
     }
 
     this.sub_type = subType ?? Binary.BSON_BINARY_SUBTYPE_DEFAULT;
@@ -95,17 +87,9 @@ export class Binary extends BSONValue {
       this.buffer = ByteUtils.allocate(Binary.BUFFER_SIZE);
       this.position = 0;
     } else {
-      if (typeof buffer === 'string') {
-        // string
-        this.buffer = ByteUtils.fromISO88591(buffer);
-      } else if (Array.isArray(buffer)) {
-        // number[]
-        this.buffer = ByteUtils.fromNumberArray(buffer);
-      } else {
-        // Buffer | TypedArray | ArrayBuffer
-        this.buffer = ByteUtils.toLocalBufferType(buffer);
-      }
-
+      this.buffer = Array.isArray(buffer)
+        ? ByteUtils.fromNumberArray(buffer)
+        : ByteUtils.toLocalBufferType(buffer);
       this.position = this.buffer.byteLength;
     }
   }
@@ -147,12 +131,12 @@ export class Binary extends BSONValue {
   }
 
   /**
-   * Writes a buffer or string to the binary.
+   * Writes a buffer to the binary.
    *
    * @param sequence - a string or buffer to be written to the Binary BSON object.
    * @param offset - specify the binary of where to write the content.
    */
-  write(sequence: string | BinarySequence, offset: number): void {
+  write(sequence: BinarySequence, offset: number): void {
     offset = typeof offset === 'number' ? offset : this.position;
 
     // If the buffer is to small let's extend the buffer
@@ -169,10 +153,7 @@ export class Binary extends BSONValue {
       this.position =
         offset + sequence.byteLength > this.position ? offset + sequence.length : this.position;
     } else if (typeof sequence === 'string') {
-      const bytes = ByteUtils.fromISO88591(sequence);
-      this.buffer.set(bytes, offset);
-      this.position =
-        offset + sequence.length > this.position ? offset + sequence.length : this.position;
+      throw new BSONError('input cannot be string');
     }
   }
 
@@ -189,26 +170,12 @@ export class Binary extends BSONValue {
     return this.buffer.slice(position, position + length);
   }
 
-  /**
-   * Returns the value of this binary as a string.
-   * @param asRaw - Will skip converting to a string
-   * @remarks
-   * This is handy when calling this function conditionally for some key value pairs and not others
-   */
-  value(asRaw?: boolean): string | BinarySequence {
-    asRaw = !!asRaw;
-
+  /** returns a view of the binary value as a Uint8Array */
+  value(): Uint8Array {
     // Optimize to serialize for the situation where the data == size of buffer
-    if (asRaw && this.buffer.length === this.position) {
-      return this.buffer;
-    }
-
-    // If it's a node.js buffer object
-    if (asRaw) {
-      return this.buffer.slice(0, this.position);
-    }
-    // TODO(NODE-4361): remove binary string support, value(true) should be the default / only option here.
-    return ByteUtils.toISO88591(this.buffer.subarray(0, this.position));
+    return this.buffer.length === this.position
+      ? this.buffer
+      : this.buffer.subarray(0, this.position);
   }
 
   /** the length of the binary sequence */
@@ -223,8 +190,9 @@ export class Binary extends BSONValue {
   toString(encoding?: 'hex' | 'base64' | 'utf8' | 'utf-8'): string {
     if (encoding === 'hex') return ByteUtils.toHex(this.buffer);
     if (encoding === 'base64') return ByteUtils.toBase64(this.buffer);
-    if (encoding === 'utf8' || encoding === 'utf-8') return ByteUtils.toUTF8(this.buffer);
-    return ByteUtils.toUTF8(this.buffer);
+    if (encoding === 'utf8' || encoding === 'utf-8')
+      return ByteUtils.toUTF8(this.buffer, 0, this.buffer.byteLength);
+    return ByteUtils.toUTF8(this.buffer, 0, this.buffer.byteLength);
   }
 
   /** @internal */
@@ -320,8 +288,6 @@ const UUID_WITH_DASHES = /^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A
  * @public
  */
 export class UUID extends Binary {
-  /** @deprecated Hex string is no longer cached, this control will be removed in a future major release */
-  static cacheHexString = false;
   /**
    * Create a UUID type
    *

package/src/bson.ts

@@ -10,8 +10,8 @@ import { MinKey } from './min_key';
 import { ObjectId } from './objectid';
 import { internalCalculateObjectSize } from './parser/calculate_size';
 // Parts of the parser
-import { internalDeserialize, DeserializeOptions } from './parser/deserializer';
-import { serializeInto, SerializeOptions } from './parser/serializer';
+import { internalDeserialize, type DeserializeOptions } from './parser/deserializer';
+import { serializeInto, type SerializeOptions } from './parser/serializer';
 import { BSONRegExp } from './regexp';
 import { BSONSymbol } from './symbol';
 import { Timestamp } from './timestamp';

package/src/code.ts

@@ -62,7 +62,7 @@ export class Code extends BSONValue {
 
   inspect(): string {
     const codeJson = this.toJSON();
-    return `new Code("${String(codeJson.code)}"${
+    return `new Code(${JSON.stringify(String(codeJson.code))}${
       codeJson.scope != null ? `, ${JSON.stringify(codeJson.scope)}` : ''
     })`;
   }

package/src/constants.ts

@@ -1,5 +1,5 @@
 /** @internal */
-export const BSON_MAJOR_VERSION = 5 as const;
+export const BSON_MAJOR_VERSION = 6 as const;
 
 /** @internal */
 export const BSON_INT32_MAX = 0x7fffffff;

package/src/decimal128.ts

@@ -160,6 +160,7 @@ export class Decimal128 extends BSONValue {
   static fromString(representation: string): Decimal128 {
     // Parse state tracking
     let isNegative = false;
+    let sawSign = false;
     let sawRadix = false;
     let foundNonZero = false;
 
@@ -180,15 +181,11 @@ export class Decimal128 extends BSONValue {
     let nDigitsStored = 0;
     // Insertion pointer for digits
     let digitsInsert = 0;
-    // The index of the first non-zero digit
-    let firstDigit = 0;
     // The index of the last digit
     let lastDigit = 0;
 
     // Exponent
     let exponent = 0;
-    // loop index over array
-    let i = 0;
     // The high 17 digits of the significand
     let significandHigh = new Long(0, 0);
     // The low 17 digits of the significand
@@ -241,6 +238,7 @@ export class Decimal128 extends BSONValue {
 
     // Get the negative or positive sign
     if (representation[index] === '+' || representation[index] === '-') {
+      sawSign = true;
       isNegative = representation[index++] === '-';
     }
 
@@ -263,7 +261,7 @@ export class Decimal128 extends BSONValue {
         continue;
       }
 
-      if (nDigitsStored < 34) {
+      if (nDigitsStored < MAX_DIGITS) {
         if (representation[index] !== '0' || foundNonZero) {
           if (!foundNonZero) {
             firstNonZero = nDigitsRead;
@@ -307,11 +305,7 @@ export class Decimal128 extends BSONValue {
 
     // Done reading input
     // Find first non-zero digit in digits
-    firstDigit = 0;
-
     if (!nDigitsStored) {
-      firstDigit = 0;
-      lastDigit = 0;
       digits[0] = 0;
       nDigits = 1;
       nDigitsStored = 1;
@@ -320,7 +314,11 @@ export class Decimal128 extends BSONValue {
       lastDigit = nDigitsStored - 1;
       significantDigits = nDigits;
       if (significantDigits !== 1) {
-        while (digits[firstNonZero + significantDigits - 1] === 0) {
+        while (
+          representation[
+            firstNonZero + significantDigits - 1 + Number(sawSign) + Number(sawRadix)
+          ] === '0'
+        ) {
           significantDigits = significantDigits - 1;
         }
       }
@@ -331,7 +329,7 @@ export class Decimal128 extends BSONValue {
     // to represent user input
 
     // Overflow prevention
-    if (exponent <= radixPosition && radixPosition - exponent > 1 << 14) {
+    if (exponent <= radixPosition && radixPosition > exponent + (1 << 14)) {
       exponent = EXPONENT_MIN;
     } else {
       exponent = exponent - radixPosition;
@@ -341,11 +339,9 @@ export class Decimal128 extends BSONValue {
     while (exponent > EXPONENT_MAX) {
       // Shift exponent to significand and decrease
       lastDigit = lastDigit + 1;
-
-      if (lastDigit - firstDigit > MAX_DIGITS) {
+      if (lastDigit >= MAX_DIGITS) {
         // Check if we have a zero then just hard clamp, otherwise fail
-        const digitsString = digits.join('');
-        if (digitsString.match(/^0+$/)) {
+        if (significantDigits === 0) {
           exponent = EXPONENT_MAX;
           break;
         }
@@ -357,16 +353,28 @@ export class Decimal128 extends BSONValue {
 
     while (exponent < EXPONENT_MIN || nDigitsStored < nDigits) {
       // Shift last digit. can only do this if < significant digits than # stored.
-      if (lastDigit === 0 && significantDigits < nDigitsStored) {
-        exponent = EXPONENT_MIN;
-        significantDigits = 0;
-        break;
+      if (lastDigit === 0) {
+        if (significantDigits === 0) {
+          exponent = EXPONENT_MIN;
+          break;
+        }
+
+        invalidErr(representation, 'exponent underflow');
       }
 
       if (nDigitsStored < nDigits) {
+        if (
+          representation[nDigits - 1 + Number(sawSign) + Number(sawRadix)] !== '0' &&
+          significantDigits !== 0
+        ) {
+          invalidErr(representation, 'inexact rounding');
+        }
         // adjust to match digits not stored
         nDigits = nDigits - 1;
       } else {
+        if (digits[lastDigit] !== 0) {
+          invalidErr(representation, 'inexact rounding');
+        }
         // adjust to round
         lastDigit = lastDigit - 1;
       }
@@ -374,68 +382,28 @@ export class Decimal128 extends BSONValue {
       if (exponent < EXPONENT_MAX) {
         exponent = exponent + 1;
       } else {
-        // Check if we have a zero then just hard clamp, otherwise fail
-        const digitsString = digits.join('');
-        if (digitsString.match(/^0+$/)) {
-          exponent = EXPONENT_MAX;
-          break;
-        }
         invalidErr(representation, 'overflow');
       }
     }
 
     // Round
     // We've normalized the exponent, but might still need to round.
-    if (lastDigit - firstDigit + 1 < significantDigits) {
-      let endOfString = nDigitsRead;
-
+    if (lastDigit + 1 < significantDigits) {
       // If we have seen a radix point, 'string' is 1 longer than we have
       // documented with ndigits_read, so inc the position of the first nonzero
       // digit and the position that digits are read to.
       if (sawRadix) {
         firstNonZero = firstNonZero + 1;
-        endOfString = endOfString + 1;
       }
-      // if negative, we need to increment again to account for - sign at start.
-      if (isNegative) {
+      // if saw sign, we need to increment again to account for - or + sign at start.
+      if (sawSign) {
         firstNonZero = firstNonZero + 1;
-        endOfString = endOfString + 1;
       }
 
       const roundDigit = parseInt(representation[firstNonZero + lastDigit + 1], 10);
-      let roundBit = 0;
-
-      if (roundDigit >= 5) {
-        roundBit = 1;
-        if (roundDigit === 5) {
-          roundBit = digits[lastDigit] % 2 === 1 ? 1 : 0;
-          for (i = firstNonZero + lastDigit + 2; i < endOfString; i++) {
-            if (parseInt(representation[i], 10)) {
-              roundBit = 1;
-              break;
-            }
-          }
-        }
-      }
 
-      if (roundBit) {
-        let dIdx = lastDigit;
-
-        for (; dIdx >= 0; dIdx--) {
-          if (++digits[dIdx] > 9) {
-            digits[dIdx] = 0;
-
-            // overflowed most significant digit
-            if (dIdx === 0) {
-              if (exponent < EXPONENT_MAX) {
-                exponent = exponent + 1;
-                digits[dIdx] = 1;
-              } else {
-                return new Decimal128(isNegative ? INF_NEGATIVE_BUFFER : INF_POSITIVE_BUFFER);
-              }
-            }
-          }
-        }
+      if (roundDigit !== 0) {
+        invalidErr(representation, 'inexact rounding');
       }
     }
 
@@ -449,8 +417,8 @@ export class Decimal128 extends BSONValue {
     if (significantDigits === 0) {
       significandHigh = Long.fromNumber(0);
       significandLow = Long.fromNumber(0);
-    } else if (lastDigit - firstDigit < 17) {
-      let dIdx = firstDigit;
+    } else if (lastDigit < 17) {
+      let dIdx = 0;
       significandLow = Long.fromNumber(digits[dIdx++]);
       significandHigh = new Long(0, 0);
 
@@ -459,7 +427,7 @@ export class Decimal128 extends BSONValue {
         significandLow = significandLow.add(Long.fromNumber(digits[dIdx]));
       }
     } else {
-      let dIdx = firstDigit;
+      let dIdx = 0;
       significandHigh = Long.fromNumber(digits[dIdx++]);
 
       for (; dIdx <= lastDigit - 17; dIdx++) {

package/src/objectid.ts

@@ -1,6 +1,5 @@
 import { BSONValue } from './bson_value';
 import { BSONError } from './error';
-import { isUint8Array } from './parser/utils';
 import { BSONDataView, ByteUtils } from './utils/byte_utils';
 
 // Regular expression that checks for hex value
@@ -74,19 +73,11 @@ export class ObjectId extends BSONValue {
       // If intstanceof matches we can escape calling ensure buffer in Node.js environments
       this[kId] = ByteUtils.toLocalBufferType(workingId);
     } else if (typeof workingId === 'string') {
-      if (workingId.length === 12) {
-        // TODO(NODE-4361): Remove string of length 12 support
-        const bytes = ByteUtils.fromUTF8(workingId);
-        if (bytes.byteLength === 12) {
-          this[kId] = bytes;
-        } else {
-          throw new BSONError('Argument passed in must be a string of 12 bytes');
-        }
-      } else if (workingId.length === 24 && checkForHexRegExp.test(workingId)) {
+      if (workingId.length === 24 && checkForHexRegExp.test(workingId)) {
         this[kId] = ByteUtils.fromHex(workingId);
       } else {
         throw new BSONError(
-          'Argument passed in must be a string of 12 bytes or a string of 24 hex characters or an integer'
+          'input must be a 24 character hex string, 12 byte Uint8Array, or an integer'
         );
       }
     } else {
@@ -113,7 +104,7 @@ export class ObjectId extends BSONValue {
     }
   }
 
-  /** Returns the ObjectId id as a 24 character hex string representation */
+  /** Returns the ObjectId id as a 24 lowercase character hex string representation */
   toHexString(): string {
     if (ObjectId.cacheHexString && this.__id) {
       return this.__id;
@@ -188,44 +179,37 @@ export class ObjectId extends BSONValue {
     return this.toHexString();
   }
 
+  /** @internal */
+  private static is(variable: unknown): variable is ObjectId {
+    return (
+      variable != null &&
+      typeof variable === 'object' &&
+      '_bsontype' in variable &&
+      variable._bsontype === 'ObjectId'
+    );
+  }
+
   /**
    * Compares the equality of this ObjectId with `otherID`.
    *
    * @param otherId - ObjectId instance to compare against.
    */
-  equals(otherId: string | ObjectId | ObjectIdLike): boolean {
+  equals(otherId: string | ObjectId | ObjectIdLike | undefined | null): boolean {
     if (otherId === undefined || otherId === null) {
       return false;
     }
 
-    if (otherId instanceof ObjectId) {
+    if (ObjectId.is(otherId)) {
       return this[kId][11] === otherId[kId][11] && ByteUtils.equals(this[kId], otherId[kId]);
     }
 
-    if (
-      typeof otherId === 'string' &&
-      ObjectId.isValid(otherId) &&
-      otherId.length === 12 &&
-      isUint8Array(this.id)
-    ) {
-      return ByteUtils.equals(this.id, ByteUtils.fromISO88591(otherId));
-    }
-
-    if (typeof otherId === 'string' && ObjectId.isValid(otherId) && otherId.length === 24) {
+    if (typeof otherId === 'string') {
       return otherId.toLowerCase() === this.toHexString();
     }
 
-    if (typeof otherId === 'string' && ObjectId.isValid(otherId) && otherId.length === 12) {
-      return ByteUtils.equals(ByteUtils.fromUTF8(otherId), this.id);
-    }
-
-    if (
-      typeof otherId === 'object' &&
-      'toHexString' in otherId &&
-      typeof otherId.toHexString === 'function'
-    ) {
+    if (typeof otherId === 'object' && typeof otherId.toHexString === 'function') {
       const otherIdString = otherId.toHexString();
-      const thisIdString = this.toHexString().toLowerCase();
+      const thisIdString = this.toHexString();
       return typeof otherIdString === 'string' && otherIdString.toLowerCase() === thisIdString;
     }
 
@@ -281,9 +265,8 @@ export class ObjectId extends BSONValue {
   }
 
   /**
-   * Checks if a value is a valid bson ObjectId
-   *
-   * @param id - ObjectId instance to validate.
+   * Checks if a value can be used to create a valid bson ObjectId
+   * @param id - any JS value
    */
   static isValid(id: string | number | ObjectId | ObjectIdLike | Uint8Array): boolean {
     if (id == null) return false;

package/src/parser/deserializer.ts

@@ -2,7 +2,7 @@ import { Binary, UUID } from '../binary';
 import type { Document } from '../bson';
 import { Code } from '../code';
 import * as constants from '../constants';
-import { DBRef, DBRefLike, isDBRefLike } from '../db_ref';
+import { DBRef, type DBRefLike, isDBRefLike } from '../db_ref';
 import { Decimal128 } from '../decimal128';
 import { Double } from '../double';
 import { BSONError } from '../error';
@@ -236,7 +236,7 @@ function deserializeObject(
     if (i >= buffer.byteLength) throw new BSONError('Bad BSON Document: illegal CString');
 
     // Represents the key
-    const name = isArray ? arrayIndex++ : ByteUtils.toUTF8(buffer.subarray(index, i));
+    const name = isArray ? arrayIndex++ : ByteUtils.toUTF8(buffer, index, i);
 
     // shouldValidateKey is true if the key should be validated, false otherwise
     let shouldValidateKey = true;
@@ -476,7 +476,7 @@ function deserializeObject(
       // If are at the end of the buffer there is a problem with the document
       if (i >= buffer.length) throw new BSONError('Bad BSON Document: illegal CString');
       // Return the C string
-      const source = ByteUtils.toUTF8(buffer.subarray(index, i));
+      const source = ByteUtils.toUTF8(buffer, index, i);
       // Create the regexp
       index = i + 1;
 
@@ -489,7 +489,7 @@ function deserializeObject(
       // If are at the end of the buffer there is a problem with the document
       if (i >= buffer.length) throw new BSONError('Bad BSON Document: illegal CString');
       // Return the C string
-      const regExpOptions = ByteUtils.toUTF8(buffer.subarray(index, i));
+      const regExpOptions = ByteUtils.toUTF8(buffer, index, i);
       index = i + 1;
 
       // For each option add the corresponding one for javascript
@@ -521,7 +521,7 @@ function deserializeObject(
       // If are at the end of the buffer there is a problem with the document
       if (i >= buffer.length) throw new BSONError('Bad BSON Document: illegal CString');
       // Return the C string
-      const source = ByteUtils.toUTF8(buffer.subarray(index, i));
+      const source = ByteUtils.toUTF8(buffer, index, i);
       index = i + 1;
 
       // Get the start search index
@@ -533,7 +533,7 @@ function deserializeObject(
       // If are at the end of the buffer there is a problem with the document
       if (i >= buffer.length) throw new BSONError('Bad BSON Document: illegal CString');
       // Return the C string
-      const regExpOptions = ByteUtils.toUTF8(buffer.subarray(index, i));
+      const regExpOptions = ByteUtils.toUTF8(buffer, index, i);
       index = i + 1;
 
       // Set the object
@@ -678,7 +678,7 @@ function deserializeObject(
           throw new BSONError('Invalid UTF-8 string in BSON document');
         }
       }
-      const namespace = ByteUtils.toUTF8(buffer.subarray(index, index + stringSize - 1));
+      const namespace = ByteUtils.toUTF8(buffer, index, index + stringSize - 1);
       // Update parse index position
       index = index + stringSize;
 
@@ -735,7 +735,7 @@ function getValidatedString(
   end: number,
   shouldValidateUtf8: boolean
 ) {
-  const value = ByteUtils.toUTF8(buffer.subarray(start, end));
+  const value = ByteUtils.toUTF8(buffer, start, end);
   // if utf8 validation is on, do the check
   if (shouldValidateUtf8) {
     for (let i = 0; i < value.length; i++) {

package/src/symbol.ts

@@ -34,7 +34,7 @@ export class BSONSymbol extends BSONValue {
   }
 
   inspect(): string {
-    return `new BSONSymbol("${this.value}")`;
+    return `new BSONSymbol(${JSON.stringify(this.value)})`;
   }
 
   toJSON(): string {

package/src/timestamp.ts

@@ -61,24 +61,26 @@ export class Timestamp extends LongWithoutOverridesClass {
       if (typeof low.i !== 'number' && (typeof low.i !== 'object' || low.i._bsontype !== 'Int32')) {
         throw new BSONError('Timestamp constructed from { t, i } must provide i as a number');
       }
-      if (low.t < 0) {
+      const t = Number(low.t);
+      const i = Number(low.i);
+      if (t < 0 || Number.isNaN(t)) {
         throw new BSONError('Timestamp constructed from { t, i } must provide a positive t');
       }
-      if (low.i < 0) {
+      if (i < 0 || Number.isNaN(i)) {
         throw new BSONError('Timestamp constructed from { t, i } must provide a positive i');
       }
-      if (low.t > 0xffff_ffff) {
+      if (t > 0xffff_ffff) {
         throw new BSONError(
           'Timestamp constructed from { t, i } must provide t equal or less than uint32 max'
         );
       }
-      if (low.i > 0xffff_ffff) {
+      if (i > 0xffff_ffff) {
         throw new BSONError(
           'Timestamp constructed from { t, i } must provide i equal or less than uint32 max'
         );
       }
 
-      super(low.i.valueOf(), low.t.valueOf(), true);
+      super(i, t, true);
     } else {
       throw new BSONError(
         'A Timestamp can only be constructed with: bigint, Long, or { t: number; i: number }'

package/src/utils/byte_utils.ts

@@ -21,12 +21,12 @@ export type ByteUtils = {
   toISO88591: (buffer: Uint8Array) => string;
   /** Create a Uint8Array from a hex string */
   fromHex: (hex: string) => Uint8Array;
-  /** Create a hex string from bytes */
+  /** Create a lowercase hex string from bytes */
   toHex: (buffer: Uint8Array) => string;
   /** Create a Uint8Array containing utf8 code units from a string */
   fromUTF8: (text: string) => Uint8Array;
   /** Create a string from utf8 code units */
-  toUTF8: (buffer: Uint8Array) => string;
+  toUTF8: (buffer: Uint8Array, start: number, end: number) => string;
   /** Get the utf8 code unit count from a string if it were to be transformed to utf8 */
   utf8ByteLength: (input: string) => number;
   /** Encode UTF8 bytes generated from `source` string into `destination` at byteOffset. Returns the number of bytes encoded. */

package/src/utils/node_byte_utils.ts

@@ -5,7 +5,7 @@ type NodeJsBuffer = ArrayBufferView &
   Uint8Array & {
     write(string: string, offset: number, length: undefined, encoding: 'utf8'): number;
     copy(target: Uint8Array, targetStart: number, sourceStart: number, sourceEnd: number): number;
-    toString: (this: Uint8Array, encoding: NodeJsEncoding) => string;
+    toString: (this: Uint8Array, encoding: NodeJsEncoding, start?: number, end?: number) => string;
     equals: (this: Uint8Array, other: Uint8Array) => boolean;
   };
 type NodeJsBufferConstructor = Omit<Uint8ArrayConstructor, 'from'> & {
@@ -125,8 +125,8 @@ export const nodeJsByteUtils = {
     return Buffer.from(text, 'utf8');
   },
 
-  toUTF8(buffer: Uint8Array): string {
-    return nodeJsByteUtils.toLocalBufferType(buffer).toString('utf8');
+  toUTF8(buffer: Uint8Array, start: number, end: number): string {
+    return nodeJsByteUtils.toLocalBufferType(buffer).toString('utf8', start, end);
   },
 
   utf8ByteLength(input: string): number {

package/src/utils/web_byte_utils.ts

@@ -172,8 +172,8 @@ export const webByteUtils = {
     return new TextEncoder().encode(text);
   },
 
-  toUTF8(uint8array: Uint8Array): string {
-    return new TextDecoder('utf8', { fatal: false }).decode(uint8array);
+  toUTF8(uint8array: Uint8Array, start: number, end: number): string {
+    return new TextDecoder('utf8', { fatal: false }).decode(uint8array.slice(start, end));
   },
 
   utf8ByteLength(input: string): number {

package/vendor/base64/LICENSE-MIT.txt

@@ -0,0 +1,20 @@
+Copyright Mathias Bynens <https://mathiasbynens.be/>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.