bufferbase 2.0.0 → 3.0.1

package/dist/cjs/types.d.ts

@@ -3,105 +3,142 @@ import { Buffer } from 'node:buffer';
  * Input type accepted by encode functions.
  *
  * Supports both Node.js `Buffer` and standard `Uint8Array` for browser compatibility.
- *
- * @example
- * ```typescript
- * // Node.js Buffer
- * encode(Buffer.from('Hello'), 'base58');
- *
- * // Browser Uint8Array
- * encode(new Uint8Array([72, 101, 108, 108, 111]), 'base58');
- * ```
  */
 export type BufferLike = Buffer | Uint8Array;
 /**
- * Supported base encoding names.
+ * How bytes are mapped to characters.
  *
- * These names can be used with the function API:
- * - `'decimal'` - Base 10 (0-9)
- * - `'base16'` / `'hex'` - Hexadecimal (0-9A-F)
- * - `'base32'` - RFC 4648 Base32 (A-Z2-7)
- * - `'base32crockford'` - Crockford's Base32 (0-9A-HJKMNP-TV-Z)
- * - `'base36'` - Alphanumeric (0-9A-Z)
- * - `'base52'` - Letters only (A-Za-z)
- * - `'base58'` - Bitcoin alphabet (no 0OIl)
- * - `'base64'` - Standard Base64 (A-Za-z0-9+/)
- * - `'base64url'` - URL-safe Base64 (A-Za-z0-9-_)
- * - `'base64xml'` - XML token Base64 (A-Za-z0-9._)
- * - `'base64xmlname'` - XML name Base64 (A-Za-z0-9_:)
- * - `'ascii85'` - ASCII85 encoding
- * - `'base85'` - Base85 encoding
- * - `'z85'` - ZeroMQ Z85 encoding
+ * An alphabet alone does not determine an encoding: the same 64 characters can
+ * be used by a radix conversion or by a bit-block encoding, producing different
+ * output. Every codec therefore names its algorithm explicitly.
+ *
+ * - `'radix'` — treats the whole buffer as one big integer and rewrites it in
+ *   base `alphabet.length`. Works with any alphabet and any input length.
+ *   Leading zero bytes are preserved as leading `alphabet[0]` characters.
+ *   Used by Base58, Base36, and custom alphabets. Not RFC 4648.
+ * - `'block'` — regroups the bit stream into `log2(alphabet.length)`-bit chunks,
+ *   as specified by RFC 4648. Requires an alphabet of 2, 4, 8, 16, 32, or 64
+ *   characters. Used by Base16, Base32, and Base64.
+ * - `'block85'` — converts each 4-byte block to 5 characters (85^5 > 2^32).
+ *   Requires an alphabet of exactly 85 characters. Used by Ascii85 and Z85.
+ */
+export type Algorithm = 'radix' | 'block' | 'block85';
+/** Options shared by every algorithm. */
+interface CommonSpec {
+    /** Characters used for encoding, ordered by value. */
+    readonly alphabet: string;
+    /**
+     * Reject input that is well-formed but not the canonical encoding of any
+     * byte sequence (RFC 4648 §3.5). Defaults to `true`.
+     *
+     * With `strict: false`, `'Zm9='` and `'Zm8='` both decode to `'fo'`, so
+     * decoding is no longer injective. Only disable it to read data produced by
+     * a lenient encoder.
+     */
+    readonly strict?: boolean;
+    /**
+     * Accept either letter case when decoding, and when validating.
+     * Requires an alphabet that does not contain both cases of the same letter.
+     * Defaults to `false`.
+     */
+    readonly caseInsensitive?: boolean;
+    /**
+     * Extra characters accepted when decoding, each mapped to the alphabet
+     * character it stands for.
+     *
+     * Crockford's Base32 uses `{ I: '1', L: '1', O: '0' }` so that a symbol
+     * written down by hand is read back as the digit it resembles. Encoding
+     * never emits them.
+     */
+    readonly aliases?: Readonly<Record<string, string>>;
+    /**
+     * Characters skipped when decoding, such as the hyphens Crockford's Base32
+     * allows for readability. Encoding never emits them.
+     */
+    readonly ignore?: string;
+}
+/** A codec that rewrites the buffer as an integer in base `alphabet.length`. */
+export interface RadixSpec extends CommonSpec {
+    readonly algorithm: 'radix';
+    /**
+     * Symbols that extend the alphabet for a trailing check symbol, which
+     * encodes the value modulo `alphabet.length + checkSymbols.length`.
+     *
+     * Crockford's Base32 uses `'*~$=U'`, giving a modulus of 37. When set, every
+     * encoding carries the symbol and every decoding verifies it.
+     */
+    readonly checkSymbols?: string;
+}
+/** A codec that regroups the bit stream, as specified by RFC 4648. */
+export interface BlockSpec extends CommonSpec {
+    readonly algorithm: 'block';
+    /**
+     * Character used to pad the final block to a whole number of characters,
+     * or `false` to emit no padding. Defaults to `'='`.
+     */
+    readonly pad?: string | false;
+}
+/** A codec that converts each 4-byte block to 5 characters. */
+export interface Block85Spec extends CommonSpec {
+    readonly algorithm: 'block85';
+    /** Write a block of four zero bytes as `'z'`. Defaults to `false`. */
+    readonly zeroShortcut?: boolean;
+    /** Write a block of four spaces as `'y'`. Defaults to `false`. */
+    readonly spaceShortcut?: boolean;
+    /** Wrap the output in `'<~'` and `'~>'`. Defaults to `false`. */
+    readonly delimiters?: boolean;
+    /**
+     * Require the input length to be a multiple of 4 bytes, as Z85 does.
+     * Defaults to `false`, which encodes a trailing partial block as
+     * `length + 1` characters.
+     */
+    readonly requireFullBlocks?: boolean;
+}
+/**
+ * A complete codec definition: an alphabet plus the algorithm that uses it.
  *
  * @example
  * ```typescript
- * import { encode, decode } from 'bufferbase';
+ * import { encode, type CodecSpec } from 'bufferbase';
  *
- * const encoded = encode(Buffer.from('Hello'), 'base58');
- * const decoded = decode(encoded, 'base58');
+ * const binary: CodecSpec = { alphabet: '01', algorithm: 'radix' };
+ * encode(Uint8Array.of(5), binary); // '101'
  * ```
  */
