@exodus/bytes 1.9.0 → 1.11.0

package/array.d.ts

@@ -1,21 +1,60 @@
+/**
+ * TypedArray utils and conversions.
+ *
+ * ```js
+ * import { typedView } from '@exodus/bytes/array.js'
+ * ```
+ *
+ * @module @exodus/bytes/array.js
+ */
+
 /// <reference types="node" />
 
 // >= TypeScript 5.9 made Uint8Array templated with <> and defaulted to ArrayBufferLike
 // which would incorrectly accept SharedArrayBuffer instances.
 // < TypeScript 5.7 doesn't support templates for Uint8Array.
 // So this type is defined as a workaround to evaluate to Uint8Array<ArrayBuffer> on all versions of TypeScript.
+
+/**
+ * This is `Uint8Array<ArrayBuffer>`
+ * (as opposed to `Uint8Array<SharedArrayBuffer>` and `Uint8Array<ArrayBufferLike>`)
+ * on TypeScript versions that support that distinction.
+ *
+ * On TypeScript < 5.7, this is just `Uint8Array`, as it's not a template there.
+ */
 export type Uint8ArrayBuffer = ReturnType<typeof Uint8Array.from>;
 
+/**
+ * This is `Uint16Array<ArrayBuffer>`
+ * (as opposed to `Uint16Array<SharedArrayBuffer>` and `Uint16Array<ArrayBufferLike>`)
+ * on TypeScript versions that support that distinction.
+ *
+ * On TypeScript < 5.7, this is just `Uint16Array`, as it's not a template there.
+ */
+export type Uint16ArrayBuffer = ReturnType<typeof Uint16Array.from>;
+
+/**
+ * This is `Uint32Array<ArrayBuffer>`
+ * (as opposed to `Uint32Array<SharedArrayBuffer>` and `Uint32Array<ArrayBufferLike>`)
+ * on TypeScript versions that support that distinction.
+ *
+ * On TypeScript < 5.7, this is just `Uint32Array`, as it's not a template there.
+ */
+export type Uint32ArrayBuffer = ReturnType<typeof Uint32Array.from>;
+
 /**
  * Output format for typed array conversions
  */
 export type OutputFormat = 'uint8' | 'buffer';
 
 /**
- * Creates a view of a TypedArray in the specified format
- * Note: This does not copy data - returns a view on the same underlying buffer
+ * Create a view of a TypedArray in the specified format (`'uint8'` or `'buffer'`)
+ *
+ * > [!IMPORTANT]
+ * > Does not copy data, returns a view on the same underlying buffer
+ *
  * @param arr - The input TypedArray
- * @param format - The desired output format ('uint8' or 'buffer')
+ * @param format - The desired output format (`'uint8'` or `'buffer'`)
  * @returns A view on the same underlying buffer
  */
 export function typedView(arr: ArrayBufferView, format: 'uint8'): Uint8Array;

