bufferbase 1.3.0 → 3.0.0

package/dist/cjs/bufferbase.js

@@ -1,150 +1,56 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validate = exports.Validator = exports.Converter = exports.BufferEncoder = exports.BufferSizeError = exports.InvalidCharacterError = exports.Chars = void 0;
-/**
- * A collection of common bases.
- */
-exports.Chars = {
-    Decimal: '0123456789',
-    Base16: '0123456789ABCDEF',
-    Base32: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567',
-    Base32Crockford: '0123456789ABCDEFGHJKMNPQRSTVWXYZ',
-    Base36: '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ',
-    Base52: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz',
-    Base58: '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz',
-    Base64_STD: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
-    Base64_URL_SAFE: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_',
-    Base64_XML_NMTOKEN: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._',
-    Base64_XML_NAME: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_:',
-    Ascii85: '!"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstu',
-    Base85: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!#$%&()*+-;<=>?@^_`{|}~',
-    Z85: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.-:+=^!/*?&<>()[]{}@%$#',
-};
-class InvalidCharacterError extends Error {
-    constructor() {
-        super(...arguments);
-        this.message = 'Invalid character found';
-    }
-}
-exports.InvalidCharacterError = InvalidCharacterError;
-class BufferSizeError extends Error {
-    constructor() {
-        super(...arguments);
-        this.message = 'Buffer size exceeds specified size';
-    }
-}
-exports.BufferSizeError = BufferSizeError;
 /**
- * Encodes and decodes buffers to and from a base.
+ * @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.
  */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Validator = exports.Converter = exports.BufferEncoder = exports.InvalidCharacterError = exports.BufferSizeError = exports.Chars = void 0;
+const codec_radix_js_1 = require("./codec-radix.js");
+/** @deprecated Import `Chars` from the package root. */
+var bases_js_1 = require("./bases.js");
+Object.defineProperty(exports, "Chars", { enumerable: true, get: function () { return bases_js_1.Chars; } });
+/** @deprecated Import these from the package root. */
+var errors_js_1 = require("./errors.js");
+Object.defineProperty(exports, "BufferSizeError", { enumerable: true, get: function () { return errors_js_1.BufferSizeError; } });
+Object.defineProperty(exports, "InvalidCharacterError", { enumerable: true, get: function () { return errors_js_1.InvalidCharacterError; } });
+/** @deprecated Use `createCodec(alphabet)`. */
 class BufferEncoder {
     constructor(baseChars) {
-        this.baseChars = baseChars;
+        this.codec = new codec_radix_js_1.RadixCodec({ alphabet: baseChars, algorithm: 'radix' });
     }
-    /**
-     * Encodes a buffer to a string.
-     */
     encode(buffer) {
-        let result = [];
-        for (const byte of buffer) {
-            let carry = byte;
-            for (let j = 0; j < result.length; j++) {
-                carry += result[j] * 256;
-                result[j] = carry % this.baseChars.length;
-                carry = Math.floor(carry / this.baseChars.length);
-            }
-            while (carry > 0) {
-                result.push(carry % this.baseChars.length);
-                carry = Math.floor(carry / this.baseChars.length);
-            }
-        }
-        for (const byte of buffer) {
-            if (byte === 0) {
-                result.push(0);
-            }
-            else {
-                break;
-            }
-        }
-        return result
-            .reverse()
-            .map((index) => this.baseChars[index])
-            .join('');
+        return this.codec.encode(buffer);
     }
-    /**
-     * Decodes a string to a buffer.
-     */
     decode(encoded, bufferSize) {
-        let result = Buffer.alloc(0);
-        for (const char of encoded) {
-            const value = this.baseChars.indexOf(char);
-            if (value === -1)
-                throw new InvalidCharacterError();
-            let carry = value;
-            let tempResult = Buffer.alloc(result.length);
-            let i;
-            for (i = 0; i < result.length; i++) {
-                carry += result[i] * this.baseChars.length;
-                tempResult[i] = carry % 256;
-                carry = Math.floor(carry / 256);
-            }
-            while (carry > 0) {
-                tempResult = Buffer.concat([tempResult, Buffer.from([carry % 256])]);
-                carry = Math.floor(carry / 256);
-            }
-            result = tempResult;
-        }
-        // buffer size
-        if (bufferSize && result.length < bufferSize) {
-            result = Buffer.concat([
-                result,
-                Buffer.from(Array(bufferSize - result.length).fill(0)),
-            ]);
-        }
-        if (bufferSize && result.length > bufferSize) {
-            throw new BufferSizeError();
-        }
-        result.reverse();
-        return result;
+        return this.codec.decode(encoded, bufferSize === undefined ? undefined : { size: bufferSize });
     }
 }
 exports.BufferEncoder = BufferEncoder;
-/**
- * Creates a converter function that can convert between two bases.
- */
+/** @deprecated Use `convert()` or `codec.convertTo()`. */
 class Converter {
     constructor(inputBase, outputBase) {
         this.decoder = new BufferEncoder(inputBase);
         this.encoder = new BufferEncoder(outputBase);
     }
-    /**
-     * Converts a string from the input base to the output base.
-     */
     convert(input) {
         return this.encoder.encode(this.decoder.decode(input));
     }
 }
 exports.Converter = Converter;
+/** @deprecated Use `validate()` or `codec.validate()`. */
 class Validator {
     constructor(inputBase) {
-        this.decorder = new BufferEncoder(inputBase);
+        this.codec = new codec_radix_js_1.RadixCodec({ alphabet: inputBase, algorithm: 'radix' });
     }
     validate(input) {
-        try {
-            this.decorder.decode(input);
-            return true;
-        }
-        catch (e) {
-            if (e instanceof InvalidCharacterError) {
-                return false;
-            }
-            throw e;
-        }
+        return this.codec.validate(input);
     }
 }
 exports.Validator = Validator;
-const validate = (input, base) => {
-    return new Validator(base).validate(input);
-};
-exports.validate = validate;
 //# sourceMappingURL=bufferbase.js.map

package/dist/cjs/bufferbase.js.map

@@ -1 +1 @@
-{"version":3,"file":"bufferbase.js","sourceRoot":"","sources":["../../src/bufferbase.ts"],"names":[],"mappings":";;;AAAA;;GAEG;AACU,QAAA,KAAK,GAAG;IACnB,OAAO,EAAE,YAAY;IACrB,MAAM,EAAE,kBAAkB;IAC1B,MAAM,EAAE,kCAAkC;IAC1C,eAAe,EAAE,kCAAkC;IACnD,MAAM,EAAE,sCAAsC;IAC9C,MAAM,EAAE,sDAAsD;IAC9D,MAAM,EAAE,4DAA4D;IACpE,UAAU,EACR,kEAAkE;IACpE,eAAe,EACb,kEAAkE;IACpE,kBAAkB,EAChB,kEAAkE;IACpE,eAAe,EACb,kEAAkE;IACpE,OAAO,EACL,uFAAuF;IACzF,MAAM,EACJ,uFAAuF;IACzF,GAAG,EAAE,uFAAuF;CAC7F,CAAC;AAEF,MAAa,qBAAsB,SAAQ,KAAK;IAAhD;;QACE,YAAO,GAAG,yBAAyB,CAAC;IACtC,CAAC;CAAA;AAFD,sDAEC;AAED,MAAa,eAAgB,SAAQ,KAAK;IAA1C;;QACE,YAAO,GAAG,oCAAoC,CAAC;IACjD,CAAC;CAAA;AAFD,0CAEC;AAED;;GAEG;AACH,MAAa,aAAa;IACxB,YAAoB,SAAiB;QAAjB,cAAS,GAAT,SAAS,CAAQ;IAAG,CAAC;IAEzC;;OAEG;IACH,MAAM,CAAC,MAAc;QACnB,IAAI,MAAM,GAAG,EAAE,CAAC;QAChB,KAAK,MAAM,IAAI,IAAI,MAAM,EAAE,CAAC;YAC1B,IAAI,KAAK,GAAG,IAAI,CAAC;YACjB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;gBACvC,KAAK,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC;gBACzB,MAAM,CAAC,CAAC,CAAC,GAAG,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;gBAC1C,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;YACpD,CAAC;YACD,OAAO,KAAK,GAAG,CAAC,EAAE,CAAC;gBACjB,MAAM,CAAC,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;gBAC3C,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;YACpD,CAAC;QACH,CAAC;QACD,KAAK,MAAM,IAAI,IAAI,MAAM,EAAE,CAAC;YAC1B,IAAI,IAAI,KAAK,CAAC,EAAE,CAAC;gBACf,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACjB,CAAC;iBAAM,CAAC;gBACN,MAAM;YACR,CAAC;QACH,CAAC;QACD,OAAO,MAAM;aACV,OAAO,EAAE;aACT,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;aACrC,IAAI,CAAC,EAAE,CAAC,CAAC;IACd,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,OAAe,EAAE,UAAmB;QACzC,IAAI,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC7B,KAAK,MAAM,IAAI,IAAI,OAAO,EAAE,CAAC;YAC3B,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;YAC3C,IAAI,KAAK,KAAK,CAAC,CAAC;gBAAE,MAAM,IAAI,qBAAqB,EAAE,CAAC;YACpD,IAAI,KAAK,GAAG,KAAK,CAAC;YAClB,IAAI,UAAU,GAAG,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;YAC7C,IAAI,CAAC,CAAC;YACN,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;gBACnC,KAAK,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;gBAC3C,UAAU,CAAC,CAAC,CAAC,GAAG,KAAK,GAAG,GAAG,CAAC;gBAC5B,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,GAAG,CAAC,CAAC;YAClC,CAAC;YACD,OAAO,KAAK,GAAG,CAAC,EAAE,CAAC;gBACjB,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,UAAU,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;gBACrE,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,GAAG,CAAC,CAAC;YAClC,CAAC;YACD,MAAM,GAAG,UAAU,CAAC;QACtB,CAAC;QACD,cAAc;QACd,IAAI,UAAU,IAAI,MAAM,CAAC,MAAM,GAAG,UAAU,EAAE,CAAC;YAC7C,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;gBACrB,MAAM;gBACN,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;aACvD,CAAC,CAAC;QACL,CAAC;QACD,IAAI,UAAU,IAAI,MAAM,CAAC,MAAM,GAAG,UAAU,EAAE,CAAC;YAC7C,MAAM,IAAI,eAAe,EAAE,CAAC;QAC9B,CAAC;QACD,MAAM,CAAC,OAAO,EAAE,CAAC;QACjB,OAAO,MAAM,CAAC;IAChB,CAAC;CACF;AApED,sCAoEC;AAED;;GAEG;AACH,MAAa,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;;OAEG;IACH,OAAO,CAAC,KAAa;QACnB,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;IACzD,CAAC;CACF;AAfD,8BAeC;AAED,MAAa,SAAS;IAGpB,YAAY,SAAiB;QAC3B,IAAI,CAAC,QAAQ,GAAG,IAAI,aAAa,CAAC,SAAS,CAAC,CAAC;IAC/C,CAAC;IAED,QAAQ,CAAC,KAAa;QACpB,IAAI,CAAC;YACH,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YAC5B,OAAO,IAAI,CAAC;QACd,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,IAAI,CAAC,YAAY,qBAAqB,EAAE,CAAC;gBACvC,OAAO,KAAK,CAAC;YACf,CAAC;YACD,MAAM,CAAC,CAAC;QACV,CAAC;IACH,CAAC;CACF;AAlBD,8BAkBC;AAEM,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;AAFW,QAAA,QAAQ,YAEnB"}
+{"version":3,"file":"bufferbase.js","sourceRoot":"","sources":["../../src/bufferbase.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG;;;AAIH,qDAA8C;AAE9C,wDAAwD;AACxD,uCAAmC;AAA1B,iGAAA,KAAK,OAAA;AAEd,sDAAsD;AACtD,yCAAqE;AAA5D,4GAAA,eAAe,OAAA;AAAE,kHAAA,qBAAqB,OAAA;AAE/C,+CAA+C;AAC/C,MAAa,aAAa;IAGxB,YAAY,SAAiB;QAC3B,IAAI,CAAC,KAAK,GAAG,IAAI,2BAAU,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;AAdD,sCAcC;AAED,0DAA0D;AAC1D,MAAa,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;AAZD,8BAYC;AAED,0DAA0D;AAC1D,MAAa,SAAS;IAGpB,YAAY,SAAiB;QAC3B,IAAI,CAAC,KAAK,GAAG,IAAI,2BAAU,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;AAVD,8BAUC"}

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

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseCodec = void 0;
+exports.toBuffer = toBuffer;
+const node_buffer_1 = require("node:buffer");
+const errors_js_1 = require("./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. */
+function toBuffer(input) {
+    return node_buffer_1.Buffer.isBuffer(input) ? input : node_buffer_1.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`.
+ */
+class BaseCodec {
+    constructor(spec) {
+        const { alphabet, strict = true, caseInsensitive = false, aliases, ignore } = spec;
+        if (alphabet.length < 2) {
+            throw new errors_js_1.InvalidCodecError(`alphabet needs at least 2 characters, got ${alphabet.length}`);
+        }
+        if (new Set(alphabet).size !== alphabet.length) {
+            throw new errors_js_1.InvalidCodecError('alphabet contains duplicate characters');
+        }
+        if ([...alphabet].some((char) => char.length !== 1)) {
+            throw new errors_js_1.InvalidCodecError('every alphabet character must be a single code unit');
+        }
+        if (caseInsensitive && new Set(alphabet.toLowerCase()).size !== alphabet.length) {
+            throw new errors_js_1.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 errors_js_1.InvalidCodecError(`alias '${from}' must be a single character`);
+            }
+            const value = this.charToIndex.get(to);
+            if (value === undefined) {
+                throw new errors_js_1.InvalidCodecError(`alias '${from}' points at '${to}', which is not in the alphabet`);
+            }
+            if (alphabet.includes(from)) {
+                throw new errors_js_1.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 errors_js_1.InvalidCodecError(`ignored character '${char}' is also decodable`);
+            }
+        }
+    }
+    /** Reads the first `length` bytes of `written` back as text. */
+    textFrom(written, length) {
+        return node_buffer_1.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));
+    }
+}
+exports.BaseCodec = BaseCodec;
+//# sourceMappingURL=codec-base.js.map

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

package/dist/cjs/codec-block.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockCodec = void 0;
+const node_buffer_1 = require("node:buffer");
+const codec_base_js_1 = require("./codec-base.js");
+const errors_js_1 = require("./errors.js");
+const RFC_BASE64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const RFC_BASE64URL = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+const HEX_LOWER = '0123456789abcdef';
+const HEX_UPPER = '0123456789ABCDEF';
+/**
+ * Finds the Node encoding equivalent to a spec, if there is one.
+ *
+ * Node's encoders are 100-250x faster than the loop below and always emit
+ * canonical output, so an exact match is handed off. Decoding is never handed
+ * off: Node's decoders are lenient, and rejecting non-canonical input is the
+ * point of this codec.
+ */
+function nativeEncoderFor(alphabet, pad) {
+    if (alphabet === RFC_BASE64 && pad === '=') {
+        return { encoding: 'base64', upper: false };
+    }
+    if (alphabet === RFC_BASE64URL && pad === false) {
+        return { encoding: 'base64url', upper: false };
+    }
+    if (pad === false && (alphabet === HEX_LOWER || alphabet === HEX_UPPER)) {
+        return { encoding: 'hex', upper: alphabet === HEX_UPPER };
+    }
+    return null;
+}
+const gcd = (a, b) => (b === 0 ? a : gcd(b, a % b));
+/**
+ * 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
+ * ```
+ */
+class BlockCodec extends codec_base_js_1.BaseCodec {
+    constructor(spec) {
+        super(spec);
+        this.algorithm = 'block';
+        const bits = Math.log2(spec.alphabet.length);
+        if (!Number.isInteger(bits)) {
+            throw new errors_js_1.InvalidCodecError(`'block' needs an alphabet of 2, 4, 8, 16, 32, or 64 characters, got ${spec.alphabet.length}`);
+        }
+        const pad = spec.pad ?? '=';
+        if (pad !== false) {
+            if (pad.length !== 1) {
+                throw new errors_js_1.InvalidCodecError(`pad must be a single character, got '${pad}'`);
+            }
+            if (this.valueOf(pad) !== undefined) {
+                throw new errors_js_1.InvalidCodecError(`pad character '${pad}' is part of the alphabet`);
+            }
+        }
+        this.bitsPerChar = bits;
+        this.charsPerBlock = 8 / gcd(8, bits);
+        this.padChar = pad;
+        this.native = nativeEncoderFor(spec.alphabet, pad);
+    }
+    encode(input) {
+        const buffer = (0, codec_base_js_1.toBuffer)(input);
+        if (this.native !== null) {
+            const encoded = buffer.toString(this.native.encoding);
+            return this.native.upper ? encoded.toUpperCase() : encoded;
+        }
+        const bits = this.bitsPerChar;
+        const mask = this.chars.length - 1;
+        const codes = this.codes;
+        if (codes === null) {
+            return this.encodeAsText(buffer);
+        }
+        const dataChars = Math.ceil((buffer.length * 8) / bits);
+        const total = this.padChar === false
+            ? dataChars
+            : Math.ceil(dataChars / this.charsPerBlock) * this.charsPerBlock;
+        const written = new Uint8Array(total);
+        let at = 0;
+        let acc = 0;
+        let held = 0;
+        for (let i = 0; i < buffer.length; i++) {
+            acc = ((acc << 8) | buffer[i]) & 0xffff;
+            held += 8;
+            while (held >= bits) {
+                held -= bits;
+                written[at++] = codes[(acc >>> held) & mask];
+            }
+        }
+        if (held > 0) {
+            written[at++] = codes[(acc << (bits - held)) & mask];
+        }
+        if (this.padChar !== false) {
+            const padCode = this.padChar.charCodeAt(0);
+            while (at < total) {
+                written[at++] = padCode;
+            }
+        }
+        return this.textFrom(written, at);
+    }
+    /** The character-by-character path, for an alphabet that is not single-byte. */
+    encodeAsText(buffer) {
+        const bits = this.bitsPerChar;
+        const mask = this.chars.length - 1;
+        let out = '';
+        let acc = 0;
+        let held = 0;
+        for (const byte of buffer) {
+            acc = ((acc << 8) | byte) & 0xffff;
+            held += 8;
+            while (held >= bits) {
+                held -= bits;
+                out += this.chars[(acc >>> held) & mask];
+            }
+        }
+        if (held > 0) {
+            out += this.chars[(acc << (bits - held)) & mask];
+        }
+        if (this.padChar !== false) {
+            while (out.length % this.charsPerBlock !== 0) {
+                out += this.padChar;
+            }
+        }
+        return out;
+    }
+    decode(encoded, options) {
+        const data = this.checkStructure(this.strip(encoded));
+        const bits = this.bitsPerChar;
+        const bytes = node_buffer_1.Buffer.alloc(Math.floor((data.length * bits) / 8));
+        let at = 0;
+        let acc = 0;
+        let held = 0;
+        for (let i = 0; i < data.length; i++) {
+            const value = this.valueAt(data, i);
+            if (value < 0) {
+                throw new errors_js_1.InvalidCharacterError(data[i]);
+            }
+            acc = ((acc << bits) | value) & 0xffff;
+            held += bits;
+            if (held >= 8) {
+                held -= 8;
+                bytes[at++] = (acc >>> held) & 0xff;
+            }
+        }
+        const size = options?.size;
+        if (size !== undefined && bytes.length !== size) {
+            throw new errors_js_1.BufferSizeError(bytes.length, size);
+        }
+        return bytes;
+    }
+    validate(input) {
+        try {
+            this.checkStructure(this.strip(input));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * 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.
+     */
+    checkStructure(input) {
+        let data = input;
+        if (this.padChar !== false) {
+            let dataLength = input.length;
+            while (dataLength > 0 && input[dataLength - 1] === this.padChar) {
+                dataLength--;
+            }
+            data = input.slice(0, dataLength);
+            if (input.length % this.charsPerBlock !== 0) {
+                throw new errors_js_1.InvalidLengthError(input.length, `padded input must be a multiple of ${this.charsPerBlock} characters`);
+            }
+            if (input.length - dataLength >= this.charsPerBlock) {
+                throw new errors_js_1.InvalidLengthError(input.length, 'too many padding characters');
+            }
+        }
+        const bits = this.bitsPerChar;
+        const spare = (data.length * bits) % 8;
+        if (spare >= bits) {
+            throw new errors_js_1.InvalidLengthError(data.length, `${data.length} characters carry ${data.length * bits} bits, which is not a whole number of bytes`);
+        }
+        let last = -1;
+        for (let i = 0; i < data.length; i++) {
+            last = this.valueAt(data, i);
+            if (last < 0) {
+                throw new errors_js_1.InvalidCharacterError(data[i]);
+            }
+        }
+        if (this.strict && spare > 0 && last >= 0 && (last & ((1 << spare) - 1)) !== 0) {
+            throw new errors_js_1.NonCanonicalError(`the final character carries ${spare} spare bits that must be zero`);
+        }
+        return data;
+    }
+}
+exports.BlockCodec = BlockCodec;
+//# sourceMappingURL=codec-block.js.map