bufferbase 1.2.3 → 2.0.0

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

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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;
+}
+/**
+ * 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');
+ * ```
+ */
+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 });
+ * ```
+ */
+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');
+ * ```
+ */
+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)
+ * ```
+ */
+function validate(input, base) {
+    return getCodec(base).validate(input);
+}
+//# sourceMappingURL=functions.js.map

package/dist/cjs/functions.js.map

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

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

@@ -0,0 +1,32 @@
+"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;
+// 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, "UnknownBaseError", { enumerable: true, get: function () { return errors_js_1.UnknownBaseError; } });
+// Codec class and factory
+var codec_js_1 = require("./codec.js");
+Object.defineProperty(exports, "Codec", { enumerable: true, get: function () { return codec_js_1.Codec; } });
+Object.defineProperty(exports, "createCodec", { enumerable: true, get: function () { return codec_js_1.createCodec; } });
+// Character sets and utilities
+var bases_js_1 = require("./bases.js");
+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; } });
+// 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, "validate", { enumerable: true, get: function () { return functions_js_1.validate; } });
+// Pre-defined codecs (namespaced)
+var codecs_js_1 = require("./codecs.js");
+Object.defineProperty(exports, "Codecs", { enumerable: true, get: function () { return codecs_js_1.Codecs; } });
+// Deprecated exports for backward compatibility
+var bufferbase_js_1 = require("./bufferbase.js");
+Object.defineProperty(exports, "BufferEncoder", { enumerable: true, get: function () { return bufferbase_js_1.BufferEncoder; } });
+Object.defineProperty(exports, "Converter", { enumerable: true, get: function () { return bufferbase_js_1.Converter; } });
+Object.defineProperty(exports, "Validator", { enumerable: true, get: function () { return bufferbase_js_1.Validator; } });
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

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

package/dist/cjs/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "bufferbase",
+  "version": "2.0.0",
+  "description": "Buffer-to-BaseN Encoder, Decoder, Converter, and Validator",
+  "sideEffects": false,
+  "type": "commonjs",
+  "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/cjs/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/cjs/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC;;;;;;;;;;;;;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/cjs/types.js

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

package/dist/cjs/types.js.map

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

package/dist/esm/bases.d.ts

@@ -0,0 +1,82 @@
+import type { BaseName } from './types.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 declare const Chars: {
+    /** Base 10: 0-9 */
+    readonly Decimal: "0123456789";
+    /** Hexadecimal: 0-9A-F */
+    readonly Base16: "0123456789ABCDEF";
+    /** RFC 4648 Base32: A-Z2-7 */
+    readonly Base32: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+    /** Crockford's Base32: 0-9A-HJKMNP-TV-Z (no I, L, O, U) */
+    readonly Base32Crockford: "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+    /** Alphanumeric: 0-9A-Z */
+    readonly Base36: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    /** Letters only: A-Za-z */
+    readonly Base52: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+    /** Bitcoin alphabet: 1-9A-HJ-NP-Za-km-z (no 0, O, I, l) */
+    readonly Base58: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+    /** Standard Base64: A-Za-z0-9+/ */
+    readonly Base64: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    /** URL-safe Base64: A-Za-z0-9-_ */
+    readonly Base64Url: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+    /** XML token Base64: A-Za-z0-9._ */
+    readonly Base64Xml: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._";
+    /** XML name Base64: A-Za-z0-9_: */
+    readonly Base64XmlName: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_:";
+    /** ASCII85 encoding */
+    readonly Ascii85: "!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstu";
+    /** Base85 encoding */
+    readonly Base85: "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!#$%&()*+-;<=>?@^_`{|}~";
+    /** ZeroMQ Z85 encoding */
+    readonly Z85: "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.-:+=^!/*?&<>()[]{}@%$#";
+};
+/**
+ * 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 declare function resolveChars(base: BaseName | string): string;
+/**
+ * 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 declare function isBaseName(value: string): value is BaseName;
+//# sourceMappingURL=bases.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bases.d.ts","sourceRoot":"","sources":["../../src/bases.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAG3C;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,KAAK;IAChB,mBAAmB;;IAEnB,0BAA0B;;IAE1B,8BAA8B;;IAE9B,2DAA2D;;IAE3D,2BAA2B;;IAE3B,2BAA2B;;IAE3B,2DAA2D;;IAE3D,mCAAmC;;IAEnC,mCAAmC;;IAEnC,oCAAoC;;IAEpC,mCAAmC;;IAEnC,uBAAuB;;IAEvB,sBAAsB;;IAEtB,0BAA0B;;CAElB,CAAC;AAwBX;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,MAAM,CAW5D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,QAAQ,CAE3D"}

package/dist/esm/bases.js

@@ -0,0 +1,116 @@
+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.-:+=^!/*?&<>()[]{}@%$#',
+};
+/**
+ * Internal mapping from base names to character sets.
+ * @internal
+ */
+const baseNameToChars = {
+    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) {
+    const normalized = base.toLowerCase();
+    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) {
+    return value.toLowerCase() in baseNameToChars;
+}
+//# sourceMappingURL=bases.js.map

