bufferbase 1.3.0 → 2.0.0

package/dist/esm/functions.d.ts

@@ -0,0 +1,62 @@
+import type { BaseName, DecodeOptions, BufferLike } from './types.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
+ *
+ * @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');
+ * ```
+ */
+export declare function encode(buffer: BufferLike, base: BaseName | string): 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
+ *
+ * @example
+ * ```typescript
+ * const buffer = decode('9Ajdvz', 'base58');
+ * const fixedSize = decode('9Ajdvz', 'base58', { size: 32 });
+ * ```
+ */
+export declare function decode(encoded: string, base: BaseName | string, 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
+ *
+ * @example
+ * ```typescript
+ * const base64 = convert('9Ajdvz', 'base58', 'base64url');
+ * ```
+ */
+export declare function convert(input: string, from: BaseName | string, to: BaseName | string): 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
+ *
+ * @example
+ * ```typescript
+ * validate('9Ajdvz', 'base58'); // true
+ * validate('0Ajdvz', 'base58'); // false ('0' is not in base58)
+ * ```
+ */
+export declare function validate(input: string, base: BaseName | string): boolean;
+//# sourceMappingURL=functions.d.ts.map

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

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

package/dist/esm/functions.js

@@ -0,0 +1,87 @@
+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;
+}
+/**
+ * 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
+ *
+ * @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');
+ * ```
+ */
+export function encode(buffer, base) {
+    return getCodec(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
+ *
+ * @example
+ * ```typescript
+ * const buffer = decode('9Ajdvz', 'base58');
+ * const fixedSize = decode('9Ajdvz', 'base58', { size: 32 });
+ * ```
+ */
+export function decode(encoded, base, options) {
+    return getCodec(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
+ *
+ * @example
+ * ```typescript
+ * const base64 = convert('9Ajdvz', 'base58', 'base64url');
+ * ```
+ */
+export function convert(input, from, to) {
+    const fromCodec = getCodec(from);
+    const toCodec = getCodec(to);
+    return fromCodec.convertTo(toCodec, 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
+ *
+ * @example
+ * ```typescript
+ * validate('9Ajdvz', 'base58'); // true
+ * validate('0Ajdvz', 'base58'); // false ('0' is not in base58)
+ * ```
+ */
+export function validate(input, base) {
+    return getCodec(base).validate(input);
+}
+//# sourceMappingURL=functions.js.map

package/dist/esm/functions.js.map

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

package/dist/esm/index.d.ts

@@ -1,2 +1,9 @@
-export { Chars, BufferEncoder, Converter, InvalidCharacterError, Validator, validate, } from './bufferbase.js';
+export type { BaseName, DecodeOptions, ICodec, BufferLike } from './types.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 { 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":"AAAA,OAAO,EACL,KAAK,EACL,aAAa,EACb,SAAS,EACT,qBAAqB,EACrB,SAAS,EACT,QAAQ,GACT,MAAM,iBAAiB,CAAC"}
+{"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"}

package/dist/esm/index.js

@@ -1,2 +1,13 @@
-export { Chars, BufferEncoder, Converter, InvalidCharacterError, Validator, validate, } from './bufferbase.js';
+// 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';
+// Simple function API
+export { encode, decode, convert, validate } from './functions.js';
+// Pre-defined codecs (namespaced)
+export { Codecs } from './codecs.js';
+// Deprecated exports for backward compatibility
+export { BufferEncoder, Converter, Validator } from './bufferbase.js';
 //# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EACL,aAAa,EACb,SAAS,EACT,qBAAqB,EACrB,SAAS,EACT,QAAQ,GACT,MAAM,iBAAiB,CAAC"}
+{"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"}

package/dist/esm/package.json

@@ -1,22 +1,21 @@
 {
   "name": "bufferbase",
-  "version": "1.3.0",
+  "version": "2.0.0",
   "description": "Buffer-to-BaseN Encoder, Decoder, Converter, and Validator",
   "sideEffects": false,
   "type": "module",
   "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"
   },
   "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": {

package/dist/esm/types.d.ts

@@ -0,0 +1,107 @@
+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.
+ *
+ * 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
+ *
+ * @example
+ * ```typescript
+ * import { encode, decode } from 'bufferbase';
+ *
+ * const encoded = encode(Buffer.from('Hello'), 'base58');
+ * const decoded = decode(encoded, 'base58');
+ * ```
+ */
+export type BaseName = 'decimal' | 'base16' | 'hex' | 'base32' | 'base32crockford' | 'base36' | 'base52' | 'base58' | 'base64' | 'base64url' | 'base64xml' | 'base64xmlname' | 'ascii85' | 'base85' | 'z85';
+/**
+ * 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`.
+     */
+    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);
+ * ```
+ */
+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
+     */
+    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
+     */
+    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
+     */
+    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
+     */
+    convertTo(target: ICodec, input: string): string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/esm/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;;;;;;;;;;;;;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"}

package/dist/esm/types.js

@@ -0,0 +1,2 @@
+import { Buffer } from 'node:buffer';
+//# sourceMappingURL=types.js.map

package/dist/esm/types.js.map

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

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "bufferbase",
-  "version": "1.3.0",
+  "version": "2.0.0",
   "description": "Buffer-to-BaseN Encoder, Decoder, Converter, and Validator",
   "sideEffects": false,
   "type": "module",
-  "main": "./dist/cjs/index.mjs",
+  "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",
-  "types": "./dist/esm/index.d.mts",
+  "types": "./dist/esm/index.d.ts",
   "exports": {
     ".": {
       "import": {
@@ -21,18 +21,17 @@
     }
   },
   "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"
   },
   "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": {

package/src/bases.ts

@@ -0,0 +1,120 @@
+import type { BaseName } from './types.js';
+import { UnknownBaseError } from './errors.js';
+
+/**
+ * Character sets for common base encodings.
+ *
+ * Use these with `createCodec()` or the deprecated `BufferEncoder` class
+ * when you need direct access to character sets.
+ *
+ * @example
+ * ```typescript
+ * import { Chars, createCodec } from 'bufferbase';
+ *
+ * const codec = createCodec(Chars.Base58);
+ * const encoded = codec.encode(Buffer.from('Hello'));
+ * ```
+ */
+export const Chars = {
+  /** Base 10: 0-9 */
+  Decimal: '0123456789',
+  /** Hexadecimal: 0-9A-F */
+  Base16: '0123456789ABCDEF',
+  /** RFC 4648 Base32: A-Z2-7 */
+  Base32: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567',
+  /** 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',
+  /** Standard Base64: A-Za-z0-9+/ */
+  Base64: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
+  /** 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 encoding */
+  Ascii85: '!"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstu',
+  /** Base85 encoding */
+  Base85: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!#$%&()*+-;<=>?@^_`{|}~',
+  /** ZeroMQ Z85 encoding */
+  Z85: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.-:+=^!/*?&<>()[]{}@%$#',
+} as const;
+
+/**
+ * Internal mapping from base names to character sets.
+ * @internal
+ */
+const baseNameToChars: Record<BaseName, string> = {
+  decimal: Chars.Decimal,
+  base16: Chars.Base16,
+  hex: Chars.Base16,
+  base32: Chars.Base32,
+  base32crockford: Chars.Base32Crockford,
+  base36: Chars.Base36,
+  base52: Chars.Base52,
+  base58: Chars.Base58,
+  base64: Chars.Base64,
+  base64url: Chars.Base64Url,
+  base64xml: Chars.Base64Xml,
+  base64xmlname: Chars.Base64XmlName,
+  ascii85: Chars.Ascii85,
+  base85: Chars.Base85,
+  z85: Chars.Z85,
+};
+
+/**
+ * Resolves a base name or character set string to a character set.
+ *
+ * This function is used internally by the function API to convert
+ * base names (like `'base58'`) to their character sets.
+ *
+ * @param base - Base name (e.g., `'base58'`) or custom character set string
+ * @returns The character set string
+ * @throws {UnknownBaseError} If base name is not recognized and string length <= 15
+ *
+ * @example
+ * ```typescript
+ * import { resolveChars } from 'bufferbase';
+ *
+ * resolveChars('base58'); // Returns Bitcoin alphabet
+ * resolveChars('0123456789ABCDEF'); // Returns the string as-is (custom charset)
+ * resolveChars('invalid'); // Throws UnknownBaseError
+ * ```
+ */
+export function resolveChars(base: BaseName | string): string {
+  const normalized = base.toLowerCase() as BaseName;
+  if (normalized in baseNameToChars) {
+    return baseNameToChars[normalized];
+  }
+  // If not a known base name, treat as custom character set
+  // (must be longer than 15 chars to distinguish from typos)
+  if (base.length > 15) {
+    return base;
+  }
+  throw new UnknownBaseError(base);
+}
+
+/**
+ * Checks if a string is a valid base name.
+ *
+ * @param value - The string to check
+ * @returns `true` if the value is a valid `BaseName`, `false` otherwise
+ *
+ * @example
+ * ```typescript
+ * import { isBaseName } from 'bufferbase';
+ *
+ * isBaseName('base58'); // true
+ * isBaseName('BASE58'); // true (case-insensitive)
+ * isBaseName('unknown'); // false
+ * ```
+ */
+export function isBaseName(value: string): value is BaseName {
+  return value.toLowerCase() in baseNameToChars;
+}

package/src/bufferbase.test.ts

@@ -1,53 +1,49 @@
 import { Chars, BufferEncoder } from './bufferbase.js';
 import { Buffer } from 'node:buffer';
-import test from 'node:test'; // ①
-import assert from 'node:assert';
+import { describe, test, expect } from 'bun:test';
 
-test('BufferEncoder', async (t) => {
-  await t.test(
-    'encodes and decodes a string correctly with base58chars',
-    () => {
-      const encoder = new BufferEncoder(Chars.Base58);
-      const buffer = Buffer.from('Hello, World!', 'utf8');
+describe('BufferEncoder', () => {
+  test('encodes and decodes a string correctly with base58chars', () => {
+    const encoder = new BufferEncoder(Chars.Base58);
+    const buffer = Buffer.from('Hello, World!', 'utf8');
 
-      const encoded = encoder.encode(buffer);
-      const decoded = encoder.decode(encoded);
+    const encoded = encoder.encode(buffer);
+    const decoded = encoder.decode(encoded);
 
-      assert.strictEqual(decoded.toString('utf8'), 'Hello, World!');
-    }
-  );
+    expect(decoded.toString('utf8')).toBe('Hello, World!');
+  });
 
-  await t.test('handles empty buffer correctly', () => {
+  test('handles empty buffer correctly', () => {
     const encoder = new BufferEncoder(Chars.Base58);
     const buffer = Buffer.alloc(0);
 
     const encoded = encoder.encode(buffer);
     const decoded = encoder.decode(encoded);
 
-    assert.strictEqual(decoded.toString('utf8'), '');
+    expect(decoded.toString('utf8')).toBe('');
   });
 
-  await t.test('handles long buffer correctly', () => {
+  test('handles long buffer correctly', () => {
     const encoder = new BufferEncoder(Chars.Base58);
     const buffer = Buffer.from('Hello, World!'.repeat(100), 'utf8');
 
     const encoded = encoder.encode(buffer);
     const decoded = encoder.decode(encoded);
 
-    assert.strictEqual(decoded.toString('utf8'), 'Hello, World!'.repeat(100));
+    expect(decoded.toString('utf8')).toBe('Hello, World!'.repeat(100));
   });
 
-  await t.test('handles bufferSize argument correctly', () => {
+  test('handles bufferSize argument correctly', () => {
     const encoder = new BufferEncoder(Chars.Base58);
     const buffer = Buffer.alloc(0);
 
     const encoded = encoder.encode(buffer);
     const decoded = encoder.decode(encoded, 4);
 
-    assert.strictEqual(decoded.toString('hex'), '00000000');
+    expect(decoded.toString('hex')).toBe('00000000');
   });
 
-  await t.test('encode and decode various chars correctly', () => {
+  test('encode and decode various chars correctly', () => {
     for (const charTable of Object.values(Chars)) {
       const encoder = new BufferEncoder(charTable);
       const buffer = Buffer.from('Hello, World!', 'utf8');
@@ -55,11 +51,11 @@ test('BufferEncoder', async (t) => {
       const encoded = encoder.encode(buffer);
       const decoded = encoder.decode(encoded);
 
-      assert.strictEqual(decoded.toString('utf8'), 'Hello, World!');
+      expect(decoded.toString('utf8')).toBe('Hello, World!');
     }
   });
 
-  await t.test('handles binary powers from 1 to 63 correctly', () => {
+  test('handles binary powers from 1 to 63 correctly', () => {
     const encoder = new BufferEncoder(Chars.Base58);
     for (let i = 0; i < 64; i++) {
       const buffer = Buffer.alloc(8);
@@ -68,14 +64,35 @@ test('BufferEncoder', async (t) => {
       const encoded = encoder.encode(buffer);
       const decoded = encoder.decode(encoded, 8);
       const result = decoded.readBigInt64BE();
-      console.log(encoded, result);
-      assert.strictEqual(result, num);
+      expect(result).toBe(num);
     }
   });
-  await t.test('throws error on invalid characters in decode', () => {
-    assert.throws(() => {
+
+  test('throws error on invalid characters in decode', () => {
+    expect(() => {
       const encoder = new BufferEncoder(Chars.Base58);
       encoder.decode('InvalidString!');
-    }, new Error('Invalid character found'));
+    }).toThrow(/Invalid character found/);
+  });
+
+  test('encodes Uint8Array correctly', () => {
+    const encoder = new BufferEncoder(Chars.Base58);
+    const uint8Array = new Uint8Array([72, 101, 108, 108, 111]); // 'Hello'
+    const buffer = Buffer.from('Hello', 'utf8');
+
+    const encodedFromUint8 = encoder.encode(uint8Array);
+    const encodedFromBuffer = encoder.encode(buffer);
+
+    expect(encodedFromUint8).toBe(encodedFromBuffer);
+  });
+
+  test('encodes Uint8Array with leading zeros correctly', () => {
+    const encoder = new BufferEncoder(Chars.Base58);
+    const uint8Array = new Uint8Array([0, 0, 1, 2, 3]);
+
+    const encoded = encoder.encode(uint8Array);
+    const decoded = encoder.decode(encoded);
+
+    expect(Array.from(decoded)).toEqual([0, 0, 1, 2, 3]);
   });
 });