@exodus/bytes 1.14.0 → 1.15.0

package/README.md

@@ -5,6 +5,7 @@
 [![](https://img.shields.io/npm/dm/@exodus/bytes?style=flat-square)](https://www.npmcharts.com/compare/@exodus/bytes?minimal=true)
 [![](https://img.shields.io/npm/l/@exodus/bytes?style=flat-square&color=blue)](https://github.com/ExodusOSS/bytes/blob/HEAD/LICENSE)
 [![](https://img.shields.io/github/check-runs/ExodusOSS/bytes/main?style=flat-square&logo=github)](https://github.com/ExodusOSS/bytes/actions/workflows/test.yml?query=branch%3Amain)
+[![](https://img.shields.io/badge/Documentation-3178c6?style=flat-square&logo=TypeScript&logoColor=fff)](https://exodusoss.github.io/bytes/)
 
 `Uint8Array` conversion to and from `base64`, `base32`, `base58`, `hex`, `utf8`, `utf16`, `bech32` and `wif`
 
@@ -63,7 +64,7 @@ Less than half the bundle size of [text-encoding](https://npmjs.com/text-encodin
 Also [much faster](#fast) than all of those.
 
 > [!TIP]
-> See also the [lite version](#lite-version) to get this down to 10 KiB gzipped.
+> See also the [lite version](#lite-version) to get this down to 8 KiB gzipped.
 
 Spec compliant, passing WPT and covered with extra tests.\
 Moreover, tests for this library uncovered [bugs in all major implementations](https://docs.google.com/spreadsheets/d/1pdEefRG6r9fZy61WHGz0TKSt8cO4ISWqlpBN5KntIvQ/edit).\
@@ -140,7 +141,7 @@ For non-browsers (Node.js, React Native), loads a full implementation.
 
 ## API
 
-### @exodus/bytes/utf8.js <sub>![](https://img.shields.io/bundlejs/size/@exodus/bytes/utf8.js?style=flat-square)<sub>
+### @exodus/bytes/utf8.js <sub>![](https://img.shields.io/bundlejs/size/@exodus/bytes/utf8.js?style=flat-square)</sub>
 
 UTF-8 encoding/decoding
 
@@ -206,7 +207,7 @@ Prefer using strict throwing methods for cryptography applications._
 This is similar to `new TextDecoder('utf-8', { ignoreBOM: true }).decode(arr)`,
 but works on all engines.
 
-### @exodus/bytes/utf16.js <sub>![](https://img.shields.io/bundlejs/size/@exodus/bytes/utf16.js?style=flat-square)<sub>
+### @exodus/bytes/utf16.js <sub>![](https://img.shields.io/bundlejs/size/@exodus/bytes/utf16.js?style=flat-square)</sub>
 
 UTF-16 encoding/decoding
 
@@ -256,169 +257,6 @@ Prefer using strict throwing methods for cryptography applications._
 
 Throws on non-even byte length.
 
-### @exodus/bytes/single-byte.js <sub>![](https://img.shields.io/bundlejs/size/@exodus/bytes/single-byte.js?style=flat-square)</sub>
-
-Decode / encode the legacy single-byte encodings according to the
-[Encoding standard](https://encoding.spec.whatwg.org/)
-([§9](https://encoding.spec.whatwg.org/#legacy-single-byte-encodings),
-[§14.5](https://encoding.spec.whatwg.org/#x-user-defined)),
-and [unicode.org](https://unicode.org/Public/MAPPINGS/ISO8859) `iso-8859-*` mappings.
-
-```js
-import { createSinglebyteDecoder, createSinglebyteEncoder } from '@exodus/bytes/single-byte.js'
-import { windows1252toString, windows1252fromString } from '@exodus/bytes/single-byte.js'
-import { latin1toString, latin1fromString } from '@exodus/bytes/single-byte.js'
-```
-
-> [!WARNING]
-> This is a lower-level API for single-byte encodings.
-> It might not match what you expect, as it supports both WHATWG and unicode.org encodings under
-> different names, with the main intended usecase for the latter being either non-web or legacy contexts.
->
-> For a safe WHATWG Encoding-compatible API, see `@exodus/bytes/encoding.js` import (and variants of it).
->
-> Be sure to know what you are doing and check documentation when directly using encodings from this file.
-
-Supports all single-byte encodings listed in the WHATWG Encoding standard:
-`ibm866`, `iso-8859-2`, `iso-8859-3`, `iso-8859-4`, `iso-8859-5`, `iso-8859-6`, `iso-8859-7`, `iso-8859-8`,
-`iso-8859-8-i`, `iso-8859-10`, `iso-8859-13`, `iso-8859-14`, `iso-8859-15`, `iso-8859-16`, `koi8-r`, `koi8-u`,
-`macintosh`, `windows-874`, `windows-1250`, `windows-1251`, `windows-1252`, `windows-1253`, `windows-1254`,
-`windows-1255`, `windows-1256`, `windows-1257`, `windows-1258`, `x-mac-cyrillic` and `x-user-defined`.
-
-Also supports `iso-8859-1`, `iso-8859-9`, `iso-8859-11` as defined at
-[unicode.org](https://unicode.org/Public/MAPPINGS/ISO8859)
-(and all other `iso-8859-*` encodings there as they match WHATWG).
-
-> [!NOTE]
-> While all `iso-8859-*` encodings supported by the [WHATWG Encoding standard](https://encoding.spec.whatwg.org/) match
-> [unicode.org](https://unicode.org/Public/MAPPINGS/ISO8859), the WHATWG Encoding spec doesn't support
-> `iso-8859-1`, `iso-8859-9`, `iso-8859-11`, and instead maps them as labels to `windows-1252`, `windows-1254`, `windows-874`.\
-> `createSinglebyteDecoder()` (unlike `TextDecoder` or `legacyHookDecode()`) does not do such mapping,
-> so its results will differ from `TextDecoder` for those encoding names.
-
-```js
-> new TextDecoder('iso-8859-1').encoding
-'windows-1252'
-> new TextDecoder('iso-8859-9').encoding
-'windows-1254'
-> new TextDecoder('iso-8859-11').encoding
-'windows-874'
-> new TextDecoder('iso-8859-9').decode(Uint8Array.of(0x80, 0x81, 0xd0))
-'€\x81Ğ' // this is actually decoded according to windows-1254 per TextDecoder spec
-> createSinglebyteDecoder('iso-8859-9')(Uint8Array.of(0x80, 0x81, 0xd0))
-'\x80\x81Ğ' // this is iso-8859-9 as defined at https://unicode.org/Public/MAPPINGS/ISO8859/8859-9.txt
-```
-
-All WHATWG Encoding spec [`windows-*` encodings](https://encoding.spec.whatwg.org/#windows-874) are supersets of
-corresponding [unicode.org encodings](https://unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/), meaning that
-they encode/decode all the old valid (non-replacement) strings / byte sequences identically, but can also support
-a wider range of inputs.
-
-#### `createSinglebyteDecoder(encoding, loose = false)`
-
-Create a decoder for a supported one-byte `encoding`, given its lowercased name `encoding`.
-
-Returns a function `decode(arr)` that decodes bytes to a string.
-
-#### `createSinglebyteEncoder(encoding, { mode = 'fatal' })`
-
-Create an encoder for a supported one-byte `encoding`, given its lowercased name `encoding`.
-
-Returns a function `encode(string)` that encodes a string to bytes.
-
-In `'fatal'` mode (default), will throw on non well-formed strings or any codepoints which could
-not be encoded in the target encoding.
-
-#### `latin1toString(arr)`
-
-Decode `iso-8859-1` bytes to a string.
-
-There is no loose variant for this encoding, all bytes can be decoded.
-
-Same as:
-```js
-const latin1toString = createSinglebyteDecoder('iso-8859-1')
-```
-
-> [!NOTE]
-> This is different from `new TextDecoder('iso-8859-1')` and `new TextDecoder('latin1')`, as those
-> alias to `new TextDecoder('windows-1252')`.
-
-#### `latin1fromString(string)`
-
-Encode a string to `iso-8859-1` bytes.
-
-Throws on non well-formed strings or any codepoints which could not be encoded in `iso-8859-1`.
-
-Same as:
-```js
-const latin1fromString = createSinglebyteEncoder('iso-8859-1', { mode: 'fatal' })
-```
-
-#### `windows1252toString(arr)`
-
-Decode `windows-1252` bytes to a string.
-
-There is no loose variant for this encoding, all bytes can be decoded.
-
-Same as:
-```js
-const windows1252toString = createSinglebyteDecoder('windows-1252')
-```
-
-#### `windows1252fromString(string)`
-
-Encode a string to `windows-1252` bytes.
-
-Throws on non well-formed strings or any codepoints which could not be encoded in `windows-1252`.
-
-Same as:
-```js
-const windows1252fromString = createSinglebyteEncoder('windows-1252', { mode: 'fatal' })
-```
-
-### @exodus/bytes/multi-byte.js <sub>![](https://img.shields.io/bundlejs/size/@exodus/bytes/multi-byte.js?style=flat-square)</sub>
-
-Decode / encode the legacy multi-byte encodings according to the
-[Encoding standard](https://encoding.spec.whatwg.org/)
-([§10](https://encoding.spec.whatwg.org/#legacy-multi-byte-chinese-(simplified)-encodings),
-[§11](https://encoding.spec.whatwg.org/#legacy-multi-byte-chinese-(traditional)-encodings),
-[§12](https://encoding.spec.whatwg.org/#legacy-multi-byte-japanese-encodings),
-[§13](https://encoding.spec.whatwg.org/#legacy-multi-byte-korean-encodings)).
-
-```js
-import { createMultibyteDecoder, createMultibyteEncoder } from '@exodus/bytes/multi-byte.js'
-```
-
-> [!WARNING]
-> This is a lower-level API for legacy multi-byte encodings.
->
-> For a safe WHATWG Encoding-compatible API, see `@exodus/bytes/encoding.js` import (and variants of it).
->
-> Be sure to know what you are doing and check documentation when directly using encodings from this file.
-
-Supports all legacy multi-byte encodings listed in the WHATWG Encoding standard:
-`gbk`, `gb18030`, `big5`, `euc-jp`, `iso-2022-jp`, `shift_jis`, `euc-kr`.
-
-#### `createMultibyteDecoder(encoding, loose = false)`
-
-Create a decoder for a supported legacy multi-byte `encoding`, given its lowercased name `encoding`.
-
-Returns a function `decode(arr, stream = false)` that decodes bytes to a string.
-
-The returned function will maintain internal state while `stream = true` is used, allowing it to
-handle incomplete multi-byte sequences across multiple calls.
-State is reset when `stream = false` or when the function is called without the `stream` parameter.
-
-#### `createMultibyteEncoder(encoding, { mode = 'fatal' })`
-
-Create an encoder for a supported legacy multi-byte `encoding`, given its lowercased name `encoding`.
-
-Returns a function `encode(string)` that encodes a string to bytes.
-
-In `'fatal'` mode (default), will throw on non well-formed strings or any codepoints which could
-not be encoded in the target encoding.
-
 ### @exodus/bytes/bigint.js <sub>![](https://img.shields.io/bundlejs/size/@exodus/bytes/bigint.js?style=flat-square)</sub>
 
 Convert between BigInt and Uint8Array
@@ -519,6 +357,14 @@ Decode a base32hex string to bytes
 
 Operates in strict mode for last chunk, does not allow whitespace
 
+#### `fromBase32crockford(string, options)`
+
+Decode a Crockford base32 string to bytes
+
+Operates in strict mode for last chunk, does not allow whitespace
+
+Crockford base32 decoding follows extra mapping per spec: `LIli -> 1, Oo -> 0`
+
 #### `toBase32(arr, { padding = false })`
 
 Encode a `Uint8Array` to a base32 string (RFC 4648)
@@ -527,6 +373,10 @@ Encode a `Uint8Array` to a base32 string (RFC 4648)
 
 Encode a `Uint8Array` to a base32hex string (RFC 4648)
 
+#### `toBase32crockford(arr, options)`
+
+Encode a `Uint8Array` to a Crockford base32 string
+
 ### @exodus/bytes/bech32.js <sub>![](https://img.shields.io/bundlejs/size/@exodus/bytes/bech32.js?style=flat-square)</sub>
 
 Implements bech32 and bech32m from
@@ -680,9 +530,24 @@ Encode WIF data to a WIF string (synchronous)
 TypedArray utils and conversions.
 
 ```js
-import { typedView } from '@exodus/bytes/array.js'
+import { typedCopyBytes, typedView } from '@exodus/bytes/array.js'
 ```
 
+#### `typedCopyBytes(arr, format = 'uint8')`
+
+Create a copy of TypedArray underlying bytes in the specified format (`'uint8'`, `'buffer'`, or `'arraybuffer'`)
+
+This does not copy _values_, but copies the underlying bytes.
+The result is similar to that of `typedView()`, but this function provides a copy, not a view of the same memory.
+
+> [!WARNING]
+> Copying underlying bytes from `Uint16Array` (or other with `BYTES_PER_ELEMENT > 1`)
+> is platform endianness-dependent.
+
+> [!NOTE]
+> Buffer might be pooled.
+> Uint8Array return values are not pooled and match their underlying ArrayBuffer.
+
 #### `typedView(arr, format = 'uint8')`
 
 Create a view of a TypedArray in the specified format (`'uint8'` or `'buffer'`)
@@ -690,6 +555,10 @@ 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
 
+> [!WARNING]
+> Viewing `Uint16Array` (or other with `BYTES_PER_ELEMENT > 1`) as bytes
+> is platform endianness-dependent.
+
 ### @exodus/bytes/encoding.js <sub>![](https://img.shields.io/bundlejs/size/@exodus/bytes/encoding.js?style=flat-square)</sub>
 
 Implements the [Encoding standard](https://encoding.spec.whatwg.org/):
@@ -702,6 +571,7 @@ some [hooks](https://encoding.spec.whatwg.org/#specification-hooks).
 ```js
 import { TextDecoder, TextEncoder } from '@exodus/bytes/encoding.js'
 import { TextDecoderStream, TextEncoderStream } from '@exodus/bytes/encoding.js' // Requires Streams
+import { isomorphicDecode, isomorphicEncode } from '@exodus/bytes/encoding.js'
 
 // Hooks for standards
 import { getBOMEncoding, legacyHookDecode, labelToName, normalizeEncoding } from '@exodus/bytes/encoding.js'
@@ -737,6 +607,26 @@ A [Streams](https://streams.spec.whatwg.org/) wrapper for `TextEncoder`.
 Requires [Streams](https://streams.spec.whatwg.org/) to be either supported by the platform or
 [polyfilled](https://npmjs.com/package/web-streams-polyfill).
 
+#### `isomorphicDecode(input)`
+
+Implements [isomorphic decode](https://infra.spec.whatwg.org/#isomorphic-decode).
+
+Given a `TypedArray` or an `ArrayBuffer` instance `input`, creates a string of the same length
+as input byteLength, using bytes from input as codepoints.
+
+E.g. for `Uint8Array` input, this is similar to `String.fromCodePoint(...input)`.
+
+Wider `TypedArray` inputs, e.g. `Uint16Array`, are interpreted as underlying _bytes_.
+
+#### `isomorphicEncode(str)`
+
+Implements [isomorphic encode](https://infra.spec.whatwg.org/#isomorphic-encode).
+
+Given a string, creates an `Uint8Array` of the same length with the string codepoints as byte values.
+
+Accepts only [isomorphic string](https://infra.spec.whatwg.org/#isomorphic-string) input
+and asserts that, throwing on any strings containing codepoints higher than `U+00FF`.
+
 #### `labelToName(label)`
 
 Implements [get an encoding from a string `label`](https://encoding.spec.whatwg.org/#concept-encoding-get).
@@ -810,6 +700,7 @@ multi-byte `TextDecoder` encodings by default to reduce bundle size ~12x.
 ```js
 import { TextDecoder, TextEncoder } from '@exodus/bytes/encoding-lite.js'
 import { TextDecoderStream, TextEncoderStream } from '@exodus/bytes/encoding-lite.js' // Requires Streams
+import { isomorphicDecode, isomorphicEncode } from '@exodus/bytes/encoding-lite.js'
 
 // Hooks for standards
 import { getBOMEncoding, legacyHookDecode, labelToName, normalizeEncoding } from '@exodus/bytes/encoding-lite.js'
@@ -860,11 +751,13 @@ true
 '%'
 ```
 
-### @exodus/bytes/encoding-browser.js <sub>![](https://img.shields.io/bundlejs/size/@exodus/bytes/encoding-browser.js?style=flat-square)<sub>
+### @exodus/bytes/encoding-browser.js <sub>![](https://img.shields.io/bundlejs/size/@exodus/bytes/encoding-browser.js?style=flat-square)</sub>
 
 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).
 
+Does not provide `isomorphicDecode` and `isomorphicEncode` exports.
+
 ```js
 import { TextDecoder, TextEncoder } from '@exodus/bytes/encoding-browser.js'
 import { TextDecoderStream, TextEncoderStream } from '@exodus/bytes/encoding-browser.js' // Requires Streams

package/array.d.ts

@@ -2,7 +2,7 @@
  * TypedArray utils and conversions.
  *
  * ```js
- * import { typedView } from '@exodus/bytes/array.js'
+ * import { typedCopyBytes, typedView } from '@exodus/bytes/array.js'
  * ```
  *
  * @module @exodus/bytes/array.js
@@ -45,7 +45,7 @@ export type Uint32ArrayBuffer = ReturnType<typeof Uint32Array.from>;
 /**
  * Output format for typed array conversions
  */
-export type OutputFormat = 'uint8' | 'buffer';
+export type OutputFormat = 'uint8' | 'arraybuffer' | 'buffer';
 
 /**
  * Create a view of a TypedArray in the specified format (`'uint8'` or `'buffer'`)
@@ -53,10 +53,37 @@ export type OutputFormat = 'uint8' | 'buffer';
  * > [!IMPORTANT]
  * > Does not copy data, returns a view on the same underlying buffer
  *
+ * > [!WARNING]
+ * > Viewing `Uint16Array` (or other with `BYTES_PER_ELEMENT > 1`) as bytes
+ * > is platform endianness-dependent.
+ *
  * @param arr - The input TypedArray
  * @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;
+export function typedView(arr: ArrayBufferView, format: 'uint8' | 'buffer'): Uint8Array | Buffer;
+
+/**
+ * Create a copy of TypedArray underlying bytes in the specified format (`'uint8'`, `'buffer'`, or `'arraybuffer'`)
+ *
+ * This does not copy _values_, but copies the underlying bytes.
+ * The result is similar to that of `typedView()`, but this function provides a copy, not a view of the same memory.
+ *
+ * > [!WARNING]
+ * > Copying underlying bytes from `Uint16Array` (or other with `BYTES_PER_ELEMENT > 1`)
+ * > is platform endianness-dependent.
+ *
+ * > [!NOTE]
+ * > Buffer might be pooled.
+ * > Uint8Array return values are not pooled and match their underlying ArrayBuffer.
+ *
+ * @param arr - The input TypedArray
+ * @param format - The desired output format (`'uint8'`, `'buffer'`, or `'arraybuffer'`)
+ * @returns A copy of the underlying buffer
+ */
+export function typedCopyBytes(arr: ArrayBufferView, format: 'uint8'): Uint8Array;
+export function typedCopyBytes(arr: ArrayBufferView, format: 'arraybuffer'): ArrayBuffer;
+export function typedCopyBytes(arr: ArrayBufferView, format: 'buffer'): Buffer;
+export function typedCopyBytes(arr: ArrayBufferView, format: OutputFormat): Uint8Array | ArrayBuffer | Buffer;

package/array.js

@@ -15,3 +15,21 @@ export function typedView(arr, format) {
 
   throw new TypeError('Unexpected format')
 }
+
+export function typedCopyBytes(arr, format) {
+  assertTypedArray(arr)
+  if (!(arr instanceof Uint8Array)) {
+    arr = new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength)
+  }
+
+  switch (format) {
+    case 'uint8':
+      return Uint8Array.from(arr) // never pooled
+    case 'buffer':
+      return Buffer.from(arr)
+    case 'arraybuffer':
+      return Uint8Array.from(arr).buffer
+  }
+
+  throw new TypeError('Unexpected format')
+}

package/base32.d.ts

@@ -58,6 +58,15 @@ export function toBase32(arr: Uint8Array, options?: ToBase32Options): string;
  */
 export function toBase32hex(arr: Uint8Array, options?: ToBase32Options): string;
 
+/**
+ * Encode a `Uint8Array` to a Crockford base32 string
+ *
+ * @param arr - The input bytes
+ * @param options - Encoding options (padding defaults to false)
+ * @returns The Crockford base32 encoded string
+ */
+export function toBase32crockford(arr: Uint8Array, options?: ToBase32Options): string;
+
 /**
  * Decode a base32 string to bytes
  *
@@ -67,8 +76,10 @@ export function toBase32hex(arr: Uint8Array, options?: ToBase32Options): 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?: 'uint8' }): Uint8ArrayBuffer;
+export function fromBase32(string: string, options: FromBase32Options & { format: 'arraybuffer' }): ArrayBuffer;
 export function fromBase32(string: string, options: FromBase32Options & { format: 'buffer' }): Buffer;
+export function fromBase32(string: string, options?: FromBase32Options): Uint8ArrayBuffer | ArrayBuffer | Buffer;
 
 /**
  * Decode a base32hex string to bytes
@@ -79,5 +90,23 @@ export function fromBase32(string: string, options: FromBase32Options & { format
  * @param options - Decoding options
  * @returns The decoded bytes
  */
-export function fromBase32hex(string: string, options?: FromBase32Options): Uint8ArrayBuffer;
+export function fromBase32hex(string: string, options?: FromBase32Options & { format?: 'uint8' }): Uint8ArrayBuffer;
+export function fromBase32hex(string: string, options: FromBase32Options & { format: 'arraybuffer' }): ArrayBuffer;
 export function fromBase32hex(string: string, options: FromBase32Options & { format: 'buffer' }): Buffer;
+export function fromBase32hex(string: string, options?: FromBase32Options): Uint8ArrayBuffer | ArrayBuffer | Buffer;
+
+/**
+ * Decode a Crockford base32 string to bytes
+ *
+ * Operates in strict mode for last chunk, does not allow whitespace
+ *
+ * Crockford base32 decoding follows extra mapping per spec: `LIli -> 1, Oo -> 0`
+ *
+ * @param string - The Crockford base32 encoded string
+ * @param options - Decoding options
+ * @returns The decoded bytes
+ */
+export function fromBase32crockford(string: string, options?: FromBase32Options & { format?: 'uint8' }): Uint8ArrayBuffer;
+export function fromBase32crockford(string: string, options: FromBase32Options & { format: 'arraybuffer' }): ArrayBuffer;
+export function fromBase32crockford(string: string, options: FromBase32Options & { format: 'buffer' }): Buffer;
+export function fromBase32crockford(string: string, options?: FromBase32Options): Uint8ArrayBuffer | ArrayBuffer | Buffer;

package/base32.js

@@ -1,29 +1,12 @@
 import { assertEmptyRest } from './assert.js'
-import { typedView } from './array.js'
-import { E_STRING } from './fallback/_utils.js'
+import { fromUint8, E_STRING } from './fallback/_utils.js'
 import * as js from './fallback/base32.js'
 
 // See https://datatracker.ietf.org/doc/html/rfc4648
 
 // 8 chars per 5 bytes
 
-export const toBase32 = (arr, { padding = false } = {}) => js.toBase32(arr, false, padding)
-export const toBase32hex = (arr, { padding = false } = {}) => js.toBase32(arr, true, padding)
-
-// By default, valid padding is accepted but not required
-export function fromBase32(str, options) {
-  if (!options) return fromBase32common(str, false, 'both', 'uint8', null)
-  const { format = 'uint8', padding = 'both', ...rest } = options
-  return fromBase32common(str, false, padding, format, rest)
-}
-
-export function fromBase32hex(str, options) {
-  if (!options) return fromBase32common(str, true, 'both', 'uint8', null)
-  const { format = 'uint8', padding = 'both', ...rest } = options
-  return fromBase32common(str, true, padding, format, rest)
-}
-
-function fromBase32common(str, isBase32Hex, padding, format, rest) {
+function fromBase32common(str, mode, padding, format, rest) {
   if (typeof str !== 'string') throw new TypeError(E_STRING)
   if (rest !== null) assertEmptyRest(rest)
 
@@ -35,5 +18,20 @@ function fromBase32common(str, isBase32Hex, padding, format, rest) {
     throw new TypeError('Invalid padding option')
   }
 
-  return typedView(js.fromBase32(str, isBase32Hex), format)
+  return fromUint8(js.fromBase32(str, mode), format)
 }
+
+// By default, valid padding is accepted but not required
+const fromBase32wrap = (mode) => (str, options) => {
+  if (!options) return fromBase32common(str, mode, 'both', 'uint8', null)
+  const { format = 'uint8', padding = 'both', ...rest } = options
+  return fromBase32common(str, mode, padding, format, rest)
+}
+
+export const fromBase32 = fromBase32wrap(0)
+export const fromBase32hex = fromBase32wrap(1)
+export const fromBase32crockford = fromBase32wrap(2)
+
+export const toBase32 = (arr, { padding = false } = {}) => js.toBase32(arr, 0, padding)
+export const toBase32hex = (arr, { padding = false } = {}) => js.toBase32(arr, 1, padding)
+export const toBase32crockford = (arr, { padding = false } = {}) => js.toBase32(arr, 2, padding)

package/base58.d.ts

@@ -35,8 +35,9 @@ export function toBase58(arr: Uint8Array): string;
  * @returns The decoded bytes
  */
 export function fromBase58(string: string, format?: 'uint8'): Uint8ArrayBuffer;
+export function fromBase58(string: string, format: 'arraybuffer'): ArrayBuffer;
 export function fromBase58(string: string, format: 'buffer'): Buffer;
-export function fromBase58(string: string, format?: OutputFormat): Uint8ArrayBuffer | Buffer;
+export function fromBase58(string: string, format?: OutputFormat): Uint8ArrayBuffer | ArrayBuffer | Buffer;
 
 /**
  * Encode a `Uint8Array` to a base58 string using XRP alphabet
@@ -58,5 +59,6 @@ export function toBase58xrp(arr: Uint8Array): string;
  * @returns The decoded bytes
  */
 export function fromBase58xrp(string: string, format?: 'uint8'): Uint8ArrayBuffer;
+export function fromBase58xrp(string: string, format: 'arraybuffer'): ArrayBuffer;
 export function fromBase58xrp(string: string, format: 'buffer'): Buffer;
-export function fromBase58xrp(string: string, format?: OutputFormat): Uint8ArrayBuffer | Buffer;
+export function fromBase58xrp(string: string, format?: OutputFormat): Uint8ArrayBuffer | ArrayBuffer | Buffer;

package/base58.js

@@ -1,5 +1,4 @@
-import { typedView } from './array.js'
-import { assertU8, E_STRING } from './fallback/_utils.js'
+import { assertU8, fromUint8, E_STRING } from './fallback/_utils.js'
 import { nativeDecoder, nativeEncoder, isHermes } from './fallback/platform.js'
 import { encodeAscii, decodeAscii } from './fallback/latin1.js'
 
@@ -124,7 +123,7 @@ function toBase58core(arr, alphabet, codes) {
 function fromBase58core(str, alphabet, codes, format = 'uint8') {
   if (typeof str !== 'string') throw new TypeError(E_STRING)
   const length = str.length
-  if (length === 0) return typedView(new Uint8Array(), format)
+  if (length === 0) return fromUint8(new Uint8Array(), format)
 
   const zeroC = codes[0]
   let zeros = 0
@@ -211,7 +210,7 @@ function fromBase58core(str, alphabet, codes, format = 'uint8') {
     }
   }
 
-  return typedView(res.slice(at - zeros), format) // slice is faster for small sizes than subarray
+  return fromUint8(res.slice(at - zeros), format)
 }
 
 export const toBase58 = (arr) => toBase58core(arr, alphabet58, codes58)

package/base58check.d.ts

@@ -46,8 +46,9 @@ export interface Base58CheckAsync {
    * @returns A Promise that resolves to the decoded bytes
    */
   decode(string: string, format?: 'uint8'): Promise<Uint8ArrayBuffer>;
+  decode(string: string, format: 'arraybuffer'): Promise<ArrayBuffer>;
   decode(string: string, format: 'buffer'): Promise<Buffer>;
-  decode(string: string, format?: OutputFormat): Promise<Uint8ArrayBuffer | Buffer>;
+  decode(string: string, format?: OutputFormat): Promise<Uint8ArrayBuffer | ArrayBuffer | Buffer>;
 }
 
 /**
@@ -70,8 +71,9 @@ export interface Base58CheckSync extends Base58CheckAsync {
    * @returns The decoded bytes
    */
   decodeSync(string: string, format?: 'uint8'): Uint8ArrayBuffer;
+  decodeSync(string: string, format: 'arraybuffer'): ArrayBuffer;
   decodeSync(string: string, format: 'buffer'): Buffer;
-  decodeSync(string: string, format?: OutputFormat): Uint8ArrayBuffer | Buffer;
+  decodeSync(string: string, format?: OutputFormat): Uint8ArrayBuffer | ArrayBuffer | Buffer;
 }
 
 /**
@@ -104,8 +106,9 @@ export function toBase58check(arr: Uint8Array): Promise<string>;
  * @returns A Promise that resolves to the decoded bytes
  */
 export function fromBase58check(string: string, format?: 'uint8'): Promise<Uint8ArrayBuffer>;
+export function fromBase58check(string: string, format: 'arraybuffer'): Promise<ArrayBuffer>;
 export function fromBase58check(string: string, format: 'buffer'): Promise<Buffer>;
-export function fromBase58check(string: string, format?: OutputFormat): Promise<Uint8ArrayBuffer | Buffer>;
+export function fromBase58check(string: string, format?: OutputFormat): Promise<Uint8ArrayBuffer | ArrayBuffer | Buffer>;
 
 /**
  * Encode bytes to base58check string synchronously
@@ -127,5 +130,6 @@ export function toBase58checkSync(arr: Uint8Array): string;
  * @returns The decoded bytes
  */
 export function fromBase58checkSync(string: string, format?: 'uint8'): Uint8ArrayBuffer;
+export function fromBase58checkSync(string: string, format: 'arraybuffer'): ArrayBuffer;
 export function fromBase58checkSync(string: string, format: 'buffer'): Buffer;
-export function fromBase58checkSync(string: string, format?: OutputFormat): Uint8ArrayBuffer | Buffer;
+export function fromBase58checkSync(string: string, format?: OutputFormat): Uint8ArrayBuffer | ArrayBuffer | Buffer;

package/base64.d.ts

@@ -68,8 +68,10 @@ export function toBase64url(arr: Uint8Array, options?: ToBase64Options): string;
  * @param options - Decoding options
  * @returns The decoded bytes
  */
-export function fromBase64(string: string, options?: FromBase64Options): Uint8ArrayBuffer;
+export function fromBase64(string: string, options?: FromBase64Options & { format?: 'uint8' }): Uint8ArrayBuffer;
+export function fromBase64(string: string, options: FromBase64Options & { format: 'arraybuffer' }): ArrayBuffer;
 export function fromBase64(string: string, options: FromBase64Options & { format: 'buffer' }): Buffer;
+export function fromBase64(string: string, options?: FromBase64Options): Uint8ArrayBuffer | ArrayBuffer | Buffer;
 
 /**
  * Decode a base64url string to bytes
@@ -80,8 +82,10 @@ export function fromBase64(string: string, options: FromBase64Options & { format
  * @param options - Decoding options (padding defaults to false)
  * @returns The decoded bytes
  */
-export function fromBase64url(string: string, options?: FromBase64Options): Uint8ArrayBuffer;
+export function fromBase64url(string: string, options?: FromBase64Options & { format?: 'uint8' }): Uint8ArrayBuffer;
+export function fromBase64url(string: string, options: FromBase64Options & { format: 'arraybuffer' }): ArrayBuffer;
 export function fromBase64url(string: string, options: FromBase64Options & { format: 'buffer' }): Buffer;
+export function fromBase64url(string: string, options?: FromBase64Options): Uint8ArrayBuffer | ArrayBuffer | Buffer;
 
 /**
  * Decode either base64 or base64url string to bytes
@@ -92,5 +96,7 @@ export function fromBase64url(string: string, options: FromBase64Options & { for
  * @param options - Decoding options
  * @returns The decoded bytes
  */
-export function fromBase64any(string: string, options?: FromBase64Options): Uint8ArrayBuffer;
+export function fromBase64any(string: string, options?: FromBase64Options & { format?: 'uint8' }): Uint8ArrayBuffer;
+export function fromBase64any(string: string, options: FromBase64Options & { format: 'arraybuffer' }): ArrayBuffer;
 export function fromBase64any(string: string, options: FromBase64Options & { format: 'buffer' }): Buffer;
+export function fromBase64url(string: string, options?: FromBase64Options): Uint8ArrayBuffer | ArrayBuffer | Buffer;