package/base32.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Implements base32 and base32hex from [RFC4648](https://datatracker.ietf.org/doc/html/rfc4648)
+ * (no differences from [RFC3548](https://datatracker.ietf.org/doc/html/rfc4648)).
+ *
+ * ```js
+ * import { fromBase32, toBase32 } from '@exodus/bytes/base32.js'
+ * import { fromBase32hex, toBase32hex } from '@exodus/bytes/base32.js'
+ * ```
+ *
+ * @module @exodus/bytes/base32.js
+ */
+
+/// <reference types="node" />
+
+import type { OutputFormat, Uint8ArrayBuffer } from './array.js';
+
+/**
+ * Options for base32 encoding
+ */
+export interface ToBase32Options {
+  /** Whether to include padding characters (default: false) */
+  padding?: boolean;
+}
+
+/**
+ * Padding mode for base32 decoding
+ * - `true`: padding is required
+ * - `false`: padding is not allowed
+ * - `'both'`: padding is optional (default)
+ */
+export type PaddingMode = boolean | 'both';
+
+/**
+ * Options for base32 decoding
+ */
+export interface FromBase32Options {
+  /** Output format (default: 'uint8') */
+  format?: OutputFormat;
+  /** Padding mode */
+  padding?: PaddingMode;
+}
+
+/**
+ * Encode a `Uint8Array` to a base32 string (RFC 4648)
+ *
+ * @param arr - The input bytes
+ * @param options - Encoding options
+ * @returns The base32 encoded string
+ */
+export function toBase32(arr: Uint8Array, options?: ToBase32Options): string;
+
+/**
+ * Encode a `Uint8Array` to a base32hex string (RFC 4648)
+ *
+ * @param arr - The input bytes
+ * @param options - Encoding options (padding defaults to false)
+ * @returns The base32hex encoded string
+ */
+export function toBase32hex(arr: Uint8Array, options?: ToBase32Options): string;
+
+/**
+ * Decode a base32 string to bytes
+ *
+ * Operates in strict mode for last chunk, does not allow whitespace
+ *
+ * @param string - The base32 encoded string
+ * @param options - Decoding options
+ * @returns The decoded bytes
+ */
+export function fromBase32(string: string, options?: FromBase32Options): Uint8ArrayBuffer;
+export function fromBase32(string: string, options: FromBase32Options & { format: 'buffer' }): Buffer;
+
+/**
+ * Decode a base32hex string to bytes
+ *
+ * Operates in strict mode for last chunk, does not allow whitespace
+ *
+ * @param string - The base32hex encoded string
+ * @param options - Decoding options
+ * @returns The decoded bytes
+ */
+export function fromBase32hex(string: string, options?: FromBase32Options): Uint8ArrayBuffer;
+export function fromBase32hex(string: string, options: FromBase32Options & { format: 'buffer' }): Buffer;

package/base58.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Implements [base58](https://www.ietf.org/archive/id/draft-msporny-base58-03.txt) encoding.
+ *
+ * Supports both standard base58 and XRP variant alphabets.
+ *
+ * ```js
+ * import { fromBase58, toBase58 } from '@exodus/bytes/base58.js'
+ * import { fromBase58xrp, toBase58xrp } from '@exodus/bytes/base58.js'
+ * ```
+ *
+ * @module @exodus/bytes/base58.js
+ */
+
+/// <reference types="node" />
+
+import type { OutputFormat, Uint8ArrayBuffer } from './array.js';
+
+/**
+ * Encode a `Uint8Array` to a base58 string
+ *
+ * Uses the standard Bitcoin base58 alphabet
+ *
+ * @param arr - The input bytes
+ * @returns The base58 encoded string
+ */
+export function toBase58(arr: Uint8Array): string;
+
+/**
+ * Decode a base58 string to bytes
+ *
+ * Uses the standard Bitcoin base58 alphabet
+ *
+ * @param string - The base58 encoded string
+ * @param format - Output format (default: 'uint8')
+ * @returns The decoded bytes
+ */
+export function fromBase58(string: string, format?: 'uint8'): Uint8ArrayBuffer;
+export function fromBase58(string: string, format: 'buffer'): Buffer;
+export function fromBase58(string: string, format?: OutputFormat): Uint8ArrayBuffer | Buffer;
+
+/**
+ * Encode a `Uint8Array` to a base58 string using XRP alphabet
+ *
+ * Uses the XRP variant base58 alphabet
+ *
+ * @param arr - The input bytes
+ * @returns The base58 encoded string
+ */
+export function toBase58xrp(arr: Uint8Array): string;
+
+/**
+ * Decode a base58 string to bytes using XRP alphabet
+ *
+ * Uses the XRP variant base58 alphabet
+ *
+ * @param string - The base58 encoded string
+ * @param format - Output format (default: 'uint8')
+ * @returns The decoded bytes
+ */
+export function fromBase58xrp(string: string, format?: 'uint8'): Uint8ArrayBuffer;
+export function fromBase58xrp(string: string, format: 'buffer'): Buffer;
+export function fromBase58xrp(string: string, format?: OutputFormat): Uint8ArrayBuffer | Buffer;

package/base58check.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Implements [base58check](https://en.bitcoin.it/wiki/Base58Check_encoding) encoding.
+ *
+ * ```js
+ * import { fromBase58check, toBase58check } from '@exodus/bytes/base58check.js'
+ * import { fromBase58checkSync, toBase58checkSync } from '@exodus/bytes/base58check.js'
+ * import { makeBase58check } from '@exodus/bytes/base58check.js'
+ * ```
+ *
+ * On non-Node.js, requires peer dependency [@noble/hashes](https://www.npmjs.com/package/@noble/hashes) to be installed.
+ *
+ * @module @exodus/bytes/base58check.js
+ */
+
+/// <reference types="node" />
+
+import type { OutputFormat, Uint8ArrayBuffer } from './array.js';
+
+/**
+ * Hash function type that takes Uint8Array and returns a Promise of Uint8Array
+ */
+export type HashFunction = (data: Uint8Array) => Promise<Uint8Array>;
+
+/**
+ * Synchronous hash function type that takes Uint8Array and returns Uint8Array
+ */
+export type HashFunctionSync = (data: Uint8Array) => Uint8Array;
+
+/**
+ * Base58Check encoder/decoder instance with async methods
+ */
+export interface Base58CheckAsync {
+  /**
+   * Encode bytes to base58check string asynchronously
+   *
+   * @param arr - The input bytes to encode
+   * @returns A Promise that resolves to the base58check encoded string
+   */
+  encode(arr: Uint8Array): Promise<string>;
+
+  /**
+   * Decode a base58check string to bytes asynchronously
+   *
+   * @param string - The base58check encoded string
+   * @param format - Output format (default: 'uint8')
+   * @returns A Promise that resolves to the decoded bytes
+   */
+  decode(string: string, format?: 'uint8'): Promise<Uint8ArrayBuffer>;
+  decode(string: string, format: 'buffer'): Promise<Buffer>;
+  decode(string: string, format?: OutputFormat): Promise<Uint8ArrayBuffer | Buffer>;
+}
+
+/**
+ * Base58Check encoder/decoder instance with both async and sync methods
+ */
+export interface Base58CheckSync extends Base58CheckAsync {
+  /**
+   * Encode bytes to base58check string synchronously
+   *
+   * @param arr - The input bytes to encode
+   * @returns The base58check encoded string
+   */
+  encodeSync(arr: Uint8Array): string;
+
+  /**
+   * Decode a base58check string to bytes synchronously
+   *
+   * @param string - The base58check encoded string
+   * @param format - Output format (default: 'uint8')
+   * @returns The decoded bytes
+   */
+  decodeSync(string: string, format?: 'uint8'): Uint8ArrayBuffer;
+  decodeSync(string: string, format: 'buffer'): Buffer;
+  decodeSync(string: string, format?: OutputFormat): Uint8ArrayBuffer | Buffer;
+}
+
+/**
+ * Create a base58check encoder/decoder with custom hash functions
+ *
+ * @param hashAlgo - Async hash function (typically double SHA-256)
+ * @param hashAlgoSync - Optional sync hash function
+ * @returns Base58Check encoder/decoder instance
+ */
+export function makeBase58check(hashAlgo: HashFunction, hashAlgoSync?: HashFunctionSync): Base58CheckSync;
+export function makeBase58check(hashAlgo: HashFunction): Base58CheckAsync;
+
+/**
+ * Encode bytes to base58check string asynchronously
+ *
+ * Uses double SHA-256 for checksum calculation
+ *
+ * @param arr - The input bytes to encode
+ * @returns A Promise that resolves to the base58check encoded string
+ */
+export function toBase58check(arr: Uint8Array): Promise<string>;
+
+/**
+ * Decode a base58check string to bytes asynchronously
+ *
+ * Validates the checksum using double SHA-256
+ *
+ * @param string - The base58check encoded string
+ * @param format - Output format (default: 'uint8')
+ * @returns A Promise that resolves to the decoded bytes
+ */
+export function fromBase58check(string: string, format?: 'uint8'): Promise<Uint8ArrayBuffer>;
+export function fromBase58check(string: string, format: 'buffer'): Promise<Buffer>;
+export function fromBase58check(string: string, format?: OutputFormat): Promise<Uint8ArrayBuffer | Buffer>;
+
+/**
+ * Encode bytes to base58check string synchronously
+ *
+ * Uses double SHA-256 for checksum calculation
+ *
+ * @param arr - The input bytes to encode
+ * @returns The base58check encoded string
+ */
+export function toBase58checkSync(arr: Uint8Array): string;
+
+/**
+ * Decode a base58check string to bytes synchronously
+ *
+ * Validates the checksum using double SHA-256
+ *
+ * @param string - The base58check encoded string
+ * @param format - Output format (default: 'uint8')
+ * @returns The decoded bytes
+ */
+export function fromBase58checkSync(string: string, format?: 'uint8'): Uint8ArrayBuffer;
+export function fromBase58checkSync(string: string, format: 'buffer'): Buffer;
+export function fromBase58checkSync(string: string, format?: OutputFormat): Uint8ArrayBuffer | Buffer;

package/base58check.js

@@ -4,7 +4,8 @@ import { makeBase58check } from './fallback/base58check.js'
 // Note: while API is async, we use hashSync for now until we improve webcrypto perf for hash256
 // Inputs to base58 are typically very small, and that makes a difference
 
-// eslint-disable-next-line @exodus/import/no-deprecated
+// Note: using native WebCrypto will have to have account for SharedArrayBuffer
+
 const hash256sync = (x) => sha256(sha256(x))
 const hash256 = hash256sync // See note at the top
 const {

package/base64.d.ts

@@ -1,3 +1,16 @@
+/**
+ * Implements base64 and base64url from [RFC4648](https://datatracker.ietf.org/doc/html/rfc4648)
+ * (no differences from [RFC3548](https://datatracker.ietf.org/doc/html/rfc4648)).
+ *
+ * ```js
+ * import { fromBase64, toBase64 } from '@exodus/bytes/base64.js'
+ * import { fromBase64url, toBase64url } from '@exodus/bytes/base64.js'
+ * import { fromBase64any } from '@exodus/bytes/base64.js'
+ * ```
+ *
+ * @module @exodus/bytes/base64.js
+ */
+
 /// <reference types="node" />
 
 import type { OutputFormat, Uint8ArrayBuffer } from './array.js';
@@ -12,9 +25,9 @@ export interface ToBase64Options {
 
 /**
  * Padding mode for base64 decoding
- * - true: padding is required
- * - false: padding is not allowed
- * - 'both': padding is optional (default for base64)
+ * - `true`: padding is required
+ * - `false`: padding is not allowed (default for base64url)
+ * - `'both'`: padding is optional (default for base64)
  */
 export type PaddingMode = boolean | 'both';
 
@@ -29,47 +42,55 @@ export interface FromBase64Options {
 }
 
 /**
- * Encodes a Uint8Array to a base64 string (RFC 4648)
+ * Encode a `Uint8Array` to a base64 string (RFC 4648)
+ *
  * @param arr - The input bytes
  * @param options - Encoding options
  * @returns The base64 encoded string
  */
-export function toBase64(arr: Uint8ArrayBuffer, options?: ToBase64Options): string;
+export function toBase64(arr: Uint8Array, options?: ToBase64Options): string;
 
 /**
- * Encodes a Uint8Array to a base64url string (RFC 4648)
+ * Encode a `Uint8Array` to a base64url string (RFC 4648)
+ *
  * @param arr - The input bytes
  * @param options - Encoding options (padding defaults to false)
  * @returns The base64url encoded string
  */
-export function toBase64url(arr: Uint8ArrayBuffer, options?: ToBase64Options): string;
+export function toBase64url(arr: Uint8Array, options?: ToBase64Options): string;
 
 /**
- * Decodes a base64 string to bytes
+ * Decode a base64 string to bytes
+ *
  * Operates in strict mode for last chunk, does not allow whitespace
- * @param str - The base64 encoded string
+ *
+ * @param string - The base64 encoded string
  * @param options - Decoding options
  * @returns The decoded bytes
  */
-export function fromBase64(str: string, options?: FromBase64Options): Uint8ArrayBuffer;
-export function fromBase64(str: string, options: FromBase64Options & { format: 'buffer' }): Buffer;
+export function fromBase64(string: string, options?: FromBase64Options): Uint8ArrayBuffer;
+export function fromBase64(string: string, options: FromBase64Options & { format: 'buffer' }): Buffer;
 
 /**
- * Decodes a base64url string to bytes
+ * Decode a base64url string to bytes
+ *
  * Operates in strict mode for last chunk, does not allow whitespace
- * @param str - The base64url encoded string
+ *
+ * @param string - The base64url encoded string
  * @param options - Decoding options (padding defaults to false)
  * @returns The decoded bytes
  */
-export function fromBase64url(str: string, options?: FromBase64Options): Uint8ArrayBuffer;
-export function fromBase64url(str: string, options: FromBase64Options & { format: 'buffer' }): Buffer;
+export function fromBase64url(string: string, options?: FromBase64Options): Uint8ArrayBuffer;
+export function fromBase64url(string: string, options: FromBase64Options & { format: 'buffer' }): Buffer;
 
 /**
- * Decodes either base64 or base64url string to bytes
+ * Decode either base64 or base64url string to bytes
+ *
  * Automatically detects the variant based on characters present
- * @param str - The base64 or base64url encoded string
+ *
+ * @param string - The base64 or base64url encoded string
  * @param options - Decoding options
  * @returns The decoded bytes
  */
-export function fromBase64any(str: string, options?: FromBase64Options): Uint8ArrayBuffer;
-export function fromBase64any(str: string, options: FromBase64Options & { format: 'buffer' }): Buffer;
+export function fromBase64any(string: string, options?: FromBase64Options): Uint8ArrayBuffer;
+export function fromBase64any(string: string, options: FromBase64Options & { format: 'buffer' }): Buffer;

package/bech32.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Implements bech32 and bech32m from
+ * [BIP-0173](https://github.com/bitcoin/bips/blob/master/bip-0173.mediawiki#specification)
+ * and [BIP-0350](https://github.com/bitcoin/bips/blob/master/bip-0350.mediawiki#specification).
+ *
+ * ```js
+ * import { fromBech32, toBech32 } from '@exodus/bytes/bech32.js'
+ * import { fromBech32m, toBech32m } from '@exodus/bytes/bech32.js'
+ * import { getPrefix } from '@exodus/bytes/bech32.js'
+ * ```
+ *
+ * @module @exodus/bytes/bech32.js
+ */
+
+/// <reference types="node" />
+
+import type { Uint8ArrayBuffer } from './array.js';
+
+/**
+ * Result of decoding a bech32 or bech32m string
+ */
+export interface Bech32DecodeResult {
+  /** The human-readable prefix */
+  prefix: string;
+  /** The decoded bytes */
+  bytes: Uint8ArrayBuffer;
+}
+
+/**
+ * Encode bytes to a bech32 string
+ *
+ * @param prefix - The human-readable prefix (e.g., 'bc' for Bitcoin)
+ * @param bytes - The input bytes to encode
+ * @param limit - Maximum length of the encoded string (default: 90)
+ * @returns The bech32 encoded string
+ */
+export function toBech32(prefix: string, bytes: Uint8Array, limit?: number): string;
+
+/**
+ * Decode a bech32 string to bytes
+ *
+ * @param string - The bech32 encoded string
+ * @param limit - Maximum length of the input string (default: 90)
+ * @returns The decoded prefix and bytes
+ */
+export function fromBech32(string: string, limit?: number): Bech32DecodeResult;
+
+/**
+ * Encode bytes to a bech32m string
+ *
+ * @param prefix - The human-readable prefix (e.g., 'bc' for Bitcoin)
+ * @param bytes - The input bytes to encode
+ * @param limit - Maximum length of the encoded string (default: 90)
+ * @returns The bech32m encoded string
+ */
+export function toBech32m(prefix: string, bytes: Uint8Array, limit?: number): string;
+
+/**
+ * Decode a bech32m string to bytes
+ *
+ * @param string - The bech32m encoded string
+ * @param limit - Maximum length of the input string (default: 90)
+ * @returns The decoded prefix and bytes
+ */
+export function fromBech32m(string: string, limit?: number): Bech32DecodeResult;
+
+/**
+ * Extract the prefix from a bech32 or bech32m string without full validation
+ *
+ * This is a quick check that skips most validation.
+ *
+ * @param string - The bech32/bech32m encoded string
+ * @param limit - Maximum length of the input string (default: 90)
+ * @returns The lowercase prefix
+ */
+export function getPrefix(string: string, limit?: number): string;

package/bigint.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Convert between BigInt and Uint8Array
+ *
+ * ```js
+ * import { fromBigInt, toBigInt } from '@exodus/bytes/bigint.js'
+ * ```
+ *
+ * @module @exodus/bytes/bigint.js
+ */
+
+/// <reference types="node" />
+
+import type { OutputFormat, Uint8ArrayBuffer } from './array.js';
+
+/**
+ * Options for converting BigInt to bytes
+ */
+export interface FromBigIntOptions {
+  /** The length in bytes of the output array */
+  length: number;
+  /** Output format (default: 'uint8') */
+  format?: OutputFormat;
+}
+
+/**
+ * Convert a BigInt to a Uint8Array or Buffer
+ *
+ * The output bytes are in big-endian format.
+ *
+ * Throws if the BigInt is negative or cannot fit into the specified length.
+ *
+ * @param bigint - The BigInt to convert (must be non-negative)
+ * @param options - Conversion options
+ * @returns The converted bytes in big-endian format
+ */
+export function fromBigInt(bigint: bigint, options: { length: number; format?: 'uint8' }): Uint8ArrayBuffer;
+export function fromBigInt(bigint: bigint, options: { length: number; format: 'buffer' }): Buffer;
+export function fromBigInt(bigint: bigint, options: FromBigIntOptions): Uint8ArrayBuffer | Buffer;
+
+/**
+ * Convert a Uint8Array or Buffer to a BigInt
+ *
+ * The bytes are interpreted as a big-endian unsigned integer.
+ *
+ * @param arr - The bytes to convert
+ * @returns The BigInt representation
+ */
+export function toBigInt(arr: Uint8Array): bigint;

package/encoding-browser.d.ts

@@ -1 +1,24 @@
+/**
+ * Same as `@exodus/bytes/encoding.js`, but in browsers instead of polyfilling just uses whatever the
+ * browser provides, drastically reducing the bundle size (to less than 2 KiB gzipped).
+ *
+ * ```js
+ * import { TextDecoder, TextEncoder } from '@exodus/bytes/encoding-browser.js'
+ * import { TextDecoderStream, TextEncoderStream } from '@exodus/bytes/encoding-browser.js' // Requires Streams
+ *
+ * // Hooks for standards
+ * import { getBOMEncoding, legacyHookDecode, labelToName, normalizeEncoding } from '@exodus/bytes/encoding-browser.js'
+ * ```
+ *
+ * Under non-browser engines (Node.js, React Native, etc.) a full polyfill is used as those platforms
+ * do not provide sufficiently complete / non-buggy `TextDecoder` APIs.
+ *
+ * > [!NOTE]
+ * > Implementations in browsers [have bugs](https://docs.google.com/spreadsheets/d/1pdEefRG6r9fZy61WHGz0TKSt8cO4ISWqlpBN5KntIvQ/edit),
+ * > but they are fixing them and the expected update window is short.\
+ * > If you want to circumvent browser bugs, use full `@exodus/bytes/encoding.js` import.
+ *
+ * @module @exodus/bytes/encoding-browser.js
+ */
+
 export * from './encoding.js'

package/encoding-lite.d.ts

@@ -1 +1,62 @@
+/**
+ * The exact same exports as `@exodus/bytes/encoding.js` are also exported as
+ * `@exodus/bytes/encoding-lite.js`, with the difference that the lite version does not load
+ * multi-byte `TextDecoder` encodings by default to reduce bundle size 10x.
+ *
+ * ```js
+ * import { TextDecoder, TextEncoder } from '@exodus/bytes/encoding-lite.js'
+ * import { TextDecoderStream, TextEncoderStream } from '@exodus/bytes/encoding-lite.js' // Requires Streams
+ *
+ * // Hooks for standards
+ * import { getBOMEncoding, legacyHookDecode, labelToName, normalizeEncoding } from '@exodus/bytes/encoding-lite.js'
+ * ```
+ *
+ * The only affected encodings are: `gbk`, `gb18030`, `big5`, `euc-jp`, `iso-2022-jp`, `shift_jis`
+ * and their [labels](https://encoding.spec.whatwg.org/#names-and-labels) when used with `TextDecoder`.
+ *
+ * Legacy single-byte encodingds are loaded by default in both cases.
+ *
+ * `TextEncoder` and hooks for standards (including `labelToName` / `normalizeEncoding`) do not have any behavior
+ * differences in the lite version and support full range if inputs.
+ *
+ * To avoid inconsistencies, the exported classes and methods are exactly the same objects.
+ *
+ * ```console
+ * > lite = require('@exodus/bytes/encoding-lite.js')
+ * [Module: null prototype] {
+ *   TextDecoder: [class TextDecoder],
+ *   TextDecoderStream: [class TextDecoderStream],
+ *   TextEncoder: [class TextEncoder],
+ *   TextEncoderStream: [class TextEncoderStream],
+ *   getBOMEncoding: [Function: getBOMEncoding],
+ *   labelToName: [Function: labelToName],
+ *   legacyHookDecode: [Function: legacyHookDecode],
+ *   normalizeEncoding: [Function: normalizeEncoding]
+ * }
+ * > new lite.TextDecoder('big5').decode(Uint8Array.of(0x25))
+ * Uncaught:
+ * Error: Legacy multi-byte encodings are disabled in /encoding-lite.js, use /encoding.js for full encodings range support
+ *
+ * > full = require('@exodus/bytes/encoding.js')
+ * [Module: null prototype] {
+ *   TextDecoder: [class TextDecoder],
+ *   TextDecoderStream: [class TextDecoderStream],
+ *   TextEncoder: [class TextEncoder],
+ *   TextEncoderStream: [class TextEncoderStream],
+ *   getBOMEncoding: [Function: getBOMEncoding],
+ *   labelToName: [Function: labelToName],
+ *   legacyHookDecode: [Function: legacyHookDecode],
+ *   normalizeEncoding: [Function: normalizeEncoding]
+ * }
+ * > full.TextDecoder === lite.TextDecoder
+ * true
+ * > new full.TextDecoder('big5').decode(Uint8Array.of(0x25))
+ * '%'
+ * > new lite.TextDecoder('big5').decode(Uint8Array.of(0x25))
+ * '%'
+ * ```
+ *
+ * @module @exodus/bytes/encoding-lite.js
+ */
+
 export * from './encoding.js'