package/dist/esm/bases.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bases.js","sourceRoot":"","sources":["../../src/bases.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/C;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG;IACnB,mBAAmB;IACnB,OAAO,EAAE,YAAY;IACrB,0BAA0B;IAC1B,MAAM,EAAE,kBAAkB;IAC1B,8BAA8B;IAC9B,MAAM,EAAE,kCAAkC;IAC1C,2DAA2D;IAC3D,eAAe,EAAE,kCAAkC;IACnD,2BAA2B;IAC3B,MAAM,EAAE,sCAAsC;IAC9C,2BAA2B;IAC3B,MAAM,EAAE,sDAAsD;IAC9D,2DAA2D;IAC3D,MAAM,EAAE,4DAA4D;IACpE,mCAAmC;IACnC,MAAM,EAAE,kEAAkE;IAC1E,mCAAmC;IACnC,SAAS,EAAE,kEAAkE;IAC7E,oCAAoC;IACpC,SAAS,EAAE,kEAAkE;IAC7E,mCAAmC;IACnC,aAAa,EAAE,kEAAkE;IACjF,uBAAuB;IACvB,OAAO,EAAE,uFAAuF;IAChG,sBAAsB;IACtB,MAAM,EAAE,uFAAuF;IAC/F,0BAA0B;IAC1B,GAAG,EAAE,uFAAuF;CACpF,CAAC;AAEX;;;GAGG;AACH,MAAM,eAAe,GAA6B;IAChD,OAAO,EAAE,KAAK,CAAC,OAAO;IACtB,MAAM,EAAE,KAAK,CAAC,MAAM;IACpB,GAAG,EAAE,KAAK,CAAC,MAAM;IACjB,MAAM,EAAE,KAAK,CAAC,MAAM;IACpB,eAAe,EAAE,KAAK,CAAC,eAAe;IACtC,MAAM,EAAE,KAAK,CAAC,MAAM;IACpB,MAAM,EAAE,KAAK,CAAC,MAAM;IACpB,MAAM,EAAE,KAAK,CAAC,MAAM;IACpB,MAAM,EAAE,KAAK,CAAC,MAAM;IACpB,SAAS,EAAE,KAAK,CAAC,SAAS;IAC1B,SAAS,EAAE,KAAK,CAAC,SAAS;IAC1B,aAAa,EAAE,KAAK,CAAC,aAAa;IAClC,OAAO,EAAE,KAAK,CAAC,OAAO;IACtB,MAAM,EAAE,KAAK,CAAC,MAAM;IACpB,GAAG,EAAE,KAAK,CAAC,GAAG;CACf,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,YAAY,CAAC,IAAuB;IAClD,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,EAAc,CAAC;IAClD,IAAI,UAAU,IAAI,eAAe,EAAE,CAAC;QAClC,OAAO,eAAe,CAAC,UAAU,CAAC,CAAC;IACrC,CAAC;IACD,0DAA0D;IAC1D,2DAA2D;IAC3D,IAAI,IAAI,CAAC,MAAM,GAAG,EAAE,EAAE,CAAC;QACrB,OAAO,IAAI,CAAC;IACd,CAAC;IACD,MAAM,IAAI,gBAAgB,CAAC,IAAI,CAAC,CAAC;AACnC,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,UAAU,CAAC,KAAa;IACtC,OAAO,KAAK,CAAC,WAAW,EAAE,IAAI,eAAe,CAAC;AAChD,CAAC"}

package/dist/esm/bufferbase.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @deprecated Use the new API instead:
+ * - `encode(buffer, 'base58')` or `base58.encode(buffer)`
+ * - `decode(encoded, 'base58')` or `base58.decode(encoded)`
+ * - `convert(input, 'base58', 'base64')` or `base58.convertTo(base64, input)`
+ * - `validate(input, 'base58')` or `base58.validate(input)`
+ */
+import { Buffer } from 'node:buffer';
+import { InvalidCharacterError, BufferSizeError } from './errors.js';
+export { Chars } from './bases.js';
+export { InvalidCharacterError, BufferSizeError };
+/**
+ * @deprecated Use `Codec` or `createCodec()` instead.
+ */
+export declare class BufferEncoder {
+    private baseChars;
+    private codec;
+    constructor(baseChars: string);
+    encode(buffer: Buffer): string;
+    decode(encoded: string, bufferSize?: number): Buffer;
+}
+/**
+ * @deprecated Use `convert()` function or `codec.convertTo()` instead.
+ */
+export declare class Converter {
+    decoder: BufferEncoder;
+    encoder: BufferEncoder;
+    constructor(inputBase: string, outputBase: string);
+    convert(input: string): string;
+}
+/**
+ * @deprecated Use `validate()` function or `codec.validate()` instead.
+ */
+export declare class Validator {
+    private codec;
+    constructor(inputBase: string);
+    validate(input: string): boolean;
+}
+/**
+ * @deprecated Use `validate()` from the main module instead.
+ */
+export declare const validate: (input: string, base: string) => boolean;
+//# sourceMappingURL=bufferbase.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bufferbase.d.ts","sourceRoot":"","sources":["../../src/bufferbase.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,OAAO,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAGrE,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAGnC,OAAO,EAAE,qBAAqB,EAAE,eAAe,EAAE,CAAC;AAElD;;GAEG;AACH,qBAAa,aAAa;IAGZ,OAAO,CAAC,SAAS;IAF7B,OAAO,CAAC,KAAK,CAAQ;gBAED,SAAS,EAAE,MAAM;IAIrC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAI9B,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM;CAGrD;AAED;;GAEG;AACH,qBAAa,SAAS;IACpB,OAAO,EAAE,aAAa,CAAC;IACvB,OAAO,EAAE,aAAa,CAAC;gBAEX,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;IAKjD,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;CAG/B;AAED;;GAEG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,KAAK,CAAQ;gBAET,SAAS,EAAE,MAAM;IAI7B,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;CAGjC;AAED;;GAEG;AACH,eAAO,MAAM,QAAQ,GAAI,OAAO,MAAM,EAAE,MAAM,MAAM,KAAG,OAEtD,CAAC"}