bufferbase 2.0.0 → 3.0.0

package/dist/esm/bases.js

@@ -1,25 +1,19 @@
 import { UnknownBaseError } from './errors.js';
 /**
- * Character sets for common base encodings.
+ * Character sets, ordered by value.
  *
- * 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'));
- * ```
+ * A character set does not by itself describe an encoding — see `Bases` for
+ * the alphabet/algorithm pairs that do.
  */
 export const Chars = {
     /** Base 10: 0-9 */
     Decimal: '0123456789',
-    /** Hexadecimal: 0-9A-F */
+    /** RFC 4648 Table 5 — Base16: 0-9A-F */
     Base16: '0123456789ABCDEF',
-    /** RFC 4648 Base32: A-Z2-7 */
+    /** RFC 4648 Table 3 — Base32: A-Z2-7 */
     Base32: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567',
+    /** RFC 4648 Table 4 — Base32 with extended hex alphabet: 0-9A-V */
+    Base32Hex: '0123456789ABCDEFGHIJKLMNOPQRSTUV',
     /** Crockford's Base32: 0-9A-HJKMNP-TV-Z (no I, L, O, U) */
     Base32Crockford: '0123456789ABCDEFGHJKMNPQRSTVWXYZ',
     /** Alphanumeric: 0-9A-Z */
@@ -28,89 +22,108 @@ export const Chars = {
     Base52: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz',
     /** Bitcoin alphabet: 1-9A-HJ-NP-Za-km-z (no 0, O, I, l) */
     Base58: '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz',
-    /** Standard Base64: A-Za-z0-9+/ */
+    /** RFC 4648 Table 1 — Base64: A-Za-z0-9+/ */
     Base64: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
-    /** URL-safe Base64: A-Za-z0-9-_ */
+    /** RFC 4648 Table 2 — 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 */
+    /** Ascii85: the 85 printable characters from `!` (0x21) to `u` (0x75) */
+    Ascii85: '!"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstu',
+    /** ZeroMQ Z85 (RFC 32): avoids the quote and backslash characters */
     Z85: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.-:+=^!/*?&<>()[]{}@%$#',
+    /** The five symbols Crockford's Base32 adds for its check symbol, giving a modulus of 37 */
+    CrockfordCheck: '*~$=U',
 };
+/** The characters Crockford's Base32 reads as the digit they resemble. */
+const CROCKFORD_ALIASES = { I: '1', L: '1', O: '0' };
 /**
- * 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.
+ * The encodings this package knows by name.
  *
- * @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
+ * Each entry pairs an alphabet with the algorithm that reads it, because the
+ * alphabet alone is ambiguous: `base64` and `radix64` share Table 1 but
+ * produce different strings for the same bytes.
  *
  * @example
  * ```typescript
- * import { resolveChars } from 'bufferbase';
+ * import { encode, Bases } from 'bufferbase';
  *
- * resolveChars('base58'); // Returns Bitcoin alphabet
- * resolveChars('0123456789ABCDEF'); // Returns the string as-is (custom charset)
- * resolveChars('invalid'); // Throws UnknownBaseError
+ * encode(Buffer.from('fo'), 'base64');  // 'Zm8='  — RFC 4648
+ * encode(Buffer.from('fo'), 'radix64'); // 'GZv'   — radix conversion
  * ```
  */
-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) {
+export const Bases = {
+    // Radix conversion. No external standard fixes these, so nothing here can
+    // disagree with one.
+    decimal: { alphabet: Chars.Decimal, algorithm: 'radix' },
+    base36: { alphabet: Chars.Base36, algorithm: 'radix', caseInsensitive: true },
+    base52: { alphabet: Chars.Base52, algorithm: 'radix' },
+    base58: { alphabet: Chars.Base58, algorithm: 'radix' },
+    /**
+     * Crockford's Base32, which specifies a notation for numbers rather than for
+     * byte streams, so a radix conversion is the right reading of it.
+     *
+     * Decoding accepts either case, reads `I` and `L` as `1` and `O` as `0`, and
+     * ignores hyphens.
+     */
+    base32crockford: {
+        alphabet: Chars.Base32Crockford,
+        algorithm: 'radix',
+        caseInsensitive: true,
+        aliases: CROCKFORD_ALIASES,
+        ignore: '-',
+    },
+    /** Crockford's Base32 carrying its trailing check symbol. */
+    base32crockfordcheck: {
+        alphabet: Chars.Base32Crockford,
+        algorithm: 'radix',
+        caseInsensitive: true,
+        aliases: CROCKFORD_ALIASES,
+        ignore: '-',
+        checkSymbols: Chars.CrockfordCheck,
+    },
+    // Bit-block encoding, RFC 4648.
+    base16: { alphabet: Chars.Base16, algorithm: 'block', pad: false, caseInsensitive: true },
+    hex: { alphabet: Chars.Base16, algorithm: 'block', pad: false, caseInsensitive: true },
+    base32: { alphabet: Chars.Base32, algorithm: 'block', caseInsensitive: true },
+    base32hex: { alphabet: Chars.Base32Hex, algorithm: 'block', caseInsensitive: true },
+    base64: { alphabet: Chars.Base64, algorithm: 'block' },
+    /** Unpadded, as used by JWT and other URL-facing formats. */
+    base64url: { alphabet: Chars.Base64Url, algorithm: 'block', pad: false },
+    base64xml: { alphabet: Chars.Base64Xml, algorithm: 'block', pad: false },
+    base64xmlname: { alphabet: Chars.Base64XmlName, algorithm: 'block', pad: false },
+    // Four bytes to five characters.
+    /** Ascii85 with the zero-block shortcut, matching Python's `a85encode`. */
+    ascii85: { alphabet: Chars.Ascii85, algorithm: 'block85', zeroShortcut: true },
+    /** ZeroMQ Z85, which has no padding and so encodes whole blocks only. */
+    z85: { alphabet: Chars.Z85, algorithm: 'block85', requireFullBlocks: true },
+    // Radix conversion over the RFC alphabets.
+    radix16: { alphabet: Chars.Base16, algorithm: 'radix' },
+    radix32: { alphabet: Chars.Base32, algorithm: 'radix' },
+    radix64: { alphabet: Chars.Base64, algorithm: 'radix' },
+    radix64url: { alphabet: Chars.Base64Url, algorithm: 'radix' },
+};
+/**
+ * Resolves a base name to its codec spec, and passes a spec through unchanged.
+ *
+ * @throws {UnknownBaseError} If the name is not one of `Bases`
+ */
+export function resolveSpec(base) {
+    if (typeof base !== 'string') {
         return base;
     }
-    throw new UnknownBaseError(base);
+    const spec = Bases[base.toLowerCase()];
+    if (spec === undefined) {
+        throw new UnknownBaseError(base);
+    }
+    return spec;
 }
 /**
- * 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
- * ```
+ * Checks whether a string names one of the encodings in `Bases`.
  */
 export function isBaseName(value) {
-    return value.toLowerCase() in baseNameToChars;
+    return value.toLowerCase() in Bases;
 }
 //# sourceMappingURL=bases.js.map

package/dist/esm/bases.js.map

@@ -1 +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"}
+{"version":3,"file":"bases.js","sourceRoot":"","sources":["../../src/bases.ts"],"names":[],"mappings":"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"}

package/dist/esm/bufferbase.d.ts

@@ -1,43 +1,37 @@
 /**
- * @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)`
+ * @deprecated Use the current API instead:
+ * - `encode(buffer, 'base58')` or `Codecs.base58.encode(buffer)`
+ * - `decode(encoded, 'base58')` or `Codecs.base58.decode(encoded)`
+ * - `convert(input, 'base58', 'base64')` or `Codecs.base58.convertTo(...)`
+ * - `validate(input, 'base58')` or `Codecs.base58.validate(input)`
+ *
+ * These classes take a bare alphabet, which always meant a radix conversion,
+ * so they keep behaving exactly as they did.
  */
-import { Buffer } from 'node:buffer';
-import { InvalidCharacterError, BufferSizeError } from './errors.js';
+import type { Buffer } from 'node:buffer';
+import type { BufferLike } from './types.js';
+/** @deprecated Import `Chars` from the package root. */
 export { Chars } from './bases.js';
-export { InvalidCharacterError, BufferSizeError };
-/**
- * @deprecated Use `Codec` or `createCodec()` instead.
- */
+/** @deprecated Import these from the package root. */
+export { BufferSizeError, InvalidCharacterError } from './errors.js';
+/** @deprecated Use `createCodec(alphabet)`. */
 export declare class BufferEncoder {
-    private baseChars;
-    private codec;
+    private readonly codec;
     constructor(baseChars: string);
-    encode(buffer: Buffer): string;
+    encode(buffer: BufferLike): string;
     decode(encoded: string, bufferSize?: number): Buffer;
 }
-/**
- * @deprecated Use `convert()` function or `codec.convertTo()` instead.
- */
+/** @deprecated Use `convert()` or `codec.convertTo()`. */
 export declare class Converter {
-    decoder: BufferEncoder;
-    encoder: BufferEncoder;
+    readonly decoder: BufferEncoder;
+    readonly encoder: BufferEncoder;
     constructor(inputBase: string, outputBase: string);
     convert(input: string): string;
 }
-/**
- * @deprecated Use `validate()` function or `codec.validate()` instead.
- */
+/** @deprecated Use `validate()` or `codec.validate()`. */
 export declare class Validator {
-    private codec;
+    private readonly 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

@@ -1 +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"}
+{"version":3,"file":"bufferbase.d.ts","sourceRoot":"","sources":["../../src/bufferbase.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAG7C,wDAAwD;AACxD,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC,sDAAsD;AACtD,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAErE,+CAA+C;AAC/C,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAa;gBAEvB,SAAS,EAAE,MAAM;IAI7B,MAAM,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM;IAIlC,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM;CAGrD;AAED,0DAA0D;AAC1D,qBAAa,SAAS;IACpB,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC;IAChC,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC;gBAEpB,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;IAKjD,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;CAG/B;AAED,0DAA0D;AAC1D,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAa;gBAEvB,SAAS,EAAE,MAAM;IAI7B,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;CAGjC"}

package/dist/esm/bufferbase.js

@@ -1,35 +1,31 @@
 /**
- * @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)`
+ * @deprecated Use the current API instead:
+ * - `encode(buffer, 'base58')` or `Codecs.base58.encode(buffer)`
+ * - `decode(encoded, 'base58')` or `Codecs.base58.decode(encoded)`
+ * - `convert(input, 'base58', 'base64')` or `Codecs.base58.convertTo(...)`
+ * - `validate(input, 'base58')` or `Codecs.base58.validate(input)`
+ *
+ * These classes take a bare alphabet, which always meant a radix conversion,
+ * so they keep behaving exactly as they did.
  */
-import { Buffer } from 'node:buffer';
-import { Codec } from './codec.js';
-import { InvalidCharacterError, BufferSizeError } from './errors.js';
-// Re-export Chars for backward compatibility
+import { RadixCodec } from './codec-radix.js';
+/** @deprecated Import `Chars` from the package root. */
 export { Chars } from './bases.js';
-// Re-export errors
-export { InvalidCharacterError, BufferSizeError };
-/**
- * @deprecated Use `Codec` or `createCodec()` instead.
- */
+/** @deprecated Import these from the package root. */
+export { BufferSizeError, InvalidCharacterError } from './errors.js';
+/** @deprecated Use `createCodec(alphabet)`. */
 export class BufferEncoder {
     constructor(baseChars) {
-        this.baseChars = baseChars;
-        this.codec = new Codec(baseChars);
+        this.codec = new RadixCodec({ alphabet: baseChars, algorithm: 'radix' });
     }
     encode(buffer) {
         return this.codec.encode(buffer);
     }
     decode(encoded, bufferSize) {
-        return this.codec.decode(encoded, bufferSize !== undefined ? { size: bufferSize } : undefined);
+        return this.codec.decode(encoded, bufferSize === undefined ? undefined : { size: bufferSize });
     }
 }
-/**
- * @deprecated Use `convert()` function or `codec.convertTo()` instead.
- */
+/** @deprecated Use `convert()` or `codec.convertTo()`. */
 export class Converter {
     constructor(inputBase, outputBase) {
         this.decoder = new BufferEncoder(inputBase);
@@ -39,21 +35,13 @@ export class Converter {
         return this.encoder.encode(this.decoder.decode(input));
     }
 }
-/**
- * @deprecated Use `validate()` function or `codec.validate()` instead.
- */
+/** @deprecated Use `validate()` or `codec.validate()`. */
 export class Validator {
     constructor(inputBase) {
-        this.codec = new Codec(inputBase);
+        this.codec = new RadixCodec({ alphabet: inputBase, algorithm: 'radix' });
     }
     validate(input) {
         return this.codec.validate(input);
     }
 }
-/**
- * @deprecated Use `validate()` from the main module instead.
- */
-export const validate = (input, base) => {
-    return new Validator(base).validate(input);
-};
 //# sourceMappingURL=bufferbase.js.map

package/dist/esm/bufferbase.js.map

@@ -1 +1 @@
-{"version":3,"file":"bufferbase.js","sourceRoot":"","sources":["../../src/bufferbase.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAErE,6CAA6C;AAC7C,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC,mBAAmB;AACnB,OAAO,EAAE,qBAAqB,EAAE,eAAe,EAAE,CAAC;AAElD;;GAEG;AACH,MAAM,OAAO,aAAa;IAGxB,YAAoB,SAAiB;QAAjB,cAAS,GAAT,SAAS,CAAQ;QACnC,IAAI,CAAC,KAAK,GAAG,IAAI,KAAK,CAAC,SAAS,CAAC,CAAC;IACpC,CAAC;IAED,MAAM,CAAC,MAAc;QACnB,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IACnC,CAAC;IAED,MAAM,CAAC,OAAe,EAAE,UAAmB;QACzC,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,OAAO,EAAE,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;IACjG,CAAC;CACF;AAED;;GAEG;AACH,MAAM,OAAO,SAAS;IAIpB,YAAY,SAAiB,EAAE,UAAkB;QAC/C,IAAI,CAAC,OAAO,GAAG,IAAI,aAAa,CAAC,SAAS,CAAC,CAAC;QAC5C,IAAI,CAAC,OAAO,GAAG,IAAI,aAAa,CAAC,UAAU,CAAC,CAAC;IAC/C,CAAC;IAED,OAAO,CAAC,KAAa;QACnB,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;IACzD,CAAC;CACF;AAED;;GAEG;AACH,MAAM,OAAO,SAAS;IAGpB,YAAY,SAAiB;QAC3B,IAAI,CAAC,KAAK,GAAG,IAAI,KAAK,CAAC,SAAS,CAAC,CAAC;IACpC,CAAC;IAED,QAAQ,CAAC,KAAa;QACpB,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IACpC,CAAC;CACF;AAED;;GAEG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,KAAa,EAAE,IAAY,EAAW,EAAE;IAC/D,OAAO,IAAI,SAAS,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;AAC7C,CAAC,CAAC"}
+{"version":3,"file":"bufferbase.js","sourceRoot":"","sources":["../../src/bufferbase.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE9C,wDAAwD;AACxD,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC,sDAAsD;AACtD,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAErE,+CAA+C;AAC/C,MAAM,OAAO,aAAa;IAGxB,YAAY,SAAiB;QAC3B,IAAI,CAAC,KAAK,GAAG,IAAI,UAAU,CAAC,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC,CAAC;IAC3E,CAAC;IAED,MAAM,CAAC,MAAkB;QACvB,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IACnC,CAAC;IAED,MAAM,CAAC,OAAe,EAAE,UAAmB;QACzC,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,OAAO,EAAE,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC,CAAC;IACjG,CAAC;CACF;AAED,0DAA0D;AAC1D,MAAM,OAAO,SAAS;IAIpB,YAAY,SAAiB,EAAE,UAAkB;QAC/C,IAAI,CAAC,OAAO,GAAG,IAAI,aAAa,CAAC,SAAS,CAAC,CAAC;QAC5C,IAAI,CAAC,OAAO,GAAG,IAAI,aAAa,CAAC,UAAU,CAAC,CAAC;IAC/C,CAAC;IAED,OAAO,CAAC,KAAa;QACnB,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;IACzD,CAAC;CACF;AAED,0DAA0D;AAC1D,MAAM,OAAO,SAAS;IAGpB,YAAY,SAAiB;QAC3B,IAAI,CAAC,KAAK,GAAG,IAAI,UAAU,CAAC,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC,CAAC;IAC3E,CAAC;IAED,QAAQ,CAAC,KAAa;QACpB,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IACpC,CAAC;CACF"}

package/dist/esm/codec-base.d.ts

@@ -0,0 +1,56 @@
+import { Buffer } from 'node:buffer';
+import type { Algorithm, BufferLike, CodecSpec, DecodeOptions, ICodec } from './types.js';
+/** Converts a `BufferLike` to a `Buffer` without copying when possible. */
+export declare function toBuffer(input: BufferLike): Buffer;
+/**
+ * Shared alphabet handling for the three codec implementations.
+ *
+ * Subclasses provide the mapping between bytes and characters; this class owns
+ * the alphabet, the character lookup, optional case folding, and `convertTo`.
+ */
+export declare abstract class BaseCodec implements ICodec {
+    /** Character set used for encoding. */
+    readonly chars: string;
+    /** The algorithm this codec applies to `chars`. */
+    abstract readonly algorithm: Algorithm;
+    /** Whether non-canonical input is rejected. */
+    protected readonly strict: boolean;
+    private readonly charToIndex;
+    /** Characters dropped from the input before decoding. */
+    private readonly ignored;
+    /**
+     * The alphabet as one byte per character, or `null` when some character does
+     * not fit in a byte.
+     *
+     * Assembling output as bytes and decoding it once is several times faster
+     * than concatenating characters, and every alphabet in practical use is
+     * single-byte.
+     */
+    protected readonly codes: Uint8Array | null;
+    /**
+     * The value of every decodable character, indexed by code unit, or `-1`.
+     * `null` when some character does not fit in a byte.
+     *
+     * Reading a character by index and looking it up here avoids allocating a
+     * string and hashing it for every character of the input.
+     */
+    private readonly valueByCode;
+    protected constructor(spec: CodecSpec);
+    /** Reads the first `length` bytes of `written` back as text. */
+    protected textFrom(written: Uint8Array, length: number): string;
+    /** Drops the characters this codec ignores, such as readability hyphens. */
+    protected strip(input: string): string;
+    /** Returns the value of a character, or `undefined` if it is not in the alphabet. */
+    protected valueOf(char: string): number | undefined;
+    /**
+     * Returns the value of the character at `index`, or `-1` if it is not
+     * decodable. This is the hot path of every decoder.
+     */
+    protected valueAt(input: string, index: number): number;
+    abstract encode(buffer: BufferLike): string;
+    abstract decode(encoded: string, options?: DecodeOptions): Buffer;
+    abstract validate(input: string): boolean;
+    /** Decodes with this codec, then re-encodes with `target`. */
+    convertTo(target: ICodec, input: string): string;
+}
+//# sourceMappingURL=codec-base.d.ts.map

package/dist/esm/codec-base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec-base.d.ts","sourceRoot":"","sources":["../../src/codec-base.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AA6B1F,2EAA2E;AAC3E,wBAAgB,QAAQ,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAElD;AAED;;;;;GAKG;AACH,8BAAsB,SAAU,YAAW,MAAM;IAC/C,uCAAuC;IACvC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAEvB,mDAAmD;IACnD,QAAQ,CAAC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAEvC,+CAA+C;IAC/C,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IAEnC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAsB;IAElD,yDAAyD;IACzD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsB;IAE9C;;;;;;;OAOG;IACH,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,CAAC;IAE5C;;;;;;OAMG;IACH,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAoB;IAEhD,SAAS,aAAa,IAAI,EAAE,SAAS;IA0DrC,gEAAgE;IAChE,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM;IAI/D,4EAA4E;IAC5E,SAAS,CAAC,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IActC,qFAAqF;IACrF,SAAS,CAAC,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAInD;;;OAGG;IACH,SAAS,CAAC,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM;IAUvD,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM;IAC3C,QAAQ,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,MAAM;IACjE,QAAQ,CAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAEzC,8DAA8D;IAC9D,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM;CAGjD"}

package/dist/esm/codec-base.js

@@ -0,0 +1,127 @@
+import { Buffer } from 'node:buffer';
+import { InvalidCodecError } from './errors.js';
+/** Returns one byte per character, or `null` if the alphabet needs more. */
+function singleByteCodes(alphabet) {
+    const codes = new Uint8Array(alphabet.length);
+    for (let i = 0; i < alphabet.length; i++) {
+        const code = alphabet.charCodeAt(i);
+        if (code > 0xff) {
+            return null;
+        }
+        codes[i] = code;
+    }
+    return codes;
+}
+/** Indexes the decodable characters by code unit, or `null` if any needs more than a byte. */
+function codeTable(charToIndex) {
+    const table = new Int16Array(256).fill(-1);
+    for (const [char, value] of charToIndex) {
+        const code = char.charCodeAt(0);
+        if (char.length !== 1 || code > 0xff) {
+            return null;
+        }
+        table[code] = value;
+    }
+    return table;
+}
+/** Converts a `BufferLike` to a `Buffer` without copying when possible. */
+export function toBuffer(input) {
+    return Buffer.isBuffer(input) ? input : Buffer.from(input.buffer, input.byteOffset, input.length);
+}
+/**
+ * Shared alphabet handling for the three codec implementations.
+ *
+ * Subclasses provide the mapping between bytes and characters; this class owns
+ * the alphabet, the character lookup, optional case folding, and `convertTo`.
+ */
+export class BaseCodec {
+    constructor(spec) {
+        const { alphabet, strict = true, caseInsensitive = false, aliases, ignore } = spec;
+        if (alphabet.length < 2) {
+            throw new InvalidCodecError(`alphabet needs at least 2 characters, got ${alphabet.length}`);
+        }
+        if (new Set(alphabet).size !== alphabet.length) {
+            throw new InvalidCodecError('alphabet contains duplicate characters');
+        }
+        if ([...alphabet].some((char) => char.length !== 1)) {
+            throw new InvalidCodecError('every alphabet character must be a single code unit');
+        }
+        if (caseInsensitive && new Set(alphabet.toLowerCase()).size !== alphabet.length) {
+            throw new InvalidCodecError('caseInsensitive needs an alphabet that does not contain both cases of a letter');
+        }
+        this.chars = alphabet;
+        this.strict = strict;
+        this.charToIndex = new Map();
+        const accept = (char, value) => {
+            this.charToIndex.set(char, value);
+            if (caseInsensitive) {
+                this.charToIndex.set(char.toLowerCase(), value);
+                this.charToIndex.set(char.toUpperCase(), value);
+            }
+        };
+        for (let i = 0; i < alphabet.length; i++) {
+            accept(alphabet[i], i);
+        }
+        for (const [from, to] of Object.entries(aliases ?? {})) {
+            if (from.length !== 1) {
+                throw new InvalidCodecError(`alias '${from}' must be a single character`);
+            }
+            const value = this.charToIndex.get(to);
+            if (value === undefined) {
+                throw new InvalidCodecError(`alias '${from}' points at '${to}', which is not in the alphabet`);
+            }
+            if (alphabet.includes(from)) {
+                throw new InvalidCodecError(`alias '${from}' is already in the alphabet`);
+            }
+            accept(from, value);
+        }
+        this.codes = singleByteCodes(alphabet);
+        this.valueByCode = codeTable(this.charToIndex);
+        this.ignored = new Set(ignore ?? '');
+        for (const char of this.ignored) {
+            if (this.charToIndex.has(char)) {
+                throw new InvalidCodecError(`ignored character '${char}' is also decodable`);
+            }
+        }
+    }
+    /** Reads the first `length` bytes of `written` back as text. */
+    textFrom(written, length) {
+        return Buffer.from(written.buffer, written.byteOffset, length).toString('latin1');
+    }
+    /** Drops the characters this codec ignores, such as readability hyphens. */
+    strip(input) {
+        if (this.ignored.size === 0) {
+            return input;
+        }
+        let out = '';
+        for (let i = 0; i < input.length; i++) {
+            const char = input[i];
+            if (!this.ignored.has(char)) {
+                out += char;
+            }
+        }
+        return out;
+    }
+    /** Returns the value of a character, or `undefined` if it is not in the alphabet. */
+    valueOf(char) {
+        return this.charToIndex.get(char);
+    }
+    /**
+     * Returns the value of the character at `index`, or `-1` if it is not
+     * decodable. This is the hot path of every decoder.
+     */
+    valueAt(input, index) {
+        const table = this.valueByCode;
+        if (table === null) {
+            const value = this.charToIndex.get(input[index]);
+            return value === undefined ? -1 : value;
+        }
+        const code = input.charCodeAt(index);
+        return code > 0xff ? -1 : table[code];
+    }
+    /** Decodes with this codec, then re-encodes with `target`. */
+    convertTo(target, input) {
+        return target.encode(this.decode(input));
+    }
+}
+//# sourceMappingURL=codec-base.js.map

package/dist/esm/codec-base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec-base.js","sourceRoot":"","sources":["../../src/codec-base.ts"],"names":[],"mappings":"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"}

package/dist/esm/codec-block.d.ts

@@ -0,0 +1,47 @@
+import { Buffer } from 'node:buffer';
+import type { BlockSpec, BufferLike, DecodeOptions } from './types.js';
+import { BaseCodec } from './codec-base.js';
+/**
+ * Regroups the bit stream into fixed-width chunks, as specified by RFC 4648.
+ *
+ * Each character carries `log2(alphabet.length)` bits, so the alphabet must
+ * hold 2, 4, 8, 16, 32, or 64 characters. Unlike a radix conversion the output
+ * length is a fixed function of the input length, which is what makes Base64
+ * and Base32 splittable and streamable.
+ *
+ * A trailing partial block leaves spare bits in the final character. RFC 4648
+ * §3.5 requires those bits to be zero for the encoding to be canonical; input
+ * that sets them is rejected unless the spec passes `strict: false`.
+ *
+ * @example
+ * ```typescript
+ * import { Codecs } from 'bufferbase';
+ *
+ * Codecs.base64.encode(Buffer.from('fo')); // 'Zm8='
+ * Codecs.base64.validate('Zm9=');          // false — spare bits are not zero
+ * ```
+ */
+export declare class BlockCodec extends BaseCodec {
+    readonly algorithm: "block";
+    /** Bits carried by one character. */
+    private readonly bitsPerChar;
+    /** Characters in a whole block. */
+    private readonly charsPerBlock;
+    private readonly padChar;
+    private readonly native;
+    constructor(spec: BlockSpec);
+    encode(input: BufferLike): string;
+    /** The character-by-character path, for an alphabet that is not single-byte. */
+    private encodeAsText;
+    decode(encoded: string, options?: DecodeOptions): Buffer;
+    validate(input: string): boolean;
+    /**
+     * Strips and checks the padding, then verifies that what remains can be the
+     * encoding of some byte sequence. Returns the data characters.
+     *
+     * Everything `decode` can reject other than `DecodeOptions.size` is checked
+     * here, so `validate` and `decode` always agree.
+     */
+    private checkStructure;
+}
+//# sourceMappingURL=codec-block.d.ts.map

package/dist/esm/codec-block.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec-block.d.ts","sourceRoot":"","sources":["../../src/codec-block.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AACvE,OAAO,EAAE,SAAS,EAAY,MAAM,iBAAiB,CAAC;AAwCtD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,UAAW,SAAQ,SAAS;IACvC,QAAQ,CAAC,SAAS,EAAG,OAAO,CAAU;IAEtC,qCAAqC;IACrC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,mCAAmC;IACnC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAiB;IACzC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuB;gBAElC,IAAI,EAAE,SAAS;IA0B3B,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM;IA4CjC,gFAAgF;IAChF,OAAO,CAAC,YAAY;IA0BpB,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,MAAM;IA4BxD,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAShC;;;;;;OAMG;IACH,OAAO,CAAC,cAAc;CA4CvB"}