bson 6.10.4 → 7.0.0-alpha.1

package/package.json

@@ -14,7 +14,7 @@
     "vendor"
   ],
   "types": "bson.d.ts",
-  "version": "6.10.4",
+  "version": "7.0.0-alpha.1",
   "author": {
     "name": "The MongoDB NodeJS Team",
     "email": "dbx-node@mongodb.com"
@@ -32,7 +32,7 @@
     "@rollup/plugin-typescript": "^12.1.2",
     "@types/chai": "^4.3.17",
     "@types/mocha": "^10.0.7",
-    "@types/node": "^22.15.3",
+    "@types/node": "^24.2.1",
     "@types/sinon": "^17.0.4",
     "@types/sinon-chai": "^3.2.12",
     "@typescript-eslint/eslint-plugin": "^8.31.1",
@@ -41,13 +41,12 @@
     "chai": "^4.4.1",
     "chalk": "^5.3.0",
     "dbx-js-tools": "github:mongodb-js/dbx-js-tools#main",
-    "eslint": "^9.25.1",
+    "eslint": "^9.33.0",
     "eslint-config-prettier": "^10.1.2",
-    "eslint-plugin-no-bigint-usage": "file:etc/eslint/no-bigint-usage",
     "eslint-plugin-prettier": "^5.2.6",
     "eslint-plugin-tsdoc": "^0.4.0",
     "magic-string": "^0.30.11",
-    "mocha": "^10.7.0",
+    "mocha": "^11.7.1",
     "node-fetch": "^3.3.2",
     "nyc": "^15.1.0",
     "prettier": "^3.5.3",
@@ -57,7 +56,8 @@
     "source-map-support": "^0.5.21",
     "tar": "^7.4.3",
     "ts-node": "^10.9.2",
-    "tsd": "^0.31.1",
+    "tsd": "^0.33.0",
+    "tslib": "^2.8.1",
     "typescript": "^5.8.3",
     "typescript-cached-transpile": "0.0.6",
     "uuid": "^11.1.0"
@@ -93,15 +93,14 @@
     "require": "./lib/bson.cjs"
   },
   "engines": {
-    "node": ">=16.20.1"
+    "node": ">=20.19.0"
   },
   "scripts": {
     "pretest": "npm run build",
-    "test": "npm run check:node && npm run check:web && npm run check:web-no-bigint",
+    "test": "npm run check:node && npm run check:web",
     "check:node": "WEB=false mocha test/node",
     "check:tsd": "npm run build:dts && tsd",
     "check:web": "WEB=true mocha test/node",
-    "check:web-no-bigint": "WEB=true NO_BIGINT=true mocha test/node",
     "check:granular-bench": "npm run build:bench && npm run check:baseline-bench && node ./test/bench/etc/run_granular_benchmarks.js",
     "check:spec-bench": "npm run build:bench && npm run check:baseline-bench && node ./test/bench/lib/spec/bsonBench.js",
     "check:custom-bench": "npm run build && npm run check:baseline-bench && node ./test/bench/custom/main.mjs",
@@ -117,4 +116,4 @@
     "prepare": "node etc/prepare.js",
     "release": "standard-version -i HISTORY.md"
   }
-}
+}

package/src/binary.ts

