bufferbase 1.2.3 → 2.0.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C;;OAEG;gBACS,IAAI,CAAC,EAAE,MAAM;CAK1B;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,eAAgB,SAAQ,KAAK;IACxC;;;OAGG;gBACS,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;CAI7C;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;IACzC;;OAEG;gBACS,IAAI,EAAE,MAAM;CAIzB"}

package/dist/esm/errors.js

@@ -0,0 +1,86 @@
+/**
+ * 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: '!'"
+ *   }
+ * }
+ * ```
+ */
+export class InvalidCharacterError extends Error {
+    /**
+     * @param char - The invalid character that was encountered (optional)
+     */
+    constructor(char) {
+        const message = char ? `Invalid character found: '${char}'` : 'Invalid character found';
+        super(message);
+        this.name = '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"
+ *   }
+ * }
+ * ```
+ */
+export class BufferSizeError extends Error {
+    /**
+     * @param actual - The actual decoded buffer size
+     * @param expected - The expected (specified) buffer size
+     */
+    constructor(actual, expected) {
+        super(`Buffer size ${actual} exceeds specified size ${expected}`);
+        this.name = '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'"
+ *   }
+ * }
+ * ```
+ */
+export class UnknownBaseError extends Error {
+    /**
+     * @param name - The unknown base name that was provided
+     */
+    constructor(name) {
+        super(`Unknown base encoding: '${name}'`);
+        this.name = 'UnknownBaseError';
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/esm/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../src/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,OAAO,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;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,OAAO,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;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,OAAO,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"}

package/dist/esm/example.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=example.d.ts.map

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

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

package/dist/esm/example.js

@@ -0,0 +1,30 @@
+import { Buffer } from 'node:buffer';
+import { encode, decode, convert, validate, Codecs } from './index.js';
+// Example buffer
+const bytes = Buffer.from('Hello, World!', 'utf8');
+// Using simple function API
+const base32encoded = encode(bytes, 'base32crockford');
+const base58encoded = convert(base32encoded, 'base32crockford', 'base58');
+const base64encoded = convert(base58encoded, 'base58', 'base64url');
+const isValidAsBase64 = validate(base64encoded, 'base64url');
+const decoded = decode(base64encoded, 'base64url');
+console.log('=== Function API ===');
+console.table({
+    bytes: bytes.toString('utf8'),
+    base32encoded,
+    base58encoded,
+    base64encoded,
+    isValidAsBase64,
+    decoded: decoded.toString('utf8'),
+});
+// Using Codecs object
+console.log('\n=== Codecs API ===');
+const encoded = Codecs.base58.encode(bytes);
+const converted = Codecs.base58.convertTo(Codecs.base64url, encoded);
+console.table({
+    original: bytes.toString('utf8'),
+    base58: encoded,
+    base64url: converted,
+    valid: Codecs.base64url.validate(converted),
+});
+//# sourceMappingURL=example.js.map

package/dist/esm/example.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"example.js","sourceRoot":"","sources":["../../src/example.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAEvE,iBAAiB;AACjB,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC;AAEnD,4BAA4B;AAC5B,MAAM,aAAa,GAAG,MAAM,CAAC,KAAK,EAAE,iBAAiB,CAAC,CAAC;AACvD,MAAM,aAAa,GAAG,OAAO,CAAC,aAAa,EAAE,iBAAiB,EAAE,QAAQ,CAAC,CAAC;AAC1E,MAAM,aAAa,GAAG,OAAO,CAAC,aAAa,EAAE,QAAQ,EAAE,WAAW,CAAC,CAAC;AACpE,MAAM,eAAe,GAAG,QAAQ,CAAC,aAAa,EAAE,WAAW,CAAC,CAAC;AAC7D,MAAM,OAAO,GAAG,MAAM,CAAC,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,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AAC5C,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,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,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,SAAS,CAAC;CAC5C,CAAC,CAAC"}

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

@@ -0,0 +1,9 @@
+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

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

package/dist/esm/index.js

@@ -0,0 +1,13 @@
+// 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

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

package/dist/esm/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "bufferbase",
+  "version": "2.0.0",
+  "description": "Buffer-to-BaseN Encoder, Decoder, Converter, and Validator",
+  "sideEffects": false,
+  "type": "module",
+  "scripts": {
+    "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": "bun run build",
+    "example": "bun src/example.ts",
+    "test": "bun test"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.1.0",
+    "@types/node": "^20.11.5",
+    "tsconfig-to-dual-package": "^1.2.0",
+    "typescript": "^5.3.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/misebox/bufferbase.git"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "keywords": [
+    "number",
+    "encode",
+    "convert",
+    "decimal",
+    "base",
+    "base16",
+    "base32",
+    "crockford",
+    "base36",
+    "base58",
+    "base64",
+    "Ascii85",
+    "base85"
+  ],
+  "author": "misebox",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/misebox/bufferbase/issues"
+  },
+  "homepage": "https://github.com/misebox/bufferbase#readme"
+}

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,22 +1,37 @@
 {
   "name": "bufferbase",
-  "version": "1.2.3",
+  "version": "2.0.0",
   "description": "Buffer-to-BaseN Encoder, Decoder, Converter, and Validator",
-  "type": "module",
-  "types": "./dist/index.d.ts",
   "sideEffects": false,
-  "main": "./dist/index.js",
-  "exports": "./dist/index.js",
+  "type": "module",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/esm/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      },
+      "default": "./dist/cjs/index.js"
+    }
+  },
   "scripts": {
-    "build": "tsc",
-    "prepublishOnly": "npm run build",
-    "example": "tsx src/example.ts",
-    "test": "tsx --test src/*.test.ts"
+    "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": "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",
-    "tsx": "^4.7.0",
+    "tsconfig-to-dual-package": "^1.2.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;
+}