bufferbase 2.0.0 → 3.0.0

package/dist/cjs/codec.js

@@ -1,247 +1,69 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Codec = void 0;
+exports.Codec = exports.Block85Codec = exports.BlockCodec = exports.RadixCodec = void 0;
 exports.createCodec = createCodec;
-const node_buffer_1 = require("node:buffer");
-const errors_js_1 = require("./errors.js");
+exports.getCodec = getCodec;
+const codec_radix_js_1 = require("./codec-radix.js");
+const codec_block_js_1 = require("./codec-block.js");
+const codec_block85_js_1 = require("./codec-block85.js");
 /**
- * Converts a BufferLike (Buffer or Uint8Array) to a Buffer.
- * @internal
- */
-function toBuffer(input) {
-    if (node_buffer_1.Buffer.isBuffer(input)) {
-        return input;
-    }
-    return node_buffer_1.Buffer.from(input);
-}
-/**
- * Codec for encoding and decoding buffers to/from a specific base.
+ * Builds the codec described by a spec.
  *
- * Use pre-defined codecs from `Codecs` for common encodings,
- * or create custom codecs with `createCodec()`.
+ * A bare string is read as a custom alphabet for a radix conversion, which is
+ * the only algorithm that works with an alphabet of any length.
  *
  * @example
  * ```typescript
- * import { Codec, Codecs, createCodec } from 'bufferbase';
- *
- * // Use pre-defined codec
- * const encoded = Codecs.base58.encode(Buffer.from('Hello'));
+ * import { createCodec } from 'bufferbase';
  *
- * // Create custom codec
  * const binary = createCodec('01');
- * const bits = binary.encode(Buffer.from([5])); // '101'
+ * binary.encode(Uint8Array.of(5)); // '101'
+ *
+ * const paddedHex = createCodec({ alphabet: '0123456789abcdef', algorithm: 'block' });
+ * paddedHex.encode(Uint8Array.of(0, 1)); // '0001'
  * ```
  */