-export type BaseName = 'decimal' | 'base16' | 'hex' | 'base32' | 'base32crockford' | 'base36' | 'base52' | 'base58' | 'base64' | 'base64url' | 'base64xml' | 'base64xmlname' | 'ascii85' | 'base85' | 'z85';
+export type CodecSpec = RadixSpec | BlockSpec | Block85Spec;
 /**
  * Options for decode operations.
- *
- * @example
- * ```typescript
- * // Decode with fixed buffer size (pads with leading zeros)
- * const buffer = decode(encoded, 'base58', { size: 32 });
- * ```
  */
 export interface DecodeOptions {
     /**
-     * Expected buffer size in bytes.
-     * - If decoded result is smaller, pads with leading zeros.
-     * - If decoded result is larger, throws `BufferSizeError`.
+     * Required byte length of the result.
+     *
+     * The decoded buffer must be exactly this long, otherwise `BufferSizeError`
+     * is thrown. Because leading zeros carry no value in a radix encoding, a
+     * `'radix'` codec pads a shorter result with leading zero bytes to reach it;
+     * `'block'` and `'block85'` codecs derive the length from the input and can
+     * only check it.
      */
     size?: number;
 }
 /**
  * Codec interface for encoding/decoding operations.
  *
- * Implemented by the `Codec` class and used by pre-defined codecs in `Codecs`.
- *
- * @example
- * ```typescript
- * import { Codecs } from 'bufferbase';
- *
- * const encoded = Codecs.base58.encode(Buffer.from('Hello'));
- * const decoded = Codecs.base58.decode(encoded);
- * ```
+ * `validate(input)` returns `true` exactly when `decode(input)` succeeds.
  */
 export interface ICodec {
     /** Character set used for encoding. */
     readonly chars: string;
-    /**
-     * Encodes a buffer to a base-encoded string.
-     * @param buffer - The buffer or Uint8Array to encode
-     * @returns Base-encoded string
-     */
+    /** The algorithm this codec applies to `chars`. */
+    readonly algorithm: Algorithm;
+    /** Encodes a buffer to a base-encoded string. */
     encode(buffer: BufferLike): string;
-    /**
-     * Decodes a base-encoded string to a buffer.
-     * @param encoded - The string to decode
-     * @param options - Decode options (e.g., fixed size)
-     * @returns Decoded buffer
-     * @throws {InvalidCharacterError} If the string contains invalid characters
-     * @throws {BufferSizeError} If the result exceeds the specified size
-     */
+    /** Decodes a base-encoded string to a buffer. */
     decode(encoded: string, options?: DecodeOptions): Buffer;
-    /**
-     * Validates if a string contains only valid characters for this base.
-     * @param input - The string to validate
-     * @returns `true` if valid, `false` otherwise
-     */
+    /** Reports whether `decode` would succeed for this input. */
     validate(input: string): boolean;
-    /**
-     * Converts a string from this base to another base.
-     * @param target - Target codec to convert to
-     * @param input - The string to convert
-     * @returns String in the target base encoding
-     */
+    /** Decodes with this codec, then re-encodes with `target`. */
     convertTo(target: ICodec, input: string): string;
 }
