@exodus/bytes 1.8.0 → 1.10.0

package/array.d.ts

@@ -1,24 +1,61 @@
+/**
+ * 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;
 export function typedView(arr: ArrayBufferView, format: 'buffer'): Buffer;
 export function typedView(arr: ArrayBufferView, format: OutputFormat): Uint8Array | Buffer;
-

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/base58.js

@@ -207,7 +207,7 @@ function fromBase58core(str, alphabet, codes, format = 'uint8') {
       }
 
       at = k + 1
-      if (c !== 0 || at < zeros) throw new Error('Unexpected') // unreachable
+      if (c !== 0 || at < zeros) /* c8 ignore next */ throw new Error('Unexpected') // unreachable
     }
   }
 

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

@@ -1,11 +1,11 @@
-import { hashSync } from '@exodus/crypto/hash' // eslint-disable-line @exodus/import/no-deprecated
+import { sha256 } from '@noble/hashes/sha2.js'
 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
-const sha256 = (x) => hashSync('sha256', x, 'uint8')
+// 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,48 +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.browser.js

@@ -0,0 +1,29 @@
+import {
+  fromSource,
+  getBOMEncoding,
+  normalizeEncoding,
+  E_ENCODING,
+} from './fallback/encoding.api.js'
+import labels from './fallback/encoding.labels.js'
+
+// Lite-weight version which re-exports existing implementations on browsers,
+// while still being aliased to the full impl in RN and Node.js
+
+// WARNING: Note that browsers have bugs (which hopefully will get fixed soon)
+
+const { TextDecoder, TextEncoder, TextDecoderStream, TextEncoderStream } = globalThis
+
+export { normalizeEncoding, getBOMEncoding, labelToName } from './fallback/encoding.api.js'
+export { TextDecoder, TextEncoder, TextDecoderStream, TextEncoderStream }
+
+// https://encoding.spec.whatwg.org/#decode
+export function legacyHookDecode(input, fallbackEncoding = 'utf-8') {
+  let u8 = fromSource(input)
+  const bomEncoding = getBOMEncoding(u8)
+  if (bomEncoding) u8 = u8.subarray(bomEncoding === 'utf-8' ? 3 : 2)
+  const enc = bomEncoding ?? normalizeEncoding(fallbackEncoding) // "the byte order mark is more authoritative than anything else"
+  if (enc === 'utf-8') return new TextDecoder('utf-8', { ignoreBOM: true }).decode(u8) // fast path
+  if (enc === 'replacement') return u8.byteLength > 0 ? '\uFFFD' : ''
+  if (!Object.hasOwn(labels, enc)) throw new RangeError(E_ENCODING)
+  return new TextDecoder(enc, { ignoreBOM: true }).decode(u8)
+}

package/encoding-browser.d.ts

@@ -0,0 +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-browser.js

@@ -0,0 +1 @@
+export * from './encoding.js'

package/encoding-browser.native.js

@@ -0,0 +1 @@
+export * from './encoding.js'