-class Codec {
-    /**
-     * Creates a new codec with the specified character set.
-     * @param chars - The character set to use for encoding/decoding
-     */
-    constructor(chars) {
-        this.chars = chars;
-        this.charToIndex = new Map();
-        for (let i = 0; i < chars.length; i++) {
-            this.charToIndex.set(chars[i], i);
-        }
-    }
-    /**
-     * Encodes a buffer to a base-encoded string.
-     *
-     * Leading zero bytes in the buffer are preserved as the first character
-     * of the encoding alphabet (e.g., '1' for Base58).
-     *
-     * @param input - The buffer or Uint8Array to encode
-     * @returns Base-encoded string
-     *
-     * @example
-     * ```typescript
-     * const codec = Codecs.base58;
-     * codec.encode(Buffer.from('Hello')); // '9Ajdvzr'
-     * codec.encode(new Uint8Array([0, 0, 1])); // '112' (preserves leading zeros)
-     * ```
-     */
-    encode(input) {
-        const buffer = toBuffer(input);
-        if (buffer.length === 0) {
-            return '';
-        }
-        const base = this.chars.length;
-        const result = [];
-        // Count leading zeros
-        let leadingZeros = 0;
-        for (const byte of buffer) {
-            if (byte === 0) {
-                leadingZeros++;
-            }
-            else {
-                break;
-            }
-        }
-        // Convert to base
-        for (const byte of buffer) {
-            let carry = byte;
-            for (let j = 0; j < result.length; j++) {
-                carry += result[j] * 256;
-                result[j] = carry % base;
-                carry = Math.floor(carry / base);
-            }
-            while (carry > 0) {
-                result.push(carry % base);
-                carry = Math.floor(carry / base);
-            }
-        }
-        // Add leading zeros
-        for (let i = 0; i < leadingZeros; i++) {
-            result.push(0);
-        }
-        // Reverse and convert to string
-        return result
-            .reverse()
-            .map((index) => this.chars[index])
-            .join('');
-    }
-    /**
-     * Decodes a base-encoded string to a buffer.
-     *
-     * Leading characters that represent zero (first char of alphabet)
-     * are converted to leading zero bytes in the result.
-     *
-     * @param encoded - The string to decode
-     * @param options - Decode options
-     * @returns Decoded buffer
-     * @throws {InvalidCharacterError} If the string contains invalid characters
-     * @throws {BufferSizeError} If the result exceeds the specified size
-     *
-     * @example
-     * ```typescript
-     * const codec = Codecs.base58;
-     * codec.decode('9Ajdvzr'); // Buffer('Hello')
-     * codec.decode('9Ajdvzr', { size: 32 }); // Pads to 32 bytes
-     * ```
-     */
-    decode(encoded, options) {
-        if (encoded.length === 0) {
-            if (options?.size !== undefined && options.size > 0) {
-                return node_buffer_1.Buffer.alloc(options.size);
-            }
-            return node_buffer_1.Buffer.alloc(0);
-        }
-        const base = this.chars.length;
-        const zeroChar = this.chars[0];
-        // Count leading zeros in encoded string
-        let leadingZeros = 0;
-        for (const char of encoded) {
-            if (char === zeroChar) {
-                leadingZeros++;
-            }
-            else {
-                break;
-            }
-        }
-        // Convert from base
-        const result = [];
-        for (const char of encoded) {
-            const value = this.charToIndex.get(char);
-            if (value === undefined) {
-                throw new errors_js_1.InvalidCharacterError(char);
-            }
-            let carry = value;
-            for (let i = 0; i < result.length; i++) {
-                carry += result[i] * base;
-                result[i] = carry % 256;
-                carry = Math.floor(carry / 256);
-            }
-            while (carry > 0) {
-                result.push(carry % 256);
-                carry = Math.floor(carry / 256);
-            }
-        }
-        // Add leading zeros
-        for (let i = 0; i < leadingZeros; i++) {
-            result.push(0);
-        }
-        result.reverse();
-        // Handle size option
-        const size = options?.size;
-        if (size !== undefined) {
-            if (result.length > size) {
-                throw new errors_js_1.BufferSizeError(result.length, size);
-            }
-            if (result.length < size) {
-                // Pad with leading zeros
-                const padded = new Array(size - result.length).fill(0).concat(result);
-                return node_buffer_1.Buffer.from(padded);
-            }
-        }
-        return node_buffer_1.Buffer.from(result);
-    }
-    /**
-     * Validates if a string contains only valid characters for this base.
-     *
-     * This is a fast check that doesn't perform full decoding.
-     *
-     * @param input - The string to validate
-     * @returns `true` if all characters are valid, `false` otherwise
-     *
-     * @example
-     * ```typescript
-     * Codecs.base58.validate('9Ajdvzr'); // true
-     * Codecs.base58.validate('0invalid'); // false ('0' not in Base58)
-     * ```
-     */
-    validate(input) {
-        for (const char of input) {
-            if (!this.charToIndex.has(char)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    /**
-     * Converts a string from this base to another base.
-     *
-     * Internally decodes to a buffer, then encodes with the target codec.
-     *
-     * @param target - Target codec to convert to
-     * @param input - The string to convert
-     * @returns String in the target base encoding
-     * @throws {InvalidCharacterError} If the input contains invalid characters
-     *
-     * @example
-     * ```typescript
-     * const base58str = '9Ajdvzr';
-     * const base64str = Codecs.base58.convertTo(Codecs.base64url, base58str);
-     * ```
-     */
-    convertTo(target, input) {
-        const buffer = this.decode(input);
-        return target.encode(buffer);
+function createCodec(spec) {
+    const resolved = typeof spec === 'string' ? { alphabet: spec, algorithm: 'radix' } : spec;
+    switch (resolved.algorithm) {
+        case 'radix':
+            return new codec_radix_js_1.RadixCodec(resolved);
+        case 'block':
+            return new codec_block_js_1.BlockCodec(resolved);
+        case 'block85':
+            return new codec_block85_js_1.Block85Codec(resolved);
     }
 }
-exports.Codec = Codec;
+const cache = new WeakMap();
 /**
- * Creates a new codec with the specified character set.
- *
- * Use this to create codecs for custom base encodings.
- * The base is determined by the length of the character set.
- *
- * @param chars - The character set to use for encoding/decoding
- * @returns A new Codec instance
+ * Returns the codec for a spec, building it once per spec object.
  *
- * @example
- * ```typescript
- * import { createCodec } from 'bufferbase';
- *
- * // Binary codec (base 2)
- * const binary = createCodec('01');
- * binary.encode(Buffer.from([5])); // '101'
- *
- * // Octal codec (base 8)
- * const octal = createCodec('01234567');
- * octal.encode(Buffer.from([255])); // '377'
- * ```
+ * Named bases always resolve to the same spec object, so they are built once
+ * for the lifetime of the process.
  */
-function createCodec(chars) {
-    return new Codec(chars);
+function getCodec(spec) {
+    const cached = cache.get(spec);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const codec = createCodec(spec);
+    cache.set(spec, codec);
+    return codec;
 }
+var codec_radix_js_2 = require("./codec-radix.js");
+Object.defineProperty(exports, "RadixCodec", { enumerable: true, get: function () { return codec_radix_js_2.RadixCodec; } });
+var codec_block_js_2 = require("./codec-block.js");
+Object.defineProperty(exports, "BlockCodec", { enumerable: true, get: function () { return codec_block_js_2.BlockCodec; } });
+var codec_block85_js_2 = require("./codec-block85.js");
+Object.defineProperty(exports, "Block85Codec", { enumerable: true, get: function () { return codec_block85_js_2.Block85Codec; } });
+/**
+ * @deprecated Use `createCodec({ alphabet, algorithm: 'radix' })`, or
+ * `createCodec(alphabet)` for the same thing.
+ */
+class Codec extends codec_radix_js_1.RadixCodec {
+    constructor(chars) {
+        super({ alphabet: chars, algorithm: 'radix' });
+    }
+}
+exports.Codec = Codec;
 //# sourceMappingURL=codec.js.map

package/dist/cjs/codec.js.map

@@ -1 +1 @@
-{"version":3,"file":"codec.js","sourceRoot":"","sources":["../../src/codec.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"codec.js","sourceRoot":"","sources":["../../src/codec.ts"],"names":[],"mappings":";;;AAsBA,kCAYC;AAUD,4BAQC;AAnDD,qDAA8C;AAC9C,qDAA8C;AAC9C,yDAAkD;AAElD;;;;;;;;;;;;;;;;GAgBG;AACH,SAAgB,WAAW,CAAC,IAAwB;IAClD,MAAM,QAAQ,GACZ,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;IAE3E,QAAQ,QAAQ,CAAC,SAAS,EAAE,CAAC;QAC3B,KAAK,OAAO;YACV,OAAO,IAAI,2BAAU,CAAC,QAAQ,CAAC,CAAC;QAClC,KAAK,OAAO;YACV,OAAO,IAAI,2BAAU,CAAC,QAAQ,CAAC,CAAC;QAClC,KAAK,SAAS;YACZ,OAAO,IAAI,+BAAY,CAAC,QAAQ,CAAC,CAAC;IACtC,CAAC;AACH,CAAC;AAED,MAAM,KAAK,GAAG,IAAI,OAAO,EAAqB,CAAC;AAE/C;;;;;GAKG;AACH,SAAgB,QAAQ,CAAC,IAAe;IACtC,MAAM,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAC/B,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QACzB,OAAO,MAAM,CAAC;IAChB,CAAC;IACD,MAAM,KAAK,GAAG,WAAW,CAAC,IAAI,CAAC,CAAC;IAChC,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IACvB,OAAO,KAAK,CAAC;AACf,CAAC;AAED,mDAA8C;AAArC,4GAAA,UAAU,OAAA;AACnB,mDAA8C;AAArC,4GAAA,UAAU,OAAA;AACnB,uDAAkD;AAAzC,gHAAA,YAAY,OAAA;AAErB;;;GAGG;AACH,MAAa,KAAM,SAAQ,2BAAU;IACnC,YAAY,KAAa;QACvB,KAAK,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC,CAAC;IACjD,CAAC;CACF;AAJD,sBAIC"}

package/dist/cjs/codecs.d.ts

@@ -1,71 +1,20 @@
-import { Codec } from './codec.js';
+import type { ICodec } from './types.js';
+import { type BaseName } from './bases.js';
 /**
- * Pre-defined codec instances for common base encodings.
- *
- * Use these for encoding/decoding without creating codec instances manually.
- * Each codec provides `encode()`, `decode()`, `validate()`, and `convertTo()` methods.
+ * A ready-made codec for every name in `Bases`.
  *
  * @example
  * ```typescript
  * import { Codecs } from 'bufferbase';
  *
- * // Encode to Base58
- * const encoded = Codecs.base58.encode(Buffer.from('Hello'));
- *
- * // Decode from Base58
- * const decoded = Codecs.base58.decode(encoded);
- *
- * // Convert between bases
- * const base64 = Codecs.base58.convertTo(Codecs.base64url, encoded);
- *
- * // Validate
- * Codecs.base58.validate(encoded); // true
+ * Codecs.base58.encode(Buffer.from('Hello'));      // '9Ajdvzr'
+ * Codecs.base64.encode(Buffer.from('fo'));         // 'Zm8='
+ * Codecs.base58.convertTo(Codecs.base64url, '9Ajdvzr');
  * ```
- *
- * Available codecs:
- * - `decimal` - Base 10 (0-9)
- * - `base16` / `hex` - Hexadecimal (0-9A-F)
- * - `base32` - RFC 4648 Base32 (A-Z2-7)
- * - `base32crockford` - Crockford's Base32
- * - `base36` - Alphanumeric (0-9A-Z)
- * - `base52` - Letters only (A-Za-z)
- * - `base58` - Bitcoin alphabet
- * - `base64` - Standard Base64
- * - `base64url` - URL-safe Base64
- * - `base64xml` - XML token Base64
- * - `base64xmlname` - XML name Base64
- * - `ascii85` - ASCII85 encoding
- * - `base85` - Base85 encoding
- * - `z85` - ZeroMQ Z85 encoding
  */
-export declare const Codecs: {
-    readonly decimal: Codec;
-    readonly base16: Codec;
-    readonly hex: Codec;
-    readonly base32: Codec;
-    readonly base32crockford: Codec;
-    readonly base36: Codec;
-    readonly base52: Codec;
-    readonly base58: Codec;
-    readonly base64: Codec;
-    readonly base64url: Codec;
-    readonly base64xml: Codec;
-    readonly base64xmlname: Codec;
-    readonly ascii85: Codec;
-    readonly base85: Codec;
-    readonly z85: Codec;
-};
+export declare const Codecs: Record<BaseName, ICodec>;
 /**
  * Type representing valid codec names in the `Codecs` object.
- *
- * @example
- * ```typescript
- * import { Codecs, CodecName } from 'bufferbase';
- *
- * function getCodec(name: CodecName) {
- *   return Codecs[name];
- * }
- * ```
  */
-export type CodecName = keyof typeof Codecs;
+export type CodecName = BaseName;
 //# sourceMappingURL=codecs.d.ts.map

package/dist/cjs/codecs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"codecs.d.ts","sourceRoot":"","sources":["../../src/codecs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAgDnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;CAgBT,CAAC;AAEX;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,OAAO,MAAM,CAAC"}
+{"version":3,"file":"codecs.d.ts","sourceRoot":"","sources":["../../src/codecs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,EAAS,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAC;AAGlD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,MAAM,EAEd,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;AAE9B;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,QAAQ,CAAC"}

package/dist/cjs/codecs.js

@@ -1,92 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Codecs = void 0;
-const codec_js_1 = require("./codec.js");
 const bases_js_1 = require("./bases.js");
-/** Decimal (base 10) codec: 0-9 */
-const decimal = new codec_js_1.Codec(bases_js_1.Chars.Decimal);
-/** Hexadecimal (base 16) codec: 0-9A-F */
-const base16 = new codec_js_1.Codec(bases_js_1.Chars.Base16);
-/** Alias for base16 */
-const hex = base16;
-/** RFC 4648 Base32 codec: A-Z2-7 */
-const base32 = new codec_js_1.Codec(bases_js_1.Chars.Base32);
-/** Crockford's Base32 codec: 0-9A-HJKMNP-TV-Z (no I, L, O, U) */
-const base32crockford = new codec_js_1.Codec(bases_js_1.Chars.Base32Crockford);
-/** Base36 codec: 0-9A-Z */
-const base36 = new codec_js_1.Codec(bases_js_1.Chars.Base36);
-/** Base52 codec: A-Za-z (letters only) */
-const base52 = new codec_js_1.Codec(bases_js_1.Chars.Base52);
-/** Bitcoin Base58 codec: 1-9A-HJ-NP-Za-km-z (no 0, O, I, l) */
-const base58 = new codec_js_1.Codec(bases_js_1.Chars.Base58);
-/** Standard Base64 codec: A-Za-z0-9+/ */
-const base64 = new codec_js_1.Codec(bases_js_1.Chars.Base64);
-/** URL-safe Base64 codec: A-Za-z0-9-_ */
-const base64url = new codec_js_1.Codec(bases_js_1.Chars.Base64Url);
-/** XML token Base64 codec: A-Za-z0-9._ */
-const base64xml = new codec_js_1.Codec(bases_js_1.Chars.Base64Xml);
-/** XML name Base64 codec: A-Za-z0-9_: */
-const base64xmlname = new codec_js_1.Codec(bases_js_1.Chars.Base64XmlName);
-/** ASCII85 codec */
-const ascii85 = new codec_js_1.Codec(bases_js_1.Chars.Ascii85);
-/** Base85 codec */
-const base85 = new codec_js_1.Codec(bases_js_1.Chars.Base85);
-/** ZeroMQ Z85 codec */
-const z85 = new codec_js_1.Codec(bases_js_1.Chars.Z85);
+const codec_js_1 = require("./codec.js");
 /**
- * Pre-defined codec instances for common base encodings.
- *
- * Use these for encoding/decoding without creating codec instances manually.
- * Each codec provides `encode()`, `decode()`, `validate()`, and `convertTo()` methods.
+ * A ready-made codec for every name in `Bases`.
  *
  * @example
  * ```typescript
  * import { Codecs } from 'bufferbase';
  *
- * // Encode to Base58
- * const encoded = Codecs.base58.encode(Buffer.from('Hello'));
- *
- * // Decode from Base58
- * const decoded = Codecs.base58.decode(encoded);
- *
- * // Convert between bases
- * const base64 = Codecs.base58.convertTo(Codecs.base64url, encoded);
- *
- * // Validate
- * Codecs.base58.validate(encoded); // true
+ * Codecs.base58.encode(Buffer.from('Hello'));      // '9Ajdvzr'
+ * Codecs.base64.encode(Buffer.from('fo'));         // 'Zm8='
+ * Codecs.base58.convertTo(Codecs.base64url, '9Ajdvzr');
  * ```
- *
- * Available codecs:
- * - `decimal` - Base 10 (0-9)
- * - `base16` / `hex` - Hexadecimal (0-9A-F)
- * - `base32` - RFC 4648 Base32 (A-Z2-7)
- * - `base32crockford` - Crockford's Base32
- * - `base36` - Alphanumeric (0-9A-Z)
- * - `base52` - Letters only (A-Za-z)
- * - `base58` - Bitcoin alphabet
- * - `base64` - Standard Base64
- * - `base64url` - URL-safe Base64
- * - `base64xml` - XML token Base64
- * - `base64xmlname` - XML name Base64
- * - `ascii85` - ASCII85 encoding
- * - `base85` - Base85 encoding
- * - `z85` - ZeroMQ Z85 encoding
  */
-exports.Codecs = {
-    decimal,
-    base16,
-    hex,
-    base32,
-    base32crockford,
-    base36,
-    base52,
-    base58,
-    base64,
-    base64url,
-    base64xml,
-    base64xmlname,
-    ascii85,
-    base85,
-    z85,
-};
+exports.Codecs = Object.fromEntries(Object.entries(bases_js_1.Bases).map(([name, spec]) => [name, (0, codec_js_1.getCodec)(spec)]));
 //# sourceMappingURL=codecs.js.map

package/dist/cjs/codecs.js.map

@@ -1 +1 @@
-{"version":3,"file":"codecs.js","sourceRoot":"","sources":["../../src/codecs.ts"],"names":[],"mappings":";;;AAAA,yCAAmC;AACnC,yCAAmC;AAEnC,mCAAmC;AACnC,MAAM,OAAO,GAAG,IAAI,gBAAK,CAAC,gBAAK,CAAC,OAAO,CAAC,CAAC;AAEzC,0CAA0C;AAC1C,MAAM,MAAM,GAAG,IAAI,gBAAK,CAAC,gBAAK,CAAC,MAAM,CAAC,CAAC;AAEvC,uBAAuB;AACvB,MAAM,GAAG,GAAG,MAAM,CAAC;AAEnB,oCAAoC;AACpC,MAAM,MAAM,GAAG,IAAI,gBAAK,CAAC,gBAAK,CAAC,MAAM,CAAC,CAAC;AAEvC,iEAAiE;AACjE,MAAM,eAAe,GAAG,IAAI,gBAAK,CAAC,gBAAK,CAAC,eAAe,CAAC,CAAC;AAEzD,2BAA2B;AAC3B,MAAM,MAAM,GAAG,IAAI,gBAAK,CAAC,gBAAK,CAAC,MAAM,CAAC,CAAC;AAEvC,0CAA0C;AAC1C,MAAM,MAAM,GAAG,IAAI,gBAAK,CAAC,gBAAK,CAAC,MAAM,CAAC,CAAC;AAEvC,+DAA+D;AAC/D,MAAM,MAAM,GAAG,IAAI,gBAAK,CAAC,gBAAK,CAAC,MAAM,CAAC,CAAC;AAEvC,yCAAyC;AACzC,MAAM,MAAM,GAAG,IAAI,gBAAK,CAAC,gBAAK,CAAC,MAAM,CAAC,CAAC;AAEvC,yCAAyC;AACzC,MAAM,SAAS,GAAG,IAAI,gBAAK,CAAC,gBAAK,CAAC,SAAS,CAAC,CAAC;AAE7C,0CAA0C;AAC1C,MAAM,SAAS,GAAG,IAAI,gBAAK,CAAC,gBAAK,CAAC,SAAS,CAAC,CAAC;AAE7C,yCAAyC;AACzC,MAAM,aAAa,GAAG,IAAI,gBAAK,CAAC,gBAAK,CAAC,aAAa,CAAC,CAAC;AAErD,oBAAoB;AACpB,MAAM,OAAO,GAAG,IAAI,gBAAK,CAAC,gBAAK,CAAC,OAAO,CAAC,CAAC;AAEzC,mBAAmB;AACnB,MAAM,MAAM,GAAG,IAAI,gBAAK,CAAC,gBAAK,CAAC,MAAM,CAAC,CAAC;AAEvC,uBAAuB;AACvB,MAAM,GAAG,GAAG,IAAI,gBAAK,CAAC,gBAAK,CAAC,GAAG,CAAC,CAAC;AAEjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACU,QAAA,MAAM,GAAG;IACpB,OAAO;IACP,MAAM;IACN,GAAG;IACH,MAAM;IACN,eAAe;IACf,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,SAAS;IACT,SAAS;IACT,aAAa;IACb,OAAO;IACP,MAAM;IACN,GAAG;CACK,CAAC"}
+{"version":3,"file":"codecs.js","sourceRoot":"","sources":["../../src/codecs.ts"],"names":[],"mappings":";;;AACA,yCAAkD;AAClD,yCAAsC;AAEtC;;;;;;;;;;;GAWG;AACU,QAAA,MAAM,GAAG,MAAM,CAAC,WAAW,CACtC,MAAM,CAAC,OAAO,CAAC,gBAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,IAAA,mBAAQ,EAAC,IAAI,CAAC,CAAC,CAAC,CACxC,CAAC"}

package/dist/cjs/errors.d.ts

@@ -1,18 +1,5 @@
 /**
  * Error thrown when an invalid character is encountered during decoding.
- *
- * @example
- * ```typescript
- * import { decode, InvalidCharacterError } from 'bufferbase';
- *
- * try {
- *   decode('invalid!', 'base58');
- * } catch (e) {
- *   if (e instanceof InvalidCharacterError) {
- *     console.log(e.message); // "Invalid character found: '!'"
- *   }
- * }
- * ```
  */
 export declare class InvalidCharacterError extends Error {
     /**
@@ -21,24 +8,8 @@ export declare class InvalidCharacterError extends Error {
     constructor(char?: string);
 }
 /**
- * Error thrown when decoded buffer size exceeds the specified size.
- *
- * This error is thrown when using the `size` option in decode operations
- * and the decoded data is larger than the specified size.
- *
- * @example
- * ```typescript
- * import { decode, BufferSizeError } from 'bufferbase';
- *
- * try {
- *   // Trying to decode into a buffer too small
- *   decode('72k1xXWG59fYdzSNoA', 'base58', { size: 2 });
- * } catch (e) {
- *   if (e instanceof BufferSizeError) {
- *     console.log(e.message); // "Buffer size 13 exceeds specified size 2"
- *   }
- * }
- * ```
+ * Error thrown when the decoded buffer does not have the size requested
+ * through `DecodeOptions.size`.
  */
 export declare class BufferSizeError extends Error {
     /**
@@ -49,23 +20,6 @@ export declare class BufferSizeError extends Error {
 }
 /**
  * Error thrown when an unknown base name is provided.
- *
- * This error is thrown when using the function API with an invalid base name
- * that is neither a known encoding name nor a valid custom character set
- * (character sets must be longer than 15 characters).
- *
- * @example
- * ```typescript
- * import { encode, UnknownBaseError } from 'bufferbase';
- *
- * try {
- *   encode(Buffer.from('test'), 'invalidbase');
- * } catch (e) {
- *   if (e instanceof UnknownBaseError) {
- *     console.log(e.message); // "Unknown base encoding: 'invalidbase'"
- *   }
- * }
- * ```
  */
 export declare class UnknownBaseError extends Error {
     /**
@@ -73,4 +27,67 @@ export declare class UnknownBaseError extends Error {
      */
     constructor(name: string);
 }
+/**
+ * Error thrown when a string cannot be the encoding of any byte sequence
+ * because of its length.
+ *
+ * A Base64 string of 5 characters, for example, describes 30 bits: too many
+ * for 3 bytes and too few for 4.
+ */
+export declare class InvalidLengthError extends Error {
+    /**
+     * @param length - The length that cannot occur
+     * @param detail - What the length should have been
+     */
+    constructor(length: number, detail: string);
+}
+/**
+ * Error thrown when input is well-formed but is not the canonical encoding of
+ * the bytes it decodes to (RFC 4648 §3.5).
+ *
+ * Accepting such input makes decoding non-injective: `'Zm8='` and `'Zm9='`
+ * would both decode to `'fo'`. Pass `strict: false` in the codec spec to allow
+ * it.
+ */
+export declare class NonCanonicalError extends Error {
+    /**
+     * @param detail - What made the input non-canonical
+     */
+    constructor(detail: string);
+}
+/**
+ * Error thrown when a codec spec cannot be realised, such as a `'block'`
+ * algorithm with an alphabet whose length is not a power of two.
+ */
+export declare class InvalidCodecError extends Error {
+    /**
+     * @param detail - Why the spec is unusable
+     */
+    constructor(detail: string);
+}
+/**
+ * Error thrown when a group of characters denotes a number too large for the
+ * bytes it is supposed to encode.
+ *
+ * In an Ascii85 group, five characters must denote a value below 2^32; `'s8W-!'`
+ * does not, so it encodes nothing. Unlike `NonCanonicalError` this is never
+ * allowed, because there is no byte sequence to decode to.
+ */
+export declare class ValueRangeError extends Error {
+    /**
+     * @param group - The group of characters that is out of range
+     */
+    constructor(group: string);
+}
+/**
+ * Error thrown when a trailing check symbol does not match the value it
+ * follows, which means the string was mistyped or corrupted.
+ */
+export declare class CheckSymbolError extends Error {
+    /**
+     * @param found - The check symbol present in the input
+     * @param expected - The check symbol the value calls for
+     */
+    constructor(found: string, expected: string);
+}
 //# sourceMappingURL=errors.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C;;OAEG;gBACS,IAAI,CAAC,EAAE,MAAM;CAK1B;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,eAAgB,SAAQ,KAAK;IACxC;;;OAGG;gBACS,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;CAI7C;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;IACzC;;OAEG;gBACS,IAAI,EAAE,MAAM;CAIzB"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C;;OAEG;gBACS,IAAI,CAAC,EAAE,MAAM;CAK1B;AAED;;;GAGG;AACH,qBAAa,eAAgB,SAAQ,KAAK;IACxC;;;OAGG;gBACS,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;CAI7C;AAED;;GAEG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;IACzC;;OAEG;gBACS,IAAI,EAAE,MAAM;CAOzB;AAED;;;;;;GAMG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C;;;OAGG;gBACS,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAI3C;AAED;;;;;;;GAOG;AACH,qBAAa,iBAAkB,SAAQ,KAAK;IAC1C;;OAEG;gBACS,MAAM,EAAE,MAAM;CAI3B;AAED;;;GAGG;AACH,qBAAa,iBAAkB,SAAQ,KAAK;IAC1C;;OAEG;gBACS,MAAM,EAAE,MAAM;CAI3B;AAED;;;;;;;GAOG;AACH,qBAAa,eAAgB,SAAQ,KAAK;IACxC;;OAEG;gBACS,KAAK,EAAE,MAAM;CAI1B;AAED;;;GAGG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;IACzC;;;OAGG;gBACS,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;CAI5C"}