+export {};
 //# sourceMappingURL=types.d.ts.map

package/dist/cjs/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,UAAU,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,MAAM,QAAQ,GAChB,SAAS,GACT,QAAQ,GACR,KAAK,GACL,QAAQ,GACR,iBAAiB,GACjB,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,WAAW,GACX,WAAW,GACX,eAAe,GACf,SAAS,GACT,QAAQ,GACR,KAAK,CAAC;AAEV;;;;;;;;GAQG;AACH,MAAM,WAAW,aAAa;IAC5B;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,MAAM;IACrB,uCAAuC;IACvC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAEvB;;;;OAIG;IACH,MAAM,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAAC;IAEnC;;;;;;;OAOG;IACH,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,MAAM,CAAC;IAEzD;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;IAEjC;;;;;OAKG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;CAClD"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC;;;;GAIG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,UAAU,CAAC;AAE7C;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,OAAO,GAAG,SAAS,CAAC;AAEtD,yCAAyC;AACzC,UAAU,UAAU;IAClB,sDAAsD;IACtD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B;;;;;;;OAOG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B;;;;OAIG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAC;IACnC;;;;;;;OAOG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACpD;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,gFAAgF;AAChF,MAAM,WAAW,SAAU,SAAQ,UAAU;IAC3C,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B;;;;;;OAMG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAChC;AAED,sEAAsE;AACtE,MAAM,WAAW,SAAU,SAAQ,UAAU;IAC3C,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B;;;OAGG;IACH,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;CAC/B;AAED,+DAA+D;AAC/D,MAAM,WAAW,WAAY,SAAQ,UAAU;IAC7C,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,sEAAsE;IACtE,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IAChC,kEAAkE;IAClE,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;IACjC,iEAAiE;IACjE,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC;CACtC;AAED;;;;;;;;;;GAUG;AACH,MAAM,MAAM,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG,WAAW,CAAC;AAE5D;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B;;;;;;;;OAQG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;GAIG;AACH,MAAM,WAAW,MAAM;IACrB,uCAAuC;IACvC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAEvB,mDAAmD;IACnD,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAE9B,iDAAiD;IACjD,MAAM,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAAC;IAEnC,iDAAiD;IACjD,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,MAAM,CAAC;IAEzD,6DAA6D;IAC7D,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;IAEjC,8DAA8D;IAC9D,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;CAClD"}

package/dist/esm/bases.d.ts

