bufferbase 1.3.0 → 3.0.0

package/dist/cjs/index.js

@@ -1,11 +1,42 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validate = exports.Validator = exports.InvalidCharacterError = exports.Converter = exports.BufferEncoder = exports.Chars = void 0;
+exports.Validator = exports.Converter = exports.BufferEncoder = exports.Codecs = exports.validate = exports.encode = exports.decode = exports.convert = exports.resolveSpec = exports.isBaseName = exports.Chars = exports.Bases = exports.getCodec = exports.createCodec = exports.RadixCodec = exports.Codec = exports.BlockCodec = exports.Block85Codec = exports.ValueRangeError = exports.UnknownBaseError = exports.NonCanonicalError = exports.InvalidLengthError = exports.InvalidCodecError = exports.InvalidCharacterError = exports.CheckSymbolError = exports.BufferSizeError = void 0;
+// Errors
+var errors_js_1 = require("./errors.js");
+Object.defineProperty(exports, "BufferSizeError", { enumerable: true, get: function () { return errors_js_1.BufferSizeError; } });
+Object.defineProperty(exports, "CheckSymbolError", { enumerable: true, get: function () { return errors_js_1.CheckSymbolError; } });
+Object.defineProperty(exports, "InvalidCharacterError", { enumerable: true, get: function () { return errors_js_1.InvalidCharacterError; } });
+Object.defineProperty(exports, "InvalidCodecError", { enumerable: true, get: function () { return errors_js_1.InvalidCodecError; } });
+Object.defineProperty(exports, "InvalidLengthError", { enumerable: true, get: function () { return errors_js_1.InvalidLengthError; } });
+Object.defineProperty(exports, "NonCanonicalError", { enumerable: true, get: function () { return errors_js_1.NonCanonicalError; } });
+Object.defineProperty(exports, "UnknownBaseError", { enumerable: true, get: function () { return errors_js_1.UnknownBaseError; } });
+Object.defineProperty(exports, "ValueRangeError", { enumerable: true, get: function () { return errors_js_1.ValueRangeError; } });
+// Codec implementations and factory
+var codec_js_1 = require("./codec.js");
+Object.defineProperty(exports, "Block85Codec", { enumerable: true, get: function () { return codec_js_1.Block85Codec; } });
+Object.defineProperty(exports, "BlockCodec", { enumerable: true, get: function () { return codec_js_1.BlockCodec; } });
+Object.defineProperty(exports, "Codec", { enumerable: true, get: function () { return codec_js_1.Codec; } });
+Object.defineProperty(exports, "RadixCodec", { enumerable: true, get: function () { return codec_js_1.RadixCodec; } });
+Object.defineProperty(exports, "createCodec", { enumerable: true, get: function () { return codec_js_1.createCodec; } });
+Object.defineProperty(exports, "getCodec", { enumerable: true, get: function () { return codec_js_1.getCodec; } });
+// Character sets, encoding definitions, and lookup helpers
+var bases_js_1 = require("./bases.js");
+Object.defineProperty(exports, "Bases", { enumerable: true, get: function () { return bases_js_1.Bases; } });
+Object.defineProperty(exports, "Chars", { enumerable: true, get: function () { return bases_js_1.Chars; } });
+Object.defineProperty(exports, "isBaseName", { enumerable: true, get: function () { return bases_js_1.isBaseName; } });
+Object.defineProperty(exports, "resolveSpec", { enumerable: true, get: function () { return bases_js_1.resolveSpec; } });
+// Simple function API
+var functions_js_1 = require("./functions.js");
+Object.defineProperty(exports, "convert", { enumerable: true, get: function () { return functions_js_1.convert; } });
+Object.defineProperty(exports, "decode", { enumerable: true, get: function () { return functions_js_1.decode; } });
+Object.defineProperty(exports, "encode", { enumerable: true, get: function () { return functions_js_1.encode; } });
+Object.defineProperty(exports, "validate", { enumerable: true, get: function () { return functions_js_1.validate; } });
+// Pre-defined codecs (namespaced)
+var codecs_js_1 = require("./codecs.js");
+Object.defineProperty(exports, "Codecs", { enumerable: true, get: function () { return codecs_js_1.Codecs; } });
+// Deprecated exports for backward compatibility
 var bufferbase_js_1 = require("./bufferbase.js");
-Object.defineProperty(exports, "Chars", { enumerable: true, get: function () { return bufferbase_js_1.Chars; } });
 Object.defineProperty(exports, "BufferEncoder", { enumerable: true, get: function () { return bufferbase_js_1.BufferEncoder; } });
 Object.defineProperty(exports, "Converter", { enumerable: true, get: function () { return bufferbase_js_1.Converter; } });
-Object.defineProperty(exports, "InvalidCharacterError", { enumerable: true, get: function () { return bufferbase_js_1.InvalidCharacterError; } });
 Object.defineProperty(exports, "Validator", { enumerable: true, get: function () { return bufferbase_js_1.Validator; } });
-Object.defineProperty(exports, "validate", { enumerable: true, get: function () { return bufferbase_js_1.validate; } });
 //# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;AAAA,iDAOyB;AANvB,sGAAA,KAAK,OAAA;AACL,8GAAA,aAAa,OAAA;AACb,0GAAA,SAAS,OAAA;AACT,sHAAA,qBAAqB,OAAA;AACrB,0GAAA,SAAS,OAAA;AACT,yGAAA,QAAQ,OAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;AAeA,SAAS;AACT,yCASqB;AARnB,4GAAA,eAAe,OAAA;AACf,6GAAA,gBAAgB,OAAA;AAChB,kHAAA,qBAAqB,OAAA;AACrB,8GAAA,iBAAiB,OAAA;AACjB,+GAAA,kBAAkB,OAAA;AAClB,8GAAA,iBAAiB,OAAA;AACjB,6GAAA,gBAAgB,OAAA;AAChB,4GAAA,eAAe,OAAA;AAGjB,oCAAoC;AACpC,uCAAgG;AAAvF,wGAAA,YAAY,OAAA;AAAE,sGAAA,UAAU,OAAA;AAAE,iGAAA,KAAK,OAAA;AAAE,sGAAA,UAAU,OAAA;AAAE,uGAAA,WAAW,OAAA;AAAE,oGAAA,QAAQ,OAAA;AAE3E,2DAA2D;AAC3D,uCAAmE;AAA1D,iGAAA,KAAK,OAAA;AAAE,iGAAA,KAAK,OAAA;AAAE,sGAAA,UAAU,OAAA;AAAE,uGAAA,WAAW,OAAA;AAE9C,sBAAsB;AACtB,+CAAmE;AAA1D,uGAAA,OAAO,OAAA;AAAE,sGAAA,MAAM,OAAA;AAAE,sGAAA,MAAM,OAAA;AAAE,wGAAA,QAAQ,OAAA;AAE1C,kCAAkC;AAClC,yCAAqC;AAA5B,mGAAA,MAAM,OAAA;AAEf,gDAAgD;AAChD,iDAAsE;AAA7D,8GAAA,aAAa,OAAA;AAAE,0GAAA,SAAS,OAAA;AAAE,0GAAA,SAAS,OAAA"}

package/dist/cjs/package.json

@@ -1,22 +1,22 @@
 {
   "name": "bufferbase",
-  "version": "1.3.0",
-  "description": "Buffer-to-BaseN Encoder, Decoder, Converter, and Validator",
+  "version": "3.0.0",
+  "description": "Buffer-to-BaseN encoding: RFC 4648 block encodings, Ascii85/Z85, and Base58-style radix conversion",
   "sideEffects": false,
   "type": "commonjs",
   "scripts": {
-    "build": "npm run build:esm && npm run build:cjs && tsconfig-to-dual-package",
+    "build": "bun run build:esm && bun run build:cjs && tsconfig-to-dual-package",
     "build:cjs": "tsc -p tsconfig.cjs.json",
     "build:esm": "tsc -p tsconfig.json",
-    "prepublishOnly": "npm run build",
-    "example": "tsx src/example.ts",
-    "test": "tsx --test src/*.test.ts"
+    "prepublishOnly": "bun run build",
+    "example": "bun src/example.ts",
+    "test": "bun test",
+    "release": "bin/release"
   },
   "devDependencies": {
+    "@types/bun": "^1.1.0",
     "@types/node": "^20.11.5",
-    "ts-loader": "^9.5.1",
     "tsconfig-to-dual-package": "^1.2.0",
-    "tsx": "^4.7.0",
     "typescript": "^5.3.3"
   },
   "repository": {
@@ -28,19 +28,24 @@
     "src"
   ],
   "keywords": [
-    "number",
     "encode",
+    "decode",
     "convert",
-    "decimal",
     "base",
+    "rfc4648",
     "base16",
+    "hex",
     "base32",
+    "base32hex",
     "crockford",
     "base36",
     "base58",
     "base64",
-    "Ascii85",
-    "base85"
+    "base64url",
+    "ascii85",
+    "base85",
+    "z85",
+    "radix"
   ],
   "author": "misebox",
   "license": "ISC",

package/dist/cjs/types.d.ts

@@ -0,0 +1,144 @@
+import { Buffer } from 'node:buffer';
+/**
+ * Input type accepted by encode functions.
+ *
+ * Supports both Node.js `Buffer` and standard `Uint8Array` for browser compatibility.
+ */
+export type BufferLike = Buffer | Uint8Array;
+/**
+ * How bytes are mapped to characters.
+ *
+ * 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, type CodecSpec } from 'bufferbase';
+ *
+ * const binary: CodecSpec = { alphabet: '01', algorithm: 'radix' };
+ * encode(Uint8Array.of(5), binary); // '101'
+ * ```
+ */
+export type CodecSpec = RadixSpec | BlockSpec | Block85Spec;
+/**
+ * Options for decode operations.
+ */
+export interface DecodeOptions {
+    /**
+     * 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.
+ *
+ * `validate(input)` returns `true` exactly when `decode(input)` succeeds.
+ */
+export interface ICodec {
+    /** Character set used for encoding. */
+    readonly chars: 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. */
+    decode(encoded: string, options?: DecodeOptions): Buffer;
+    /** Reports whether `decode` would succeed for this input. */
+    validate(input: string): boolean;
+    /** 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

@@ -0,0 +1 @@
+{"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/cjs/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/cjs/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":""}

package/dist/esm/bases.d.ts

@@ -0,0 +1,189 @@
+import type { CodecSpec } from './types.js';
+/**
+ * Character sets, ordered by value.
+ *
+ * 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";
+    /** RFC 4648 Table 5 — Base16: 0-9A-F */
+    readonly Base16: "0123456789ABCDEF";
+    /** 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 */
+    readonly Base36: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    /** Letters only: A-Za-z */
+    readonly Base52: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+    /** Bitcoin alphabet: 1-9A-HJ-NP-Za-km-z (no 0, O, I, l) */
+    readonly Base58: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+    /** RFC 4648 Table 1 — Base64: A-Za-z0-9+/ */
+    readonly Base64: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    /** 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: 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";
+};
+/**
+ * The encodings this package knows by name.
+ *
+ * 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 { encode, Bases } from 'bufferbase';
+ *
+ * encode(Buffer.from('fo'), 'base64');  // 'Zm8='  — RFC 4648
+ * encode(Buffer.from('fo'), 'radix64'); // 'GZv'   — radix conversion
+ * ```
+ */
+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";
+    };
+};
+/**
+ * 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.
+ *
+ * @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

@@ -0,0 +1 @@
+{"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"}

package/dist/esm/bases.js

@@ -0,0 +1,129 @@
+import { UnknownBaseError } from './errors.js';
+/**
+ * Character sets, ordered by value.
+ *
+ * A character set does not by itself describe an encoding — see `Bases` for
+ * the alphabet/algorithm pairs that do.
+ */
+export const Chars = {
+    /** Base 10: 0-9 */
+    Decimal: '0123456789',
+    /** RFC 4648 Table 5 — Base16: 0-9A-F */
+    Base16: '0123456789ABCDEF',
+    /** RFC 4648 Table 3 — Base32: A-Z2-7 */
+    Base32: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567',
+    /** RFC 4648 Table 4 — Base32 with extended hex alphabet: 0-9A-V */
+    Base32Hex: '0123456789ABCDEFGHIJKLMNOPQRSTUV',
+    /** Crockford's Base32: 0-9A-HJKMNP-TV-Z (no I, L, O, U) */
+    Base32Crockford: '0123456789ABCDEFGHJKMNPQRSTVWXYZ',
+    /** Alphanumeric: 0-9A-Z */
+    Base36: '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ',
+    /** Letters only: A-Za-z */
+    Base52: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz',
+    /** Bitcoin alphabet: 1-9A-HJ-NP-Za-km-z (no 0, O, I, l) */
+    Base58: '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz',
+    /** RFC 4648 Table 1 — Base64: A-Za-z0-9+/ */
+    Base64: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
+    /** RFC 4648 Table 2 — URL-safe Base64: A-Za-z0-9-_ */
+    Base64Url: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_',
+    /** XML token Base64: A-Za-z0-9._ */
+    Base64Xml: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._',
+    /** XML name Base64: A-Za-z0-9_: */
+    Base64XmlName: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_:',
+    /** Ascii85: the 85 printable characters from `!` (0x21) to `u` (0x75) */
+    Ascii85: '!"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstu',
+    /** ZeroMQ Z85 (RFC 32): avoids the quote and backslash characters */
+    Z85: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.-:+=^!/*?&<>()[]{}@%$#',
+    /** The five symbols Crockford's Base32 adds for its check symbol, giving a modulus of 37 */
+    CrockfordCheck: '*~$=U',
+};
+/** The characters Crockford's Base32 reads as the digit they resemble. */
+const CROCKFORD_ALIASES = { I: '1', L: '1', O: '0' };
+/**
+ * The encodings this package knows by name.
+ *
+ * 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 { encode, Bases } from 'bufferbase';
+ *
+ * encode(Buffer.from('fo'), 'base64');  // 'Zm8='  — RFC 4648
+ * encode(Buffer.from('fo'), 'radix64'); // 'GZv'   — radix conversion
+ * ```
+ */
+export const Bases = {
+    // Radix conversion. No external standard fixes these, so nothing here can
+    // disagree with one.
+    decimal: { alphabet: Chars.Decimal, algorithm: 'radix' },
+    base36: { alphabet: Chars.Base36, algorithm: 'radix', caseInsensitive: true },
+    base52: { alphabet: Chars.Base52, algorithm: 'radix' },
+    base58: { alphabet: Chars.Base58, 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.
+     */
+    base32crockford: {
+        alphabet: Chars.Base32Crockford,
+        algorithm: 'radix',
+        caseInsensitive: true,
+        aliases: CROCKFORD_ALIASES,
+        ignore: '-',
+    },
+    /** Crockford's Base32 carrying its trailing check symbol. */
+    base32crockfordcheck: {
+        alphabet: Chars.Base32Crockford,
+        algorithm: 'radix',
+        caseInsensitive: true,
+        aliases: CROCKFORD_ALIASES,
+        ignore: '-',
+        checkSymbols: Chars.CrockfordCheck,
+    },
+    // Bit-block encoding, RFC 4648.
+    base16: { alphabet: Chars.Base16, algorithm: 'block', pad: false, caseInsensitive: true },
+    hex: { alphabet: Chars.Base16, algorithm: 'block', pad: false, caseInsensitive: true },
+    base32: { alphabet: Chars.Base32, algorithm: 'block', caseInsensitive: true },
+    base32hex: { alphabet: Chars.Base32Hex, algorithm: 'block', caseInsensitive: true },
+    base64: { alphabet: Chars.Base64, algorithm: 'block' },
+    /** Unpadded, as used by JWT and other URL-facing formats. */
+    base64url: { alphabet: Chars.Base64Url, algorithm: 'block', pad: false },
+    base64xml: { alphabet: Chars.Base64Xml, algorithm: 'block', pad: false },
+    base64xmlname: { alphabet: Chars.Base64XmlName, algorithm: 'block', pad: false },
+    // Four bytes to five characters.
+    /** Ascii85 with the zero-block shortcut, matching Python's `a85encode`. */
+    ascii85: { alphabet: Chars.Ascii85, algorithm: 'block85', zeroShortcut: true },
+    /** ZeroMQ Z85, which has no padding and so encodes whole blocks only. */
+    z85: { alphabet: Chars.Z85, algorithm: 'block85', requireFullBlocks: true },
+    // Radix conversion over the RFC alphabets.
+    radix16: { alphabet: Chars.Base16, algorithm: 'radix' },
+    radix32: { alphabet: Chars.Base32, algorithm: 'radix' },
+    radix64: { alphabet: Chars.Base64, algorithm: 'radix' },
+    radix64url: { alphabet: Chars.Base64Url, algorithm: 'radix' },
+};
+/**
+ * Resolves a base name to its codec spec, and passes a spec through unchanged.
+ *
+ * @throws {UnknownBaseError} If the name is not one of `Bases`
+ */
+export function resolveSpec(base) {
+    if (typeof base !== 'string') {
+        return base;
+    }
+    const spec = Bases[base.toLowerCase()];
+    if (spec === undefined) {
+        throw new UnknownBaseError(base);
+    }
+    return spec;
+}
+/**
+ * Checks whether a string names one of the encodings in `Bases`.
+ */
+export function isBaseName(value) {
+    return value.toLowerCase() in Bases;
+}
+//# sourceMappingURL=bases.js.map

package/dist/esm/bases.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bases.js","sourceRoot":"","sources":["../../src/bases.ts"],"names":[],"mappings":"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"}