bufferbase 2.0.0 → 3.0.1

package/dist/cjs/errors.js

@@ -1,21 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnknownBaseError = exports.BufferSizeError = exports.InvalidCharacterError = void 0;
+exports.CheckSymbolError = exports.ValueRangeError = exports.InvalidCodecError = exports.NonCanonicalError = exports.InvalidLengthError = exports.UnknownBaseError = exports.BufferSizeError = exports.InvalidCharacterError = void 0;
 /**
  * Error thrown when an invalid character is encountered during decoding.
- *
- * @example
- * ```typescript
- * import { decode, InvalidCharacterError } from 'bufferbase';
- *
- * try {
- *   decode('invalid!', 'base58');
- * } catch (e) {
- *   if (e instanceof InvalidCharacterError) {
- *     console.log(e.message); // "Invalid character found: '!'"
- *   }
- * }
- * ```
  */
 class InvalidCharacterError extends Error {
     /**
@@ -29,24 +16,8 @@ class InvalidCharacterError extends Error {
 }
 exports.InvalidCharacterError = InvalidCharacterError;
 /**
- * Error thrown when decoded buffer size exceeds the specified size.
- *
- * This error is thrown when using the `size` option in decode operations
- * and the decoded data is larger than the specified size.
- *
- * @example
- * ```typescript
- * import { decode, BufferSizeError } from 'bufferbase';
- *
- * try {
- *   // Trying to decode into a buffer too small
- *   decode('72k1xXWG59fYdzSNoA', 'base58', { size: 2 });
- * } catch (e) {
- *   if (e instanceof BufferSizeError) {
- *     console.log(e.message); // "Buffer size 13 exceeds specified size 2"
- *   }
- * }
- * ```
+ * Error thrown when the decoded buffer does not have the size requested
+ * through `DecodeOptions.size`.
  */
 class BufferSizeError extends Error {
     /**
@@ -54,39 +25,106 @@ class BufferSizeError extends Error {
      * @param expected - The expected (specified) buffer size
      */
     constructor(actual, expected) {
-        super(`Buffer size ${actual} exceeds specified size ${expected}`);
+        super(`Buffer size ${actual} does not match specified size ${expected}`);
         this.name = 'BufferSizeError';
     }
 }
 exports.BufferSizeError = BufferSizeError;
 /**
  * Error thrown when an unknown base name is provided.
- *
- * This error is thrown when using the function API with an invalid base name
- * that is neither a known encoding name nor a valid custom character set
- * (character sets must be longer than 15 characters).
- *
- * @example
- * ```typescript
- * import { encode, UnknownBaseError } from 'bufferbase';
- *
- * try {
- *   encode(Buffer.from('test'), 'invalidbase');
- * } catch (e) {
- *   if (e instanceof UnknownBaseError) {
- *     console.log(e.message); // "Unknown base encoding: 'invalidbase'"
- *   }
- * }
- * ```
  */
 class UnknownBaseError extends Error {
     /**
      * @param name - The unknown base name that was provided
      */
     constructor(name) {
-        super(`Unknown base encoding: '${name}'`);
+        super(`Unknown base encoding: '${name}'. ` +
+            'Pass a CodecSpec such as { alphabet, algorithm: \'radix\' } to use a custom alphabet.');
         this.name = 'UnknownBaseError';
     }
 }
 exports.UnknownBaseError = UnknownBaseError;
+/**
+ * Error thrown when a string cannot be the encoding of any byte sequence
+ * because of its length.
+ *
+ * A Base64 string of 5 characters, for example, describes 30 bits: too many
+ * for 3 bytes and too few for 4.
+ */
+class InvalidLengthError extends Error {
+    /**
+     * @param length - The length that cannot occur
+     * @param detail - What the length should have been
+     */
+    constructor(length, detail) {
+        super(`Invalid encoded length ${length}: ${detail}`);
+        this.name = 'InvalidLengthError';
+    }
+}
+exports.InvalidLengthError = InvalidLengthError;
+/**
+ * Error thrown when input is well-formed but is not the canonical encoding of
+ * the bytes it decodes to (RFC 4648 §3.5).
+ *
+ * Accepting such input makes decoding non-injective: `'Zm8='` and `'Zm9='`
+ * would both decode to `'fo'`. Pass `strict: false` in the codec spec to allow
+ * it.
+ */
+class NonCanonicalError extends Error {
+    /**
+     * @param detail - What made the input non-canonical
+     */
+    constructor(detail) {
+        super(`Non-canonical encoding: ${detail}`);
+        this.name = 'NonCanonicalError';
+    }
+}
+exports.NonCanonicalError = NonCanonicalError;
+/**
+ * Error thrown when a codec spec cannot be realised, such as a `'block'`
+ * algorithm with an alphabet whose length is not a power of two.
+ */
+class InvalidCodecError extends Error {
+    /**
+     * @param detail - Why the spec is unusable
+     */
+    constructor(detail) {
+        super(`Invalid codec: ${detail}`);
+        this.name = 'InvalidCodecError';
+    }
+}
+exports.InvalidCodecError = InvalidCodecError;
+/**
+ * Error thrown when a group of characters denotes a number too large for the
+ * bytes it is supposed to encode.
+ *
+ * In an Ascii85 group, five characters must denote a value below 2^32; `'s8W-!'`
+ * does not, so it encodes nothing. Unlike `NonCanonicalError` this is never
+ * allowed, because there is no byte sequence to decode to.
+ */
+class ValueRangeError extends Error {
+    /**
+     * @param group - The group of characters that is out of range
+     */
+    constructor(group) {
+        super(`Encoded group '${group}' exceeds the maximum value for its block`);
+        this.name = 'ValueRangeError';
+    }
+}
+exports.ValueRangeError = ValueRangeError;
+/**
+ * Error thrown when a trailing check symbol does not match the value it
+ * follows, which means the string was mistyped or corrupted.
+ */
+class CheckSymbolError extends Error {
+    /**
+     * @param found - The check symbol present in the input
+     * @param expected - The check symbol the value calls for
+     */
+    constructor(found, expected) {
+        super(`Check symbol '${found}' does not match the expected '${expected}'`);
+        this.name = 'CheckSymbolError';
+    }
+}
+exports.CheckSymbolError = CheckSymbolError;
 //# sourceMappingURL=errors.js.map

package/dist/cjs/errors.js.map

@@ -1 +1 @@
-{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../src/errors.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;;GAeG;AACH,MAAa,qBAAsB,SAAQ,KAAK;IAC9C;;OAEG;IACH,YAAY,IAAa;QACvB,MAAM,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,6BAA6B,IAAI,GAAG,CAAC,CAAC,CAAC,yBAAyB,CAAC;QACxF,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,uBAAuB,CAAC;IACtC,CAAC;CACF;AATD,sDASC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAa,eAAgB,SAAQ,KAAK;IACxC;;;OAGG;IACH,YAAY,MAAc,EAAE,QAAgB;QAC1C,KAAK,CAAC,eAAe,MAAM,2BAA2B,QAAQ,EAAE,CAAC,CAAC;QAClE,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAC;IAChC,CAAC;CACF;AATD,0CASC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAa,gBAAiB,SAAQ,KAAK;IACzC;;OAEG;IACH,YAAY,IAAY;QACtB,KAAK,CAAC,2BAA2B,IAAI,GAAG,CAAC,CAAC;QAC1C,IAAI,CAAC,IAAI,GAAG,kBAAkB,CAAC;IACjC,CAAC;CACF;AARD,4CAQC"}
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../src/errors.ts"],"names":[],"mappings":";;;AAAA;;GAEG;AACH,MAAa,qBAAsB,SAAQ,KAAK;IAC9C;;OAEG;IACH,YAAY,IAAa;QACvB,MAAM,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,6BAA6B,IAAI,GAAG,CAAC,CAAC,CAAC,yBAAyB,CAAC;QACxF,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,uBAAuB,CAAC;IACtC,CAAC;CACF;AATD,sDASC;AAED;;;GAGG;AACH,MAAa,eAAgB,SAAQ,KAAK;IACxC;;;OAGG;IACH,YAAY,MAAc,EAAE,QAAgB;QAC1C,KAAK,CAAC,eAAe,MAAM,kCAAkC,QAAQ,EAAE,CAAC,CAAC;QACzE,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAC;IAChC,CAAC;CACF;AATD,0CASC;AAED;;GAEG;AACH,MAAa,gBAAiB,SAAQ,KAAK;IACzC;;OAEG;IACH,YAAY,IAAY;QACtB,KAAK,CACH,2BAA2B,IAAI,KAAK;YAClC,uFAAuF,CAC1F,CAAC;QACF,IAAI,CAAC,IAAI,GAAG,kBAAkB,CAAC;IACjC,CAAC;CACF;AAXD,4CAWC;AAED;;;;;;GAMG;AACH,MAAa,kBAAmB,SAAQ,KAAK;IAC3C;;;OAGG;IACH,YAAY,MAAc,EAAE,MAAc;QACxC,KAAK,CAAC,0BAA0B,MAAM,KAAK,MAAM,EAAE,CAAC,CAAC;QACrD,IAAI,CAAC,IAAI,GAAG,oBAAoB,CAAC;IACnC,CAAC;CACF;AATD,gDASC;AAED;;;;;;;GAOG;AACH,MAAa,iBAAkB,SAAQ,KAAK;IAC1C;;OAEG;IACH,YAAY,MAAc;QACxB,KAAK,CAAC,2BAA2B,MAAM,EAAE,CAAC,CAAC;QAC3C,IAAI,CAAC,IAAI,GAAG,mBAAmB,CAAC;IAClC,CAAC;CACF;AARD,8CAQC;AAED;;;GAGG;AACH,MAAa,iBAAkB,SAAQ,KAAK;IAC1C;;OAEG;IACH,YAAY,MAAc;QACxB,KAAK,CAAC,kBAAkB,MAAM,EAAE,CAAC,CAAC;QAClC,IAAI,CAAC,IAAI,GAAG,mBAAmB,CAAC;IAClC,CAAC;CACF;AARD,8CAQC;AAED;;;;;;;GAOG;AACH,MAAa,eAAgB,SAAQ,KAAK;IACxC;;OAEG;IACH,YAAY,KAAa;QACvB,KAAK,CAAC,kBAAkB,KAAK,2CAA2C,CAAC,CAAC;QAC1E,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAC;IAChC,CAAC;CACF;AARD,0CAQC;AAED;;;GAGG;AACH,MAAa,gBAAiB,SAAQ,KAAK;IACzC;;;OAGG;IACH,YAAY,KAAa,EAAE,QAAgB;QACzC,KAAK,CAAC,iBAAiB,KAAK,kCAAkC,QAAQ,GAAG,CAAC,CAAC;QAC3E,IAAI,CAAC,IAAI,GAAG,kBAAkB,CAAC;IACjC,CAAC;CACF;AATD,4CASC"}

package/dist/cjs/example.js

@@ -2,31 +2,54 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const node_buffer_1 = require("node:buffer");
 const index_js_1 = require("./index.js");
-// Example buffer
 const bytes = node_buffer_1.Buffer.from('Hello, World!', 'utf8');
-// Using simple function API
-const base32encoded = (0, index_js_1.encode)(bytes, 'base32crockford');
-const base58encoded = (0, index_js_1.convert)(base32encoded, 'base32crockford', 'base58');
-const base64encoded = (0, index_js_1.convert)(base58encoded, 'base58', 'base64url');
-const isValidAsBase64 = (0, index_js_1.validate)(base64encoded, 'base64url');
-const decoded = (0, index_js_1.decode)(base64encoded, 'base64url');
-console.log('=== Function API ===');
+// The same bytes under each algorithm.
+console.log('=== Algorithms ===');
+console.table({
+    'block   base64': (0, index_js_1.encode)(bytes, 'base64'),
+    'block   base32': (0, index_js_1.encode)(bytes, 'base32'),
+    'block85 ascii85': (0, index_js_1.encode)(bytes, 'ascii85'),
+    'radix   base58': (0, index_js_1.encode)(bytes, 'base58'),
+    'radix   base32crockford': (0, index_js_1.encode)(bytes, 'base32crockford'),
+});
+// Converting goes through the bytes, so any pair works.
+console.log('\n=== Function API ===');
+const base58 = (0, index_js_1.encode)(bytes, 'base58');
+const base64url = (0, index_js_1.convert)(base58, 'base58', 'base64url');
 console.table({
     bytes: bytes.toString('utf8'),
-    base32encoded,
-    base58encoded,
-    base64encoded,
-    isValidAsBase64,
-    decoded: decoded.toString('utf8'),
+    base58,
+    base64url,
+    valid: (0, index_js_1.validate)(base64url, 'base64url'),
+    decoded: (0, index_js_1.decode)(base64url, 'base64url').toString('utf8'),
+});
+// validate() agrees with decode(): it checks length, padding and canonicality.
+console.log('\n=== Rejected input ===');
+console.table({
+    "'Zm8=' (canonical)": (0, index_js_1.validate)('Zm8=', 'base64'),
+    "'Zm9=' (spare bits set)": (0, index_js_1.validate)('Zm9=', 'base64'),
+    "'Zm9vd' (5 characters)": (0, index_js_1.validate)('Zm9vd', 'base64'),
+});
+// Crockford's Base32 reads what a person is likely to have written down.
+console.log('\n=== Crockford ===');
+const crockford = (0, index_js_1.encode)(bytes, 'base32crockfordcheck');
+console.table({
+    encoded: crockford,
+    'as typed': (0, index_js_1.decode)(`${crockford.slice(0, 4)}-${crockford.slice(4)}`.toLowerCase(), 'base32crockfordcheck').toString('utf8'),
+    'one character changed': (0, index_js_1.validate)(`${crockford.slice(0, -2)}Z${crockford.slice(-1)}`, 'base32crockfordcheck'),
+});
+// Codecs, and a custom alphabet.
+console.log('\n=== Codecs and custom alphabets ===');
+const binary = (0, index_js_1.createCodec)('01');
+const adobe = (0, index_js_1.createCodec)({
+    alphabet: index_js_1.Chars.Ascii85,
+    algorithm: 'block85',
+    zeroShortcut: true,
+    delimiters: true,
 });
-// Using Codecs object
-console.log('\n=== Codecs API ===');
-const encoded = index_js_1.Codecs.base58.encode(bytes);
-const converted = index_js_1.Codecs.base58.convertTo(index_js_1.Codecs.base64url, encoded);
 console.table({
-    original: bytes.toString('utf8'),
-    base58: encoded,
-    base64url: converted,
-    valid: index_js_1.Codecs.base64url.validate(converted),
+    'Codecs.base58': index_js_1.Codecs.base58.encode(bytes),
+    'binary of [5]': binary.encode(Uint8Array.of(5)),
+    'adobe ascii85': adobe.encode(bytes),
 });
 //# sourceMappingURL=example.js.map

package/dist/cjs/example.js.map

@@ -1 +1 @@
-{"version":3,"file":"example.js","sourceRoot":"","sources":["../../src/example.ts"],"names":[],"mappings":";;AAAA,6CAAqC;AACrC,yCAAuE;AAEvE,iBAAiB;AACjB,MAAM,KAAK,GAAG,oBAAM,CAAC,IAAI,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC;AAEnD,4BAA4B;AAC5B,MAAM,aAAa,GAAG,IAAA,iBAAM,EAAC,KAAK,EAAE,iBAAiB,CAAC,CAAC;AACvD,MAAM,aAAa,GAAG,IAAA,kBAAO,EAAC,aAAa,EAAE,iBAAiB,EAAE,QAAQ,CAAC,CAAC;AAC1E,MAAM,aAAa,GAAG,IAAA,kBAAO,EAAC,aAAa,EAAE,QAAQ,EAAE,WAAW,CAAC,CAAC;AACpE,MAAM,eAAe,GAAG,IAAA,mBAAQ,EAAC,aAAa,EAAE,WAAW,CAAC,CAAC;AAC7D,MAAM,OAAO,GAAG,IAAA,iBAAM,EAAC,aAAa,EAAE,WAAW,CAAC,CAAC;AAEnD,OAAO,CAAC,GAAG,CAAC,sBAAsB,CAAC,CAAC;AACpC,OAAO,CAAC,KAAK,CAAC;IACZ,KAAK,EAAE,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC;IAC7B,aAAa;IACb,aAAa;IACb,aAAa;IACb,eAAe;IACf,OAAO,EAAE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC;CAClC,CAAC,CAAC;AAEH,sBAAsB;AACtB,OAAO,CAAC,GAAG,CAAC,sBAAsB,CAAC,CAAC;AACpC,MAAM,OAAO,GAAG,iBAAM,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AAC5C,MAAM,SAAS,GAAG,iBAAM,CAAC,MAAM,CAAC,SAAS,CAAC,iBAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;AACrE,OAAO,CAAC,KAAK,CAAC;IACZ,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC;IAChC,MAAM,EAAE,OAAO;IACf,SAAS,EAAE,SAAS;IACpB,KAAK,EAAE,iBAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,SAAS,CAAC;CAC5C,CAAC,CAAC"}
+{"version":3,"file":"example.js","sourceRoot":"","sources":["../../src/example.ts"],"names":[],"mappings":"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"}

package/dist/cjs/functions.d.ts

@@ -1,62 +1,58 @@
-import type { BaseName, DecodeOptions, BufferLike } from './types.js';
+import type { BufferLike, CodecSpec, DecodeOptions } from './types.js';
+import type { Buffer } from 'node:buffer';
+import { type BaseName } from './bases.js';
+/** A named encoding, or a spec describing one directly. */
+export type Base = BaseName | CodecSpec;
 /**
  * Encodes a buffer to a base-encoded string.
  *
  * @param buffer - Buffer or Uint8Array to encode
- * @param base - Base name (e.g., 'base58') or custom character set
- * @returns Encoded string
+ * @param base - Base name (e.g. `'base58'`) or a codec spec
  *
  * @example
  * ```typescript
- * // Node.js Buffer
- * const encoded = encode(Buffer.from('Hello'), 'base58');
- *
- * // Browser Uint8Array
- * const encoded = encode(new Uint8Array([72, 101, 108, 108, 111]), 'base58');
+ * encode(Buffer.from('fo'), 'base64');                        // 'Zm8='
+ * encode(Uint8Array.of(5), { alphabet: '01', algorithm: 'radix' }); // '101'
  * ```
  */
-export declare function encode(buffer: BufferLike, base: BaseName | string): string;
+export declare function encode(buffer: BufferLike, base: Base): string;
 /**
  * Decodes a base-encoded string to a buffer.
  *
  * @param encoded - String to decode
- * @param base - Base name (e.g., 'base58') or custom character set
- * @param options - Decode options (e.g., { size: 32 })
- * @returns Decoded buffer
+ * @param base - Base name (e.g. `'base58'`) or a codec spec
+ * @param options - Decode options, such as a required `size`
+ * @throws {InvalidCharacterError} If a character is not in the alphabet
+ * @throws {InvalidLengthError} If the length cannot encode a whole number of bytes
+ * @throws {NonCanonicalError} If spare bits are set and the codec is strict
+ * @throws {BufferSizeError} If the result does not have the requested `size`
  *
  * @example
  * ```typescript
- * const buffer = decode('9Ajdvz', 'base58');
- * const fixedSize = decode('9Ajdvz', 'base58', { size: 32 });
+ * decode('Zm8=', 'base64');              // Buffer('fo')
+ * decode('9Ajdvzr', 'base58', { size: 32 });
  * ```
  */
-export declare function decode(encoded: string, base: BaseName | string, options?: DecodeOptions): Buffer;
+export declare function decode(encoded: string, base: Base, options?: DecodeOptions): Buffer;
 /**
- * Converts a string from one base to another.
- *
- * @param input - String to convert
- * @param from - Source base name or character set
- * @param to - Target base name or character set
- * @returns Converted string
+ * Converts a string from one base to another, through the bytes they describe.
  *
  * @example
  * ```typescript
- * const base64 = convert('9Ajdvz', 'base58', 'base64url');
+ * convert('9Ajdvzr', 'base58', 'base64url');
+ * convert(legacy, 'radix64', 'base64'); // migrate data written by bufferbase 2
  * ```
  */
-export declare function convert(input: string, from: BaseName | string, to: BaseName | string): string;
+export declare function convert(input: string, from: Base, to: Base): string;
 /**
- * Validates if a string contains only valid characters for the specified base.
- *
- * @param input - String to validate
- * @param base - Base name or character set
- * @returns true if valid, false otherwise
+ * Reports whether `decode` would succeed for this input.
  *
  * @example
  * ```typescript
- * validate('9Ajdvz', 'base58'); // true
- * validate('0Ajdvz', 'base58'); // false ('0' is not in base58)
+ * validate('Zm8=', 'base64');  // true
+ * validate('Zm9=', 'base64');  // false — spare bits are not zero
+ * validate('Zm9vd', 'base64'); // false — 5 characters cannot be whole bytes
  * ```
  */
-export declare function validate(input: string, base: BaseName | string): boolean;
+export declare function validate(input: string, base: Base): boolean;
 //# sourceMappingURL=functions.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"functions.d.ts","sourceRoot":"","sources":["../../src/functions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAoBtE;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,MAAM,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,MAAM,CAE1E;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,GAAG,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,MAAM,CAEhG;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,GAAG,MAAM,EAAE,EAAE,EAAE,QAAQ,GAAG,MAAM,GAAG,MAAM,CAI7F;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,OAAO,CAExE"}
+{"version":3,"file":"functions.d.ts","sourceRoot":"","sources":["../../src/functions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AACvE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAe,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAC;AAGxD,2DAA2D;AAC3D,MAAM,MAAM,IAAI,GAAG,QAAQ,GAAG,SAAS,CAAC;AAExC;;;;;;;;;;;GAWG;AACH,wBAAgB,MAAM,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,GAAG,MAAM,CAE7D;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,MAAM,CAEnF;AAED;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,GAAG,MAAM,CAInE;AAED;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,GAAG,OAAO,CAE3D"}

package/dist/cjs/functions.js

@@ -4,90 +4,68 @@ exports.encode = encode;
 exports.decode = decode;
 exports.convert = convert;
 exports.validate = validate;
-const codec_js_1 = require("./codec.js");
 const bases_js_1 = require("./bases.js");
-// Cache for codec instances
-const codecCache = new Map();
-/**
- * Gets or creates a codec for the specified base.
- */
-function getCodec(base) {
-    const chars = (0, bases_js_1.resolveChars)(base);
-    let codec = codecCache.get(chars);
-    if (!codec) {
-        codec = new codec_js_1.Codec(chars);
-        codecCache.set(chars, codec);
-    }
-    return codec;
-}
+const codec_js_1 = require("./codec.js");
 /**
  * Encodes a buffer to a base-encoded string.
  *
  * @param buffer - Buffer or Uint8Array to encode
- * @param base - Base name (e.g., 'base58') or custom character set
- * @returns Encoded string
+ * @param base - Base name (e.g. `'base58'`) or a codec spec
  *
  * @example
  * ```typescript
- * // Node.js Buffer
- * const encoded = encode(Buffer.from('Hello'), 'base58');
- *
- * // Browser Uint8Array
- * const encoded = encode(new Uint8Array([72, 101, 108, 108, 111]), 'base58');
+ * encode(Buffer.from('fo'), 'base64');                        // 'Zm8='
+ * encode(Uint8Array.of(5), { alphabet: '01', algorithm: 'radix' }); // '101'
  * ```
  */
 function encode(buffer, base) {
-    return getCodec(base).encode(buffer);
+    return (0, codec_js_1.getCodec)((0, bases_js_1.resolveSpec)(base)).encode(buffer);
 }
 /**
  * Decodes a base-encoded string to a buffer.
  *
  * @param encoded - String to decode
- * @param base - Base name (e.g., 'base58') or custom character set
- * @param options - Decode options (e.g., { size: 32 })
- * @returns Decoded buffer
+ * @param base - Base name (e.g. `'base58'`) or a codec spec
+ * @param options - Decode options, such as a required `size`
+ * @throws {InvalidCharacterError} If a character is not in the alphabet
+ * @throws {InvalidLengthError} If the length cannot encode a whole number of bytes
+ * @throws {NonCanonicalError} If spare bits are set and the codec is strict
+ * @throws {BufferSizeError} If the result does not have the requested `size`
  *
  * @example
  * ```typescript
- * const buffer = decode('9Ajdvz', 'base58');
- * const fixedSize = decode('9Ajdvz', 'base58', { size: 32 });
+ * decode('Zm8=', 'base64');              // Buffer('fo')
+ * decode('9Ajdvzr', 'base58', { size: 32 });
  * ```
  */
 function decode(encoded, base, options) {
-    return getCodec(base).decode(encoded, options);
+    return (0, codec_js_1.getCodec)((0, bases_js_1.resolveSpec)(base)).decode(encoded, options);
 }
 /**
- * Converts a string from one base to another.
- *
- * @param input - String to convert
- * @param from - Source base name or character set
- * @param to - Target base name or character set
- * @returns Converted string
+ * Converts a string from one base to another, through the bytes they describe.
  *
  * @example
  * ```typescript
- * const base64 = convert('9Ajdvz', 'base58', 'base64url');
+ * convert('9Ajdvzr', 'base58', 'base64url');
+ * convert(legacy, 'radix64', 'base64'); // migrate data written by bufferbase 2
  * ```
  */
 function convert(input, from, to) {
-    const fromCodec = getCodec(from);
-    const toCodec = getCodec(to);
-    return fromCodec.convertTo(toCodec, input);
+    const source = (0, codec_js_1.getCodec)((0, bases_js_1.resolveSpec)(from));
+    const target = (0, codec_js_1.getCodec)((0, bases_js_1.resolveSpec)(to));
+    return source.convertTo(target, input);
 }
 /**
- * Validates if a string contains only valid characters for the specified base.
- *
- * @param input - String to validate
- * @param base - Base name or character set
- * @returns true if valid, false otherwise
+ * Reports whether `decode` would succeed for this input.
  *
  * @example
  * ```typescript
- * validate('9Ajdvz', 'base58'); // true
- * validate('0Ajdvz', 'base58'); // false ('0' is not in base58)
+ * validate('Zm8=', 'base64');  // true
+ * validate('Zm9=', 'base64');  // false — spare bits are not zero
+ * validate('Zm9vd', 'base64'); // false — 5 characters cannot be whole bytes
  * ```
  */
 function validate(input, base) {
-    return getCodec(base).validate(input);
+    return (0, codec_js_1.getCodec)((0, bases_js_1.resolveSpec)(base)).validate(input);
 }
 //# sourceMappingURL=functions.js.map

package/dist/cjs/functions.js.map

@@ -1 +1 @@
-{"version":3,"file":"functions.js","sourceRoot":"","sources":["../../src/functions.ts"],"names":[],"mappings":";;AAoCA,wBAEC;AAgBD,wBAEC;AAeD,0BAIC;AAeD,4BAEC;AA3FD,yCAAmC;AACnC,yCAA0C;AAE1C,4BAA4B;AAC5B,MAAM,UAAU,GAAG,IAAI,GAAG,EAAiB,CAAC;AAE5C;;GAEG;AACH,SAAS,QAAQ,CAAC,IAAuB;IACvC,MAAM,KAAK,GAAG,IAAA,uBAAY,EAAC,IAAI,CAAC,CAAC;IACjC,IAAI,KAAK,GAAG,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IAClC,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,KAAK,GAAG,IAAI,gBAAK,CAAC,KAAK,CAAC,CAAC;QACzB,UAAU,CAAC,GAAG,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IAC/B,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,SAAgB,MAAM,CAAC,MAAkB,EAAE,IAAuB;IAChE,OAAO,QAAQ,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;AACvC,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,SAAgB,MAAM,CAAC,OAAe,EAAE,IAAuB,EAAE,OAAuB;IACtF,OAAO,QAAQ,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;AACjD,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,OAAO,CAAC,KAAa,EAAE,IAAuB,EAAE,EAAqB;IACnF,MAAM,SAAS,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;IACjC,MAAM,OAAO,GAAG,QAAQ,CAAC,EAAE,CAAC,CAAC;IAC7B,OAAO,SAAS,CAAC,SAAS,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;AAC7C,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,QAAQ,CAAC,KAAa,EAAE,IAAuB;IAC7D,OAAO,QAAQ,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;AACxC,CAAC"}
+{"version":3,"file":"functions.js","sourceRoot":"","sources":["../../src/functions.ts"],"names":[],"mappings":";;AAoBA,wBAEC;AAmBD,wBAEC;AAWD,0BAIC;AAYD,4BAEC;AAtED,yCAAwD;AACxD,yCAAsC;AAKtC;;;;;;;;;;;GAWG;AACH,SAAgB,MAAM,CAAC,MAAkB,EAAE,IAAU;IACnD,OAAO,IAAA,mBAAQ,EAAC,IAAA,sBAAW,EAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;AACpD,CAAC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,SAAgB,MAAM,CAAC,OAAe,EAAE,IAAU,EAAE,OAAuB;IACzE,OAAO,IAAA,mBAAQ,EAAC,IAAA,sBAAW,EAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;AAC9D,CAAC;AAED;;;;;;;;GAQG;AACH,SAAgB,OAAO,CAAC,KAAa,EAAE,IAAU,EAAE,EAAQ;IACzD,MAAM,MAAM,GAAG,IAAA,mBAAQ,EAAC,IAAA,sBAAW,EAAC,IAAI,CAAC,CAAC,CAAC;IAC3C,MAAM,MAAM,GAAG,IAAA,mBAAQ,EAAC,IAAA,sBAAW,EAAC,EAAE,CAAC,CAAC,CAAC;IACzC,OAAO,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;AACzC,CAAC;AAED;;;;;;;;;GASG;AACH,SAAgB,QAAQ,CAAC,KAAa,EAAE,IAAU;IAChD,OAAO,IAAA,mBAAQ,EAAC,IAAA,sBAAW,EAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;AACrD,CAAC"}

package/dist/cjs/index.d.ts

@@ -1,9 +1,11 @@
-export type { BaseName, DecodeOptions, ICodec, BufferLike } from './types.js';
+export type { Algorithm, Block85Spec, BlockSpec, BufferLike, CodecSpec, DecodeOptions, ICodec, RadixSpec, } from './types.js';
+export type { BaseName } from './bases.js';
+export type { Base } from './functions.js';
 export type { CodecName } from './codecs.js';
-export { InvalidCharacterError, BufferSizeError, UnknownBaseError } from './errors.js';
-export { Codec, createCodec } from './codec.js';
-export { Chars, resolveChars, isBaseName } from './bases.js';
-export { encode, decode, convert, validate } from './functions.js';
+export { BufferSizeError, CheckSymbolError, InvalidCharacterError, InvalidCodecError, InvalidLengthError, NonCanonicalError, UnknownBaseError, ValueRangeError, } from './errors.js';
+export { Block85Codec, BlockCodec, Codec, RadixCodec, createCodec, getCodec } from './codec.js';
+export { Bases, Chars, isBaseName, resolveSpec } from './bases.js';
+export { convert, decode, encode, validate } from './functions.js';
 export { Codecs } from './codecs.js';
 export { BufferEncoder, Converter, Validator } from './bufferbase.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,YAAY,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC9E,YAAY,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAG7C,OAAO,EAAE,qBAAqB,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAGvF,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAGhD,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAG7D,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAGnE,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAGrC,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,YAAY,EACV,SAAS,EACT,WAAW,EACX,SAAS,EACT,UAAU,EACV,SAAS,EACT,aAAa,EACb,MAAM,EACN,SAAS,GACV,MAAM,YAAY,CAAC;AACpB,YAAY,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,YAAY,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAC3C,YAAY,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAG7C,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,qBAAqB,EACrB,iBAAiB,EACjB,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,EAChB,eAAe,GAChB,MAAM,aAAa,CAAC;AAGrB,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAGhG,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAGnE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAGnE,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAGrC,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/cjs/index.js

@@ -1,25 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Validator = exports.Converter = exports.BufferEncoder = exports.Codecs = exports.validate = exports.convert = exports.decode = exports.encode = exports.isBaseName = exports.resolveChars = exports.Chars = exports.createCodec = exports.Codec = exports.UnknownBaseError = exports.BufferSizeError = exports.InvalidCharacterError = 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, "InvalidCharacterError", { enumerable: true, get: function () { return errors_js_1.InvalidCharacterError; } });
 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; } });
