bufferbase 2.0.0 → 3.0.0

package/dist/esm/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/esm/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/esm/functions.js

@@ -1,87 +1,65 @@
-import { Codec } from './codec.js';
-import { resolveChars } from './bases.js';
-// Cache for codec instances
-const codecCache = new Map();
-/**
- * Gets or creates a codec for the specified base.
- */
-function getCodec(base) {
-    const chars = resolveChars(base);
-    let codec = codecCache.get(chars);
-    if (!codec) {
-        codec = new Codec(chars);
-        codecCache.set(chars, codec);
-    }
-    return codec;
-}
+import { resolveSpec } from './bases.js';
+import { getCodec } from './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'
  * ```
  */
 export function encode(buffer, base) {
-    return getCodec(base).encode(buffer);
+    return getCodec(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 });
  * ```
  */
 export function decode(encoded, base, options) {
-    return getCodec(base).decode(encoded, options);
+    return getCodec(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
  * ```
  */
 export function convert(input, from, to) {
-    const fromCodec = getCodec(from);
-    const toCodec = getCodec(to);
-    return fromCodec.convertTo(toCodec, input);
+    const source = getCodec(resolveSpec(from));
+    const target = getCodec(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
  * ```
  */
 export function validate(input, base) {
-    return getCodec(base).validate(input);
+    return getCodec(resolveSpec(base)).validate(input);
 }
 //# sourceMappingURL=functions.js.map

package/dist/esm/functions.js.map

@@ -1 +1 @@
-{"version":3,"file":"functions.js","sourceRoot":"","sources":["../../src/functions.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE1C,4BAA4B;AAC5B,MAAM,UAAU,GAAG,IAAI,GAAG,EAAiB,CAAC;AAE5C;;GAEG;AACH,SAAS,QAAQ,CAAC,IAAuB;IACvC,MAAM,KAAK,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC;IACjC,IAAI,KAAK,GAAG,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IAClC,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,KAAK,GAAG,IAAI,KAAK,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,MAAM,UAAU,MAAM,CAAC,MAAkB,EAAE,IAAuB;IAChE,OAAO,QAAQ,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;AACvC,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,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,MAAM,UAAU,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,MAAM,UAAU,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":"AAEA,OAAO,EAAE,WAAW,EAAiB,MAAM,YAAY,CAAC;AACxD,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAKtC;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,MAAM,CAAC,MAAkB,EAAE,IAAU;IACnD,OAAO,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;AACpD,CAAC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,MAAM,CAAC,OAAe,EAAE,IAAU,EAAE,OAAuB;IACzE,OAAO,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;AAC9D,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,OAAO,CAAC,KAAa,EAAE,IAAU,EAAE,EAAQ;IACzD,MAAM,MAAM,GAAG,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC;IAC3C,MAAM,MAAM,GAAG,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC,CAAC;IACzC,OAAO,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;AACzC,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,QAAQ,CAAC,KAAa,EAAE,IAAU;IAChD,OAAO,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;AACrD,CAAC"}

package/dist/esm/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/esm/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/esm/index.js

@@ -1,11 +1,11 @@
 // Errors
-export { InvalidCharacterError, BufferSizeError, UnknownBaseError } from './errors.js';
-// Codec class and factory
-export { Codec, createCodec } from './codec.js';
-// Character sets and utilities
-export { Chars, resolveChars, isBaseName } from './bases.js';
+export { BufferSizeError, CheckSymbolError, InvalidCharacterError, InvalidCodecError, InvalidLengthError, NonCanonicalError, UnknownBaseError, ValueRangeError, } from './errors.js';
+// Codec implementations and factory
+export { Block85Codec, BlockCodec, Codec, RadixCodec, createCodec, getCodec } from './codec.js';
+// Character sets, encoding definitions, and lookup helpers
+export { Bases, Chars, isBaseName, resolveSpec } from './bases.js';
 // Simple function API
-export { encode, decode, convert, validate } from './functions.js';
+export { convert, decode, encode, validate } from './functions.js';
 // Pre-defined codecs (namespaced)
 export { Codecs } from './codecs.js';
 // Deprecated exports for backward compatibility

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAIA,SAAS;AACT,OAAO,EAAE,qBAAqB,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEvF,0BAA0B;AAC1B,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEhD,+BAA+B;AAC/B,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7D,sBAAsB;AACtB,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAEnE,kCAAkC;AAClC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,gDAAgD;AAChD,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAeA,SAAS;AACT,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,qBAAqB,EACrB,iBAAiB,EACjB,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,EAChB,eAAe,GAChB,MAAM,aAAa,CAAC;AAErB,oCAAoC;AACpC,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEhG,2DAA2D;AAC3D,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEnE,sBAAsB;AACtB,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAEnE,kCAAkC;AAClC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,gDAAgD;AAChD,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/esm/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bufferbase",
-  "version": "2.0.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": "module",
   "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,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/esm/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/esm/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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bufferbase",
-  "version": "2.0.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": "module",
   "main": "./dist/cjs/index.js",
@@ -26,7 +26,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",
@@ -43,19 +44,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",