@@ -45,7 +45,10 @@ export class Binary extends BSONValue {
   static readonly SUBTYPE_DEFAULT = 0;
   /** Function BSON type */
   static readonly SUBTYPE_FUNCTION = 1;
-  /** Byte Array BSON type */
+  /**
+   * Legacy default BSON Binary type
+   * @deprecated BSON Binary subtype 2 is deprecated in the BSON specification
+   */
   static readonly SUBTYPE_BYTE_ARRAY = 2;
   /** Deprecated UUID BSON type @deprecated Please use SUBTYPE_UUID */
   static readonly SUBTYPE_UUID_OLD = 3;

package/src/bson.ts

@@ -50,7 +50,7 @@ export {
   BSONRegExp,
   Decimal128
 };
-export { BSONValue } from './bson_value';
+export { BSONValue, bsonType, type BSONTypeTag } from './bson_value';
 export { BSONError, BSONVersionError, BSONRuntimeError, BSONOffsetError } from './error';
 export { BSONType } from './constants';
 export { EJSON } from './extended_json';

package/src/bson_value.ts

@@ -2,10 +2,33 @@ import { BSON_MAJOR_VERSION } from './constants';
 import { type InspectFn } from './parser/utils';
 import { BSON_VERSION_SYMBOL } from './constants';
 
+/** @public */
+export type BSONTypeTag =
+  | 'BSONRegExp'
+  | 'BSONSymbol'
+  | 'ObjectId'
+  | 'Binary'
+  | 'Decimal128'
+  | 'Double'
+  | 'Int32'
+  | 'Long'
+  | 'MaxKey'
+  | 'MinKey'
+  | 'Timestamp'
+  | 'Code'
+  | 'DBRef';
+
+/** @public */
+export const bsonType = Symbol.for('@@mdb.bson.type');
+
 /** @public */
 export abstract class BSONValue {
   /** @public */
-  public abstract get _bsontype(): string;
+  public abstract get _bsontype(): BSONTypeTag;
+
+  public get [bsonType](): this['_bsontype'] {
+    return this._bsontype;
+  }
 
   /** @internal */
   get [BSON_VERSION_SYMBOL](): typeof BSON_MAJOR_VERSION {

package/src/constants.ts

@@ -1,5 +1,5 @@
 /** @internal */
-export const BSON_MAJOR_VERSION = 6;
+export const BSON_MAJOR_VERSION = 7;
 
 /** @internal */
 export const BSON_VERSION_SYMBOL = Symbol.for('@@mdb.bson.version');

package/src/extended_json.ts

@@ -102,7 +102,6 @@ function deserializeValue(value: any, options: EJSONOptions = {}) {
       }
       if (in64BitRange) {
         if (options.useBigInt64) {
-          // eslint-disable-next-line no-restricted-globals -- This is allowed here as useBigInt64=true
           return BigInt(value);
         }
         return Long.fromNumber(value);
@@ -275,12 +274,10 @@ function serializeValue(value: any, options: EJSONSerializeOptions): any {
   }
 
   if (typeof value === 'bigint') {
-    /* eslint-disable no-restricted-globals -- This is allowed as we are accepting a bigint as input */
     if (!options.relaxed) {
       return { $numberLong: BigInt.asIntN(64, value).toString() };
     }
     return Number(BigInt.asIntN(64, value));
-    /* eslint-enable */
   }
 
   if (value instanceof RegExp || isRegExp(value)) {

package/src/long.ts

@@ -258,10 +258,8 @@ export class Long extends BSONValue {
    * @returns The corresponding Long value
    */
   static fromBigInt(value: bigint, unsigned?: boolean): Long {
-    // eslint-disable-next-line no-restricted-globals
-    const FROM_BIGINT_BIT_MASK = BigInt(0xffffffff);
-    // eslint-disable-next-line no-restricted-globals
-    const FROM_BIGINT_BIT_SHIFT = BigInt(32);
+    const FROM_BIGINT_BIT_MASK = 0xffffffffn;
+    const FROM_BIGINT_BIT_SHIFT = 32n;
     return new Long(
       Number(value & FROM_BIGINT_BIT_MASK),
       Number((value >> FROM_BIGINT_BIT_SHIFT) & FROM_BIGINT_BIT_MASK),
@@ -366,7 +364,7 @@ export class Long extends BSONValue {
     let unsigned = false;
     if (typeof unsignedOrRadix === 'number') {
       // For goog.math.long compatibility
-      (radix = unsignedOrRadix), (unsignedOrRadix = false);
+      ((radix = unsignedOrRadix), (unsignedOrRadix = false));
     } else {
       unsigned = !!unsignedOrRadix;
     }
@@ -456,7 +454,7 @@ export class Long extends BSONValue {
     let unsigned = false;
     if (typeof unsignedOrRadix === 'number') {
       // For goog.math.long compatibility
-      (radix = unsignedOrRadix), (unsignedOrRadix = false);
+      ((radix = unsignedOrRadix), (unsignedOrRadix = false));
     } else {
       unsigned = !!unsignedOrRadix;
     }
@@ -1077,7 +1075,6 @@ export class Long extends BSONValue {
 
   /** Converts the Long to a BigInt (arbitrary precision). */
   toBigInt(): bigint {
-    // eslint-disable-next-line no-restricted-globals -- This is allowed here as it is explicitly requesting a bigint
     return BigInt(this.toString());
   }
 
@@ -1223,10 +1220,8 @@ export class Long extends BSONValue {
     }
 
     if (useBigInt64) {
-      /* eslint-disable no-restricted-globals -- Can use BigInt here as useBigInt64=true */
       const bigIntResult = BigInt(doc.$numberLong);
       return BigInt.asIntN(64, bigIntResult);
-      /* eslint-enable */
     }
 
     const longResult = Long.fromString(doc.$numberLong);

package/src/objectid.ts

@@ -7,9 +7,6 @@ import { NumberUtils } from './utils/number_utils';
 // Unique sequence for the current process (initialized on first use)
 let PROCESS_UNIQUE: Uint8Array | null = null;
 
-/** ObjectId hexString cache @internal */
-const __idCache = new WeakMap(); // TODO(NODE-6549): convert this to #__id private field when target updated to ES2022
-
 /** @public */
 export interface ObjectIdLike {
   id: string | Uint8Array;
@@ -35,18 +32,22 @@ export class ObjectId extends BSONValue {
   /** @internal */
   private static index = Math.floor(Math.random() * 0xffffff);
 
-  static cacheHexString: boolean;
+  static cacheHexString: boolean = false;
 
   /** ObjectId Bytes @internal */
   private buffer!: Uint8Array;
 
   /**
-   * Create ObjectId from a number.
+   * If hex string caching is enabled, contains the cached hex string.  Otherwise, is null.
    *
-   * @param inputId - A number.
-   * @deprecated Instead, use `static createFromTime()` to set a numeric value for the new ObjectId.
+   * Note that #hexString is populated lazily, and as a result simply checking `this.#hexString != null` is
+   * not sufficient to determine if caching is enabled.  `ObjectId.prototype.isCached()` can be used to
+   * determine if the hex string has been cached yet for an ObjectId.
    */
-  constructor(inputId: number);
+  #cachedHexString: string | null = null;
+
+  /** To generate a new ObjectId, use ObjectId() with no argument. */
+  constructor();
   /**
    * Create ObjectId from a 24 character hex string.
    *
@@ -71,20 +72,18 @@ export class ObjectId extends BSONValue {
    * @param inputId - A 12 byte binary Buffer.
    */
   constructor(inputId: Uint8Array);
-  /** To generate a new ObjectId, use ObjectId() with no argument. */
-  constructor();
   /**
    * Implementation overload.
    *
    * @param inputId - All input types that are used in the constructor implementation.
    */
-  constructor(inputId?: string | number | ObjectId | ObjectIdLike | Uint8Array);
+  constructor(inputId?: string | ObjectId | ObjectIdLike | Uint8Array);
   /**
    * Create a new ObjectId.
    *
    * @param inputId - An input value to create a new ObjectId from.
    */
-  constructor(inputId?: string | number | ObjectId | ObjectIdLike | Uint8Array) {
+  constructor(inputId?: string | ObjectId | ObjectIdLike | Uint8Array) {
     super();
     // workingId is set based on type of input and whether valid id exists for the input
     let workingId;
@@ -102,19 +101,19 @@ export class ObjectId extends BSONValue {
     }
 
     // The following cases use workingId to construct an ObjectId
-    if (workingId == null || typeof workingId === 'number') {
+    if (workingId == null) {
       // The most common use case (blank id, new objectId instance)
       // Generate a new id
-      this.buffer = ObjectId.generate(typeof workingId === 'number' ? workingId : undefined);
+      this.buffer = ObjectId.generate();
     } else if (ArrayBuffer.isView(workingId) && workingId.byteLength === 12) {
-      // If intstanceof matches we can escape calling ensure buffer in Node.js environments
+      // If instanceof matches we can escape calling ensure buffer in Node.js environments
       this.buffer = ByteUtils.toLocalBufferType(workingId);
     } else if (typeof workingId === 'string') {
       if (ObjectId.validateHexString(workingId)) {
         this.buffer = ByteUtils.fromHex(workingId);
         // If we are caching the hex string
         if (ObjectId.cacheHexString) {
-          __idCache.set(this, workingId);
+          this.#cachedHexString = workingId;
         }
       } else {
         throw new BSONError(
@@ -137,7 +136,7 @@ export class ObjectId extends BSONValue {
   set id(value: Uint8Array) {
     this.buffer = value;
     if (ObjectId.cacheHexString) {
-      __idCache.set(this, ByteUtils.toHex(value));
+      this.#cachedHexString = ByteUtils.toHex(value);
     }
   }
 
@@ -166,15 +165,12 @@ export class ObjectId extends BSONValue {
 
   /** Returns the ObjectId id as a 24 lowercase character hex string representation */
   toHexString(): string {
-    if (ObjectId.cacheHexString) {
-      const __id = __idCache.get(this);
-      if (__id) return __id;
-    }
+    if (this.#cachedHexString) return this.#cachedHexString.toLowerCase();
 
     const hexString = ByteUtils.toHex(this.id);
 
     if (ObjectId.cacheHexString) {
-      __idCache.set(this, hexString);
+      this.#cachedHexString = hexString;
     }
 
     return hexString;
@@ -349,7 +345,7 @@ export class ObjectId extends BSONValue {
    * 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 {
+  static isValid(id: string | ObjectId | ObjectIdLike | Uint8Array): boolean {
     if (id == null) return false;
     if (typeof id === 'string') return ObjectId.validateHexString(id);
 
@@ -372,9 +368,13 @@ export class ObjectId extends BSONValue {
     return new ObjectId(doc.$oid);
   }
 
-  /** @internal */
+  /**
+   * @internal
+   *
+   * used for testing
+   */
   private isCached(): boolean {
-    return ObjectId.cacheHexString && __idCache.has(this);
+    return ObjectId.cacheHexString && this.#cachedHexString != null;
   }
 
   /**

package/src/timestamp.ts

@@ -1,10 +1,16 @@
+import { bsonType } from './bson_value';
 import { BSONError } from './error';
 import type { Int32 } from './int_32';
 import { Long } from './long';
 import { type InspectFn, defaultInspect } from './parser/utils';
 
 /** @public */
-export type TimestampOverrides = '_bsontype' | 'toExtendedJSON' | 'fromExtendedJSON' | 'inspect';
+export type TimestampOverrides =
+  | '_bsontype'
+  | 'toExtendedJSON'
+  | 'fromExtendedJSON'
+  | 'inspect'
+  | typeof bsonType;
 /** @public */
 export type LongWithoutOverrides = new (
   low: unknown,
@@ -35,6 +41,9 @@ export class Timestamp extends LongWithoutOverridesClass {
   get _bsontype(): 'Timestamp' {
     return 'Timestamp';
   }
+  get [bsonType](): 'Timestamp' {
+    return 'Timestamp';
+  }
 
   static readonly MAX_VALUE = Long.MAX_UNSIGNED_VALUE;
 

package/src/utils/node_byte_utils.ts

@@ -17,7 +17,7 @@ type NodeJsBufferConstructor = Omit<Uint8ArrayConstructor, 'from'> & {
   from(array: number[]): NodeJsBuffer;
   from(array: Uint8Array): NodeJsBuffer;
   from(array: ArrayBuffer): NodeJsBuffer;
-  from(array: ArrayBuffer, byteOffset: number, byteLength: number): NodeJsBuffer;
+  from(array: ArrayBufferLike, byteOffset: number, byteLength: number): NodeJsBuffer;
   from(base64: string, encoding: NodeJsEncoding): NodeJsBuffer;
   byteLength(input: string, encoding: 'utf8'): number;
   isBuffer(value: unknown): value is NodeJsBuffer;
@@ -26,34 +26,27 @@ type NodeJsBufferConstructor = Omit<Uint8ArrayConstructor, 'from'> & {
 // This can be nullish, but we gate the nodejs functions on being exported whether or not this exists
 // Node.js global
 declare const Buffer: NodeJsBufferConstructor;
-declare const require: (mod: 'crypto') => { randomBytes: (byteLength: number) => Uint8Array };
 
 /** @internal */
-export function nodejsMathRandomBytes(byteLength: number) {
+function nodejsMathRandomBytes(byteLength: number): NodeJsBuffer {
   return nodeJsByteUtils.fromNumberArray(
     Array.from({ length: byteLength }, () => Math.floor(Math.random() * 256))
   );
 }
 
-/**
- * @internal
- * WARNING: REQUIRE WILL BE REWRITTEN
- *
- * This code is carefully used by require_rewriter.mjs any modifications must be reflected in the plugin.
- *
- * @remarks
- * "crypto" is the only dependency BSON needs. This presents a problem for creating a bundle of the BSON library
- * in an es module format that can be used both on the browser and in Node.js. In Node.js when BSON is imported as
- * an es module, there will be no global require function defined, making the code below fallback to the much less desireable math.random bytes.
- * In order to make our es module bundle work as expected on Node.js we need to change this `require()` to a dynamic import, and the dynamic
- * import must be top-level awaited since es modules are async. So we rely on a custom rollup plugin to seek out the following lines of code
- * and replace `require` with `await import` and the IIFE line (`nodejsRandomBytes = (() => { ... })()`) with `nodejsRandomBytes = await (async () => { ... })()`
- * when generating an es module bundle.
- */
-const nodejsRandomBytes: (byteLength: number) => Uint8Array = (() => {
-  try {
-    return require('crypto').randomBytes;
-  } catch {
+/** @internal */
+function nodejsSecureRandomBytes(byteLength: number): NodeJsBuffer {
+  // @ts-expect-error: crypto.getRandomValues cannot actually be null here
+  return crypto.getRandomValues(nodeJsByteUtils.allocate(byteLength));
+}
+
+const nodejsRandomBytes = (() => {
+  const { crypto } = globalThis as {
+    crypto?: { getRandomValues?: (space: Uint8Array) => Uint8Array };
+  };
+  if (crypto != null && typeof crypto.getRandomValues === 'function') {
+    return nodejsSecureRandomBytes;
+  } else {
     return nodejsMathRandomBytes;
   }
 })();

package/src/utils/number_utils.ts

@@ -83,7 +83,6 @@ export const NumberUtils: NumberUtils = {
 
   /** Reads a little-endian 64-bit integer from source */
   getBigInt64LE(source: Uint8Array, offset: number): bigint {
-    // eslint-disable-next-line no-restricted-globals
     const hi = BigInt(
       source[offset + 4] +
         source[offset + 5] * 256 +
@@ -91,15 +90,14 @@ export const NumberUtils: NumberUtils = {
         (source[offset + 7] << 24)
     ); // Overflow
 
-    // eslint-disable-next-line no-restricted-globals
     const lo = BigInt(
       source[offset] +
         source[offset + 1] * 256 +
         source[offset + 2] * 65536 +
         source[offset + 3] * 16777216
     );
-    // eslint-disable-next-line no-restricted-globals
-    return (hi << BigInt(32)) + lo;
+
+    return (hi << 32n) + lo;
   },
 
   /** Reads a little-endian 64-bit float from source */
@@ -153,8 +151,7 @@ export const NumberUtils: NumberUtils = {
 
   /** Write a little-endian 64-bit integer to source */
   setBigInt64LE(destination: Uint8Array, offset: number, value: bigint): 8 {
-    /* eslint-disable-next-line no-restricted-globals -- This is allowed here as useBigInt64=true */
-    const mask32bits = BigInt(0xffff_ffff);
+    const mask32bits = 0xffff_ffffn;
 
     /** lower 32 bits */
     let lo = Number(value & mask32bits);
@@ -166,13 +163,7 @@ export const NumberUtils: NumberUtils = {
     lo >>= 8;
     destination[offset + 3] = lo;
 
-    /*
-       eslint-disable-next-line no-restricted-globals
-       -- This is allowed here as useBigInt64=true
-
-       upper 32 bits
-     */
-    let hi = Number((value >> BigInt(32)) & mask32bits);
+    let hi = Number((value >> 32n) & mask32bits);
     destination[offset + 4] = hi;
     hi >>= 8;
     destination[offset + 5] = hi;

package/vendor/base64/LICENSE-MIT.txt

@@ -1,20 +0,0 @@
-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.

package/vendor/base64/README.md

@@ -1,112 +0,0 @@
-# base64 [![Build status](https://travis-ci.org/mathiasbynens/base64.svg?branch=master)](https://travis-ci.org/mathiasbynens/base64) [![Code coverage status](http://img.shields.io/coveralls/mathiasbynens/base64/master.svg)](https://coveralls.io/r/mathiasbynens/base64)
-
-_base64_ is a robust base64 encoder/decoder that is fully compatible with [`atob()` and `btoa()`](https://html.spec.whatwg.org/multipage/webappapis.html#atob), written in JavaScript. The base64-encoding and -decoding algorithms it uses are fully [RFC 4648](https://tools.ietf.org/html/rfc4648#section-4) compliant.
-
-## Installation
-
-Via [npm](https://www.npmjs.com/):
-
-```bash
-npm install base-64
-```
-
-In a browser:
-
-```html
-<script src="base64.js"></script>
-```
-
-In [Narwhal](http://narwhaljs.org/), [Node.js](https://nodejs.org/), and [RingoJS](http://ringojs.org/):
-
-```js
-var base64 = require('base-64');
-```
-
-In [Rhino](http://www.mozilla.org/rhino/):
-
-```js
-load('base64.js');
-```
-
-Using an AMD loader like [RequireJS](http://requirejs.org/):
-
-```js
-require(
-  {
-    'paths': {
-      'base64': 'path/to/base64'
-    }
-  },
-  ['base64'],
-  function(base64) {
-    console.log(base64);
-  }
-);
-```
-
-## API
-
-### `base64.version`
-
-A string representing the semantic version number.
-
-### `base64.encode(input)`
-
-This function takes a byte string (the `input` parameter) and encodes it according to base64. The input data must be in the form of a string containing only characters in the range from U+0000 to U+00FF, each representing a binary byte with values `0x00` to `0xFF`. The `base64.encode()` function is designed to be fully compatible with [`btoa()` as described in the HTML Standard](https://html.spec.whatwg.org/multipage/webappapis.html#dom-windowbase64-btoa).
-
-```js
-var encodedData = base64.encode(input);
-```
-
-To base64-encode any Unicode string, [encode it as UTF-8 first](https://github.com/mathiasbynens/utf8.js#utf8encodestring):
-
-```js
-var base64 = require('base-64');
-var utf8 = require('utf8');
-
-var text = 'foo © bar 𝌆 baz';
-var bytes = utf8.encode(text);
-var encoded = base64.encode(bytes);
-console.log(encoded);
-// → 'Zm9vIMKpIGJhciDwnYyGIGJheg=='
-```
-
-### `base64.decode(input)`
-
-This function takes a base64-encoded string (the `input` parameter) and decodes it. The return value is in the form of a string containing only characters in the range from U+0000 to U+00FF, each representing a binary byte with values `0x00` to `0xFF`. The `base64.decode()` function is designed to be fully compatible with [`atob()` as described in the HTML Standard](https://html.spec.whatwg.org/multipage/webappapis.html#dom-windowbase64-atob).
-
-```js
-var decodedData = base64.decode(encodedData);
-```
-
-To base64-decode UTF-8-encoded data back into a Unicode string, [UTF-8-decode it](https://github.com/mathiasbynens/utf8.js#utf8decodebytestring) after base64-decoding it:
-
-```js
-var encoded = 'Zm9vIMKpIGJhciDwnYyGIGJheg==';
-var bytes = base64.decode(encoded);
-var text = utf8.decode(bytes);
-console.log(text);
-// → 'foo © bar 𝌆 baz'
-```
-
-## Support
-
-_base64_ is designed to work in at least Node.js v0.10.0, Narwhal 0.3.2, RingoJS 0.8-0.9, PhantomJS 1.9.0, Rhino 1.7RC4, as well as old and modern versions of Chrome, Firefox, Safari, Opera, and Internet Explorer.
-
-## Unit tests & code coverage
-
-After cloning this repository, run `npm install` to install the dependencies needed for development and testing. You may want to install Istanbul _globally_ using `npm install istanbul -g`.
-
-Once that’s done, you can run the unit tests in Node using `npm test` or `node tests/tests.js`. To run the tests in Rhino, Ringo, Narwhal, and web browsers as well, use `grunt test`.
-
-To generate the code coverage report, use `grunt cover`.
-
-## Author
-
-| [![twitter/mathias](https://gravatar.com/avatar/24e08a9ea84deb17ae121074d0f17125?s=70)](https://twitter.com/mathias "Follow @mathias on Twitter") |
-|---|
-| [Mathias Bynens](https://mathiasbynens.be/) |
-
-## License
-
-_base64_ is available under the [MIT](https://mths.be/mit) license.