@@ -1,25 +1,19 @@
-import type { BaseName } from './types.js';
+import type { CodecSpec } from './types.js';
 /**
- * Character sets for common base encodings.
+ * Character sets, ordered by value.
  *
- * Use these with `createCodec()` or the deprecated `BufferEncoder` class
- * when you need direct access to character sets.
- *
- * @example
- * ```typescript
- * import { Chars, createCodec } from 'bufferbase';
- *
- * const codec = createCodec(Chars.Base58);
- * const encoded = codec.encode(Buffer.from('Hello'));
- * ```
+ * A character set does not by itself describe an encoding — see `Bases` for
+ * the alphabet/algorithm pairs that do.
  */
 export declare const Chars: {
     /** Base 10: 0-9 */
     readonly Decimal: "0123456789";
-    /** Hexadecimal: 0-9A-F */
+    /** RFC 4648 Table 5 — Base16: 0-9A-F */
     readonly Base16: "0123456789ABCDEF";
-    /** RFC 4648 Base32: A-Z2-7 */
+    /** RFC 4648 Table 3 — Base32: A-Z2-7 */
     readonly Base32: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+    /** RFC 4648 Table 4 — Base32 with extended hex alphabet: 0-9A-V */
+    readonly Base32Hex: "0123456789ABCDEFGHIJKLMNOPQRSTUV";
     /** Crockford's Base32: 0-9A-HJKMNP-TV-Z (no I, L, O, U) */
     readonly Base32Crockford: "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
     /** Alphanumeric: 0-9A-Z */
@@ -28,55 +22,168 @@ export declare const Chars: {
     readonly Base52: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     /** Bitcoin alphabet: 1-9A-HJ-NP-Za-km-z (no 0, O, I, l) */
     readonly Base58: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
-    /** Standard Base64: A-Za-z0-9+/ */
+    /** RFC 4648 Table 1 — Base64: A-Za-z0-9+/ */
     readonly Base64: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-    /** URL-safe Base64: A-Za-z0-9-_ */
+    /** RFC 4648 Table 2 — URL-safe Base64: A-Za-z0-9-_ */
     readonly Base64Url: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
     /** XML token Base64: A-Za-z0-9._ */
     readonly Base64Xml: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._";
     /** XML name Base64: A-Za-z0-9_: */
     readonly Base64XmlName: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_:";
-    /** ASCII85 encoding */
-    readonly Ascii85: "!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstu";
-    /** Base85 encoding */
-    readonly Base85: "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!#$%&()*+-;<=>?@^_`{|}~";
-    /** ZeroMQ Z85 encoding */
+    /** Ascii85: the 85 printable characters from `!` (0x21) to `u` (0x75) */
+    readonly Ascii85: "!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstu";
+    /** ZeroMQ Z85 (RFC 32): avoids the quote and backslash characters */
     readonly Z85: "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.-:+=^!/*?&<>()[]{}@%$#";
+    /** The five symbols Crockford's Base32 adds for its check symbol, giving a modulus of 37 */
+    readonly CrockfordCheck: "*~$=U";
 };
 /**
- * Resolves a base name or character set string to a character set.
- *
- * This function is used internally by the function API to convert
- * base names (like `'base58'`) to their character sets.
+ * The encodings this package knows by name.
  *
- * @param base - Base name (e.g., `'base58'`) or custom character set string
- * @returns The character set string
- * @throws {UnknownBaseError} If base name is not recognized and string length <= 15
+ * Each entry pairs an alphabet with the algorithm that reads it, because the
+ * alphabet alone is ambiguous: `base64` and `radix64` share Table 1 but
+ * produce different strings for the same bytes.
  *
  * @example
  * ```typescript
- * import { resolveChars } from 'bufferbase';
+ * import { encode, Bases } from 'bufferbase';
  *
- * resolveChars('base58'); // Returns Bitcoin alphabet
- * resolveChars('0123456789ABCDEF'); // Returns the string as-is (custom charset)
- * resolveChars('invalid'); // Throws UnknownBaseError
+ * encode(Buffer.from('fo'), 'base64');  // 'Zm8='  — RFC 4648
+ * encode(Buffer.from('fo'), 'radix64'); // 'GZv'   — radix conversion
  * ```
  */
-export declare function resolveChars(base: BaseName | string): string;
+export declare const Bases: {
+    readonly decimal: {
+        readonly alphabet: "0123456789";
+        readonly algorithm: "radix";
+    };
+    readonly base36: {
+        readonly alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+        readonly algorithm: "radix";
+        readonly caseInsensitive: true;
+    };
+    readonly base52: {
+        readonly alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+        readonly algorithm: "radix";
+    };
+    readonly base58: {
+        readonly alphabet: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+        readonly algorithm: "radix";
+    };
+    /**
+     * Crockford's Base32, which specifies a notation for numbers rather than for
+     * byte streams, so a radix conversion is the right reading of it.
+     *
+     * Decoding accepts either case, reads `I` and `L` as `1` and `O` as `0`, and
+     * ignores hyphens.
+     */
+    readonly base32crockford: {
+        readonly alphabet: "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+        readonly algorithm: "radix";
+        readonly caseInsensitive: true;
+        readonly aliases: {
+            readonly I: "1";
+            readonly L: "1";
+            readonly O: "0";
+        };
+        readonly ignore: "-";
+    };
+    /** Crockford's Base32 carrying its trailing check symbol. */
+    readonly base32crockfordcheck: {
+        readonly alphabet: "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+        readonly algorithm: "radix";
+        readonly caseInsensitive: true;
+        readonly aliases: {
+            readonly I: "1";
+            readonly L: "1";
+            readonly O: "0";
+        };
+        readonly ignore: "-";
+        readonly checkSymbols: "*~$=U";
+    };
+    readonly base16: {
+        readonly alphabet: "0123456789ABCDEF";
+        readonly algorithm: "block";
+        readonly pad: false;
+        readonly caseInsensitive: true;
+    };
+    readonly hex: {
+        readonly alphabet: "0123456789ABCDEF";
+        readonly algorithm: "block";
+        readonly pad: false;
+        readonly caseInsensitive: true;
+    };
+    readonly base32: {
+        readonly alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+        readonly algorithm: "block";
+        readonly caseInsensitive: true;
+    };
+    readonly base32hex: {
+        readonly alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUV";
+        readonly algorithm: "block";
+        readonly caseInsensitive: true;
+    };
+    readonly base64: {
+        readonly alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+        readonly algorithm: "block";
+    };
+    /** Unpadded, as used by JWT and other URL-facing formats. */
+    readonly base64url: {
+        readonly alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+        readonly algorithm: "block";
+        readonly pad: false;
+    };
+    readonly base64xml: {
+        readonly alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._";
+        readonly algorithm: "block";
+        readonly pad: false;
+    };
+    readonly base64xmlname: {
+        readonly alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_:";
+        readonly algorithm: "block";
+        readonly pad: false;
+    };
+    /** Ascii85 with the zero-block shortcut, matching Python's `a85encode`. */
+    readonly ascii85: {
+        readonly alphabet: "!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstu";
+        readonly algorithm: "block85";
+        readonly zeroShortcut: true;
+    };
+    /** ZeroMQ Z85, which has no padding and so encodes whole blocks only. */
+    readonly z85: {
+        readonly alphabet: "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.-:+=^!/*?&<>()[]{}@%$#";
+        readonly algorithm: "block85";
+        readonly requireFullBlocks: true;
+    };
+    readonly radix16: {
+        readonly alphabet: "0123456789ABCDEF";
+        readonly algorithm: "radix";
+    };
+    readonly radix32: {
+        readonly alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+        readonly algorithm: "radix";
+    };
+    readonly radix64: {
+        readonly alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+        readonly algorithm: "radix";
+    };
+    readonly radix64url: {
+        readonly alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+        readonly algorithm: "radix";
+    };
+};
 /**
- * Checks if a string is a valid base name.
- *
- * @param value - The string to check
- * @returns `true` if the value is a valid `BaseName`, `false` otherwise
- *
- * @example
- * ```typescript
- * import { isBaseName } from 'bufferbase';
+ * The names accepted wherever a base is expected.
+ */
+export type BaseName = keyof typeof Bases;
+/**
+ * Resolves a base name to its codec spec, and passes a spec through unchanged.
  *
- * isBaseName('base58'); // true
- * isBaseName('BASE58'); // true (case-insensitive)
- * isBaseName('unknown'); // false
- * ```
+ * @throws {UnknownBaseError} If the name is not one of `Bases`
+ */
+export declare function resolveSpec(base: BaseName | CodecSpec): CodecSpec;
+/**
+ * Checks whether a string names one of the encodings in `Bases`.
  */
 export declare function isBaseName(value: string): value is BaseName;
 //# sourceMappingURL=bases.d.ts.map

package/dist/esm/bases.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bases.d.ts","sourceRoot":"","sources":["../../src/bases.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAG3C;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,KAAK;IAChB,mBAAmB;;IAEnB,0BAA0B;;IAE1B,8BAA8B;;IAE9B,2DAA2D;;IAE3D,2BAA2B;;IAE3B,2BAA2B;;IAE3B,2DAA2D;;IAE3D,mCAAmC;;IAEnC,mCAAmC;;IAEnC,oCAAoC;;IAEpC,mCAAmC;;IAEnC,uBAAuB;;IAEvB,sBAAsB;;IAEtB,0BAA0B;;CAElB,CAAC;AAwBX;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,MAAM,CAW5D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,QAAQ,CAE3D"}
+{"version":3,"file":"bases.d.ts","sourceRoot":"","sources":["../../src/bases.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAG5C;;;;;GAKG;AACH,eAAO,MAAM,KAAK;IAChB,mBAAmB;;IAEnB,wCAAwC;;IAExC,wCAAwC;;IAExC,mEAAmE;;IAEnE,2DAA2D;;IAE3D,2BAA2B;;IAE3B,2BAA2B;;IAE3B,2DAA2D;;IAE3D,6CAA6C;;IAE7C,sDAAsD;;IAEtD,oCAAoC;;IAEpC,mCAAmC;;IAEnC,yEAAyE;;IAEzE,qEAAqE;;IAErE,4FAA4F;;CAEpF,CAAC;AAKX;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;IAOhB;;;;;;OAMG;;;;;;;;;;;;IAQH,6DAA6D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAgB7D,6DAA6D;;;;;;;;;;;;;;;;IAM7D,2EAA2E;;;;;;IAE3E,yEAAyE;;;;;;;;;;;;;;;;;;;;;;CAQ7B,CAAC;AAE/C;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,OAAO,KAAK,CAAC;AAE1C;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,QAAQ,GAAG,SAAS,GAAG,SAAS,CASjE;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,QAAQ,CAE3D"}