-// Codec class and factory
+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; } });
-// Character sets and utilities
+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, "resolveChars", { enumerable: true, get: function () { return bases_js_1.resolveChars; } });
 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, "encode", { enumerable: true, get: function () { return functions_js_1.encode; } });
-Object.defineProperty(exports, "decode", { enumerable: true, get: function () { return functions_js_1.decode; } });
 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");

package/dist/cjs/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;AAIA,SAAS;AACT,yCAAuF;AAA9E,kHAAA,qBAAqB,OAAA;AAAE,4GAAA,eAAe,OAAA;AAAE,6GAAA,gBAAgB,OAAA;AAEjE,0BAA0B;AAC1B,uCAAgD;AAAvC,iGAAA,KAAK,OAAA;AAAE,uGAAA,WAAW,OAAA;AAE3B,+BAA+B;AAC/B,uCAA6D;AAApD,iGAAA,KAAK,OAAA;AAAE,wGAAA,YAAY,OAAA;AAAE,sGAAA,UAAU,OAAA;AAExC,sBAAsB;AACtB,+CAAmE;AAA1D,sGAAA,MAAM,OAAA;AAAE,sGAAA,MAAM,OAAA;AAAE,uGAAA,OAAO,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"}
+{"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,7 +1,7 @@
 {
   "name": "bufferbase",
-  "version": "2.0.0",
-  "description": "Buffer-to-BaseN Encoder, Decoder, Converter, and Validator",
+  "version": "3.0.1",
+  "description": "Buffer-to-BaseN encoding: RFC 4648 block encodings, Ascii85/Z85, and Base58-style radix conversion",
   "sideEffects": false,
   "type": "commonjs",
   "scripts": {
@@ -10,7 +10,8 @@
     "build:esm": "tsc -p tsconfig.json",
     "prepublishOnly": "bun run build",
     "example": "bun src/example.ts",
-    "test": "bun test"
+    "test": "bun test",
+    "release": "bin/release"
   },
   "devDependencies": {
     "@types/bun": "^1.1.0",
@@ -27,19 +28,23 @@
     "src"
   ],
   "keywords": [
-    "number",
     "encode",
+    "decode",
     "convert",
-    "decimal",
     "base",
+    "rfc4648",
     "base16",
+    "hex",
     "base32",
+    "base32hex",
     "crockford",
     "base36",
     "base58",
     "base64",
-    "Ascii85",
-    "base85"
+    "base64url",
+    "ascii85",
+    "z85",
+    "radix"
   ],
   "author": "misebox",
   "license": "ISC",