bufferbase 2.0.0 → 3.0.0

package/README.md

@@ -1,6 +1,7 @@
 # bufferbase
 
-Buffer-to-BaseN encoding and decoding for Node.js.
+Buffer-to-BaseN encoding for Node.js and the browser, across three algorithms:
+RFC 4648 bit-block encodings, Ascii85/Z85, and Base58-style radix conversion.
 
 ## Installation
 
@@ -8,106 +9,193 @@ Buffer-to-BaseN encoding and decoding for Node.js.
 npm install bufferbase
 ```
 
+## The three algorithms
+
+An alphabet does not describe an encoding on its own. The same 64 characters
+can be read as a radix conversion or as a bit-block encoding, and the two
+produce different strings for the same bytes. Every codec here therefore names
+its algorithm.
+
+| Algorithm | How it works | Alphabet | Used by |
+|---|---|---|---|
+| `block` | Regroups the bit stream into `log2(n)`-bit chunks, per RFC 4648 | 2, 4, 8, 16, 32, or 64 characters | Base16, Base32, Base64 |
+| `block85` | Converts each 4-byte block to 5 characters | exactly 85 characters | Ascii85, Z85 |
+| `radix` | Reads the buffer as one integer and rewrites it in base `n` | any length | Base58, Base36, Crockford |
+
+```typescript
+import { encode } from 'bufferbase';
+
+encode(Buffer.from('fo'), 'base64');  // 'Zm8='  — RFC 4648
+encode(Buffer.from('fo'), 'radix64'); // 'GZv'   — radix conversion
+```
+
+Only `radix` accepts an alphabet of any length, and only `radix` preserves
+leading zero bytes as leading characters. Only `block` and `block85` have an
+output length that is a fixed function of the input length.
+
+## Supported encodings
+
+| Name | Algorithm | Characters | Notes |
+|---|---|---|---|
+| `base16`, `hex` | `block` | 0-9A-F | RFC 4648 Table 5, unpadded |
+| `base32` | `block` | A-Z2-7 | RFC 4648 Table 3 |
+| `base32hex` | `block` | 0-9A-V | RFC 4648 Table 4 |
+| `base64` | `block` | A-Za-z0-9+/ | RFC 4648 Table 1 |
+| `base64url` | `block` | A-Za-z0-9-_ | RFC 4648 Table 2, unpadded |
+| `base64xml` | `block` | A-Za-z0-9._ | unpadded |
+| `base64xmlname` | `block` | A-Za-z0-9_: | unpadded |
+| `ascii85` | `block85` | `!` to `u` | zero-block shortcut on |
+| `z85` | `block85` | ZeroMQ RFC 32 | whole 4-byte blocks only |
+| `base58` | `radix` | Bitcoin alphabet | |
+| `base32crockford` | `radix` | 0-9A-HJKMNP-TV-Z | |
+| `base32crockfordcheck` | `radix` | as above, plus `*~$=U` | carries a check symbol |
+| `base36` | `radix` | 0-9A-Z | case-insensitive |
+| `base52` | `radix` | A-Za-z | |
+| `decimal` | `radix` | 0-9 | |
+| `radix16`, `radix32`, `radix64`, `radix64url` | `radix` | the RFC alphabets | radix conversion, not RFC 4648 |
+
+Base16, Base32, Base32hex, Base36 and both Crockford codecs decode in either
+case.
+
 ## Usage
 
-### Simple Function API
+### Functions
 
 ```typescript
 import { encode, decode, convert, validate } from 'bufferbase';
 
-// Encode buffer to base58
-const encoded = encode(Buffer.from('Hello'), 'base58');
+encode(Buffer.from('Hello'), 'base58');       // '9Ajdvzr'
+decode('9Ajdvzr', 'base58');                  // Buffer('Hello')
+decode('9Ajdvzr', 'base58', { size: 32 });    // padded to 32 bytes
+convert('9Ajdvzr', 'base58', 'base64url');    // through the bytes
+validate('Zm8=', 'base64');                   // true
+```
 
-// Decode base58 string to buffer
-const decoded = decode(encoded, 'base58');
+`validate(input, base)` returns `true` exactly when `decode(input, base)`
+succeeds, so the two never disagree.
 
-// Decode with fixed size (pads with leading zeros)
-const fixed = decode(encoded, 'base58', { size: 32 });
+### Codecs
 
-// Convert between bases
-const base64 = convert(encoded, 'base58', 'base64url');
+```typescript
+import { Codecs } from 'bufferbase';
 
-// Validate string
-validate('9Ajdvz', 'base58'); // true
-validate('0Ajdvz', 'base58'); // false ('0' not in base58)
+Codecs.base64.encode(Buffer.from('fo'));      // 'Zm8='
+Codecs.base58.convertTo(Codecs.base64url, '9Ajdvzr');
 ```
 
-### Pre-defined Codecs
+### Custom codecs
+
+Pass a spec anywhere a base name is accepted.
 
 ```typescript
-import { Codecs } from 'bufferbase';
+import { createCodec, encode } from 'bufferbase';
+
+encode(Uint8Array.of(5), { alphabet: '01', algorithm: 'radix' }); // '101'
+
+const lowerHex = createCodec({ alphabet: '0123456789abcdef', algorithm: 'block', pad: false });
+lowerHex.encode(Uint8Array.of(0, 1)); // '0001'
+
+createCodec('01'); // a bare string means a radix codec over that alphabet
+```
 
-const encoded = Codecs.base58.encode(Buffer.from('Hello'));
-const decoded = Codecs.base58.decode(encoded);
+### Crockford's Base32
 
-// Convert between codecs
-const base64 = Codecs.base58.convertTo(Codecs.base64url, encoded);
+Crockford's specification describes 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 the hyphens
+that may be inserted for readability. Encoding emits only the alphabet.
 
-// Validate
-Codecs.base58.validate('9Ajdvz'); // true
+```typescript
+decode('91jprv3f', 'base32crockford');   // Buffer('Hello')
+decode('91JP-RV3F', 'base32crockford');  // the same
+decode('9IJPRV3F', 'base32crockford');   // the same, reading I as 1
 ```
 
-### Custom Character Set
+`base32crockfordcheck` appends the check symbol, the value modulo 37 written
+with the alphabet extended by `*~$=U`. Decoding verifies it, so a mistyped
+character is caught rather than decoded into different bytes.
 
 ```typescript
-import { createCodec } from 'bufferbase';
+encode(Buffer.from('Hello'), 'base32crockfordcheck'); // '91JPRV3FG'
+validate('91JPRV3XG', 'base32crockfordcheck');        // false
+```
+
+### Ascii85 variants
+
+Several incompatible encodings share the Ascii85 algorithm and alphabet,
+differing only in the shortcuts and framing they add. They are options rather
+than separate codecs. The `ascii85` default is `zeroShortcut` alone, which
+matches Python's `base64.a85encode`.
 
-const binary = createCodec('01');
-binary.encode(Buffer.from([5])); // '101'
-binary.decode('101'); // Buffer([5])
+```typescript
+import { createCodec, Chars } from 'bufferbase';
+
+const btoa = createCodec({
+  alphabet: Chars.Ascii85, algorithm: 'block85',
+  zeroShortcut: true, spaceShortcut: true,      // '    ' -> 'y'
+});
+
+const adobe = createCodec({
+  alphabet: Chars.Ascii85, algorithm: 'block85',
+  zeroShortcut: true, delimiters: true,          // '<~ ... ~>'
+});
 ```
 
-## Supported Encodings
-
-| Name | Characters |
-|------|------------|
-| `decimal` | 0-9 |
-| `base16` / `hex` | 0-9A-F |
-| `base32` | A-Z2-7 |
-| `base32crockford` | 0-9A-HJKMNP-TV-Z |
-| `base36` | 0-9A-Z |
-| `base52` | A-Za-z |
-| `base58` | Bitcoin alphabet (no 0OIl) |
-| `base64` | A-Za-z0-9+/ |
-| `base64url` | A-Za-z0-9-_ |
-| `base64xml` | A-Za-z0-9._ |
-| `base64xmlname` | A-Za-z0-9_: |
-| `ascii85` | ASCII85 |
-| `base85` | Base85 |
-| `z85` | ZeroMQ Z85 |
+## Canonical encodings
 
-## API
+A trailing partial block leaves spare bits in the final character. RFC 4648
+§3.5 requires them to be zero; input that sets them decodes to the same bytes
+as the canonical form, so accepting it makes decoding non-injective.
 
-### Functions
+```typescript
+decode('Zm8=', 'base64'); // Buffer('fo')
+decode('Zm9=', 'base64'); // throws NonCanonicalError — also 'fo'
+```
+
+This is rejected by default. Pass `strict: false` to read data from a lenient
+encoder.
 
-- `encode(buffer, base)` - Encode buffer to string
-- `decode(encoded, base, options?)` - Decode string to buffer
-- `convert(input, from, to)` - Convert between bases
-- `validate(input, base)` - Check if string is valid for base
-- `createCodec(chars)` - Create codec with custom character set
+```typescript
+createCodec({ alphabet: Chars.Base64, algorithm: 'block', strict: false });
+```
 
-### Codecs Object
+The same check rejects lengths that cannot be a whole number of bytes
+(`'Zm9vd'`), misplaced or excess padding, and Ascii85 groups above 2^32.
+
+## API
 
 ```typescript
-Codecs.base58.encode(buffer)
-Codecs.base58.decode(encoded, options?)
-Codecs.base58.validate(input)
-Codecs.base58.convertTo(targetCodec, input)
+encode(buffer, base)              // string
+decode(encoded, base, options?)   // Buffer
+convert(input, from, to)          // string
+validate(input, base)             // boolean
+createCodec(spec | alphabet)      // ICodec
 ```
 
-### Options
+`base` is a name from the table above or a `CodecSpec`. Every spec accepts
+`strict`, `caseInsensitive`, `aliases` and `ignore`:
 
 ```typescript
-interface DecodeOptions {
-  size?: number; // Expected buffer size (pads with zeros if smaller)
-}
+type CodecSpec =
+  | { alphabet: string; algorithm: 'radix'; checkSymbols?: string }
+  | { alphabet: string; algorithm: 'block'; pad?: string | false }
+  | { alphabet: string; algorithm: 'block85';
+      zeroShortcut?: boolean; spaceShortcut?: boolean;
+      delimiters?: boolean; requireFullBlocks?: boolean };
 ```
 
 ### Errors
 
-- `InvalidCharacterError` - Invalid character in decode input
-- `BufferSizeError` - Decoded buffer exceeds specified size
-- `UnknownBaseError` - Unknown base name
+| Error | Thrown when |
+|---|---|
+| `InvalidCharacterError` | a character is not in the alphabet |
+| `InvalidLengthError` | the length cannot encode a whole number of bytes |
+| `NonCanonicalError` | spare bits are set and the codec is strict |
+| `ValueRangeError` | a block85 group is 2^32 or above |
+| `CheckSymbolError` | a check symbol does not match the value it follows |
+| `BufferSizeError` | the result does not have the requested `size` |
+| `UnknownBaseError` | the base name is not known |
+| `InvalidCodecError` | the spec cannot be realised |
 
 ## License
 

package/dist/cjs/bases.d.ts

@@ -1,25 +1,19 @@
-import type { BaseName } from './types.js';
+import type { CodecSpec } from './types.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 declare const Chars: {
     /** Base 10: 0-9 */
     readonly Decimal: "0123456789";
-    /** Hexadecimal: 0-9A-F */
+    /** RFC 4648 Table 5 — Base16: 0-9A-F */
     readonly Base16: "0123456789ABCDEF";
-    /** RFC 4648 Base32: A-Z2-7 */
+    /** RFC 4648 Table 3 — Base32: A-Z2-7 */
     readonly Base32: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+    /** RFC 4648 Table 4 — Base32 with extended hex alphabet: 0-9A-V */
+    readonly Base32Hex: "0123456789ABCDEFGHIJKLMNOPQRSTUV";
     /** Crockford's Base32: 0-9A-HJKMNP-TV-Z (no I, L, O, U) */
     readonly Base32Crockford: "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
     /** Alphanumeric: 0-9A-Z */
@@ -28,55 +22,168 @@ export declare const Chars: {
     readonly Base52: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     /** Bitcoin alphabet: 1-9A-HJ-NP-Za-km-z (no 0, O, I, l) */
     readonly Base58: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
-    /** Standard Base64: A-Za-z0-9+/ */
+    /** RFC 4648 Table 1 — Base64: A-Za-z0-9+/ */
     readonly Base64: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-    /** URL-safe Base64: A-Za-z0-9-_ */
+    /** RFC 4648 Table 2 — URL-safe Base64: A-Za-z0-9-_ */
     readonly Base64Url: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
     /** XML token Base64: A-Za-z0-9._ */
     readonly Base64Xml: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._";
     /** XML name Base64: A-Za-z0-9_: */
     readonly Base64XmlName: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_:";
-    /** ASCII85 encoding */
-    readonly Ascii85: "!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstu";
-    /** Base85 encoding */
-    readonly Base85: "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!#$%&()*+-;<=>?@^_`{|}~";
-    /** ZeroMQ Z85 encoding */
+    /** Ascii85: the 85 printable characters from `!` (0x21) to `u` (0x75) */
+    readonly Ascii85: "!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstu";
+    /** ZeroMQ Z85 (RFC 32): avoids the quote and backslash characters */
     readonly Z85: "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.-:+=^!/*?&<>()[]{}@%$#";
+    /** The five symbols Crockford's Base32 adds for its check symbol, giving a modulus of 37 */
+    readonly CrockfordCheck: "*~$=U";
 };
 /**
- * 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 declare function resolveChars(base: BaseName | string): string;
+export declare const Bases: {
+    readonly decimal: {
+        readonly alphabet: "0123456789";
+        readonly algorithm: "radix";
+    };
+    readonly base36: {
+        readonly alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+        readonly algorithm: "radix";
+        readonly caseInsensitive: true;
+    };
+    readonly base52: {
+        readonly alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+        readonly algorithm: "radix";
+    };
+    readonly base58: {
+        readonly alphabet: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+        readonly 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.
+     */
+    readonly base32crockford: {
+        readonly alphabet: "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+        readonly algorithm: "radix";
+        readonly caseInsensitive: true;
+        readonly aliases: {
+            readonly I: "1";
+            readonly L: "1";
+            readonly O: "0";
+        };
+        readonly ignore: "-";
+    };
+    /** Crockford's Base32 carrying its trailing check symbol. */
+    readonly base32crockfordcheck: {
+        readonly alphabet: "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+        readonly algorithm: "radix";
+        readonly caseInsensitive: true;
+        readonly aliases: {
+            readonly I: "1";
+            readonly L: "1";
+            readonly O: "0";
+        };
+        readonly ignore: "-";
+        readonly checkSymbols: "*~$=U";
+    };
+    readonly base16: {
+        readonly alphabet: "0123456789ABCDEF";
+        readonly algorithm: "block";
+        readonly pad: false;
+        readonly caseInsensitive: true;
+    };
+    readonly hex: {
+        readonly alphabet: "0123456789ABCDEF";
+        readonly algorithm: "block";
+        readonly pad: false;
+        readonly caseInsensitive: true;
+    };
+    readonly base32: {
+        readonly alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+        readonly algorithm: "block";
+        readonly caseInsensitive: true;
+    };
+    readonly base32hex: {
+        readonly alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUV";
+        readonly algorithm: "block";
+        readonly caseInsensitive: true;
+    };
+    readonly base64: {
+        readonly alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+        readonly algorithm: "block";
+    };
+    /** Unpadded, as used by JWT and other URL-facing formats. */
+    readonly base64url: {
+        readonly alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+        readonly algorithm: "block";
+        readonly pad: false;
+    };
+    readonly base64xml: {
+        readonly alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._";
+        readonly algorithm: "block";
+        readonly pad: false;
+    };
+    readonly base64xmlname: {
+        readonly alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_:";
+        readonly algorithm: "block";
+        readonly pad: false;
+    };
+    /** Ascii85 with the zero-block shortcut, matching Python's `a85encode`. */
+    readonly ascii85: {
+        readonly alphabet: "!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstu";
+        readonly algorithm: "block85";
+        readonly zeroShortcut: true;
+    };
+    /** ZeroMQ Z85, which has no padding and so encodes whole blocks only. */
+    readonly z85: {
+        readonly alphabet: "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.-:+=^!/*?&<>()[]{}@%$#";
+        readonly algorithm: "block85";
+        readonly requireFullBlocks: true;
+    };
+    readonly radix16: {
+        readonly alphabet: "0123456789ABCDEF";
+        readonly algorithm: "radix";
+    };
+    readonly radix32: {
+        readonly alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+        readonly algorithm: "radix";
+    };
+    readonly radix64: {
+        readonly alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+        readonly algorithm: "radix";
+    };
+    readonly radix64url: {
+        readonly alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+        readonly algorithm: "radix";
+    };
+};
 /**
- * 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';
+ * The names accepted wherever a base is expected.
+ */
+export type BaseName = keyof typeof Bases;
+/**
+ * Resolves a base name to its codec spec, and passes a spec through unchanged.
  *
- * isBaseName('base58'); // true
- * isBaseName('BASE58'); // true (case-insensitive)
- * isBaseName('unknown'); // false
- * ```
+ * @throws {UnknownBaseError} If the name is not one of `Bases`
+ */
+export declare function resolveSpec(base: BaseName | CodecSpec): CodecSpec;
+/**
+ * Checks whether a string names one of the encodings in `Bases`.
  */
 export declare function isBaseName(value: string): value is BaseName;
 //# sourceMappingURL=bases.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"bases.d.ts","sourceRoot":"","sources":["../../src/bases.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAG3C;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,KAAK;IAChB,mBAAmB;;IAEnB,0BAA0B;;IAE1B,8BAA8B;;IAE9B,2DAA2D;;IAE3D,2BAA2B;;IAE3B,2BAA2B;;IAE3B,2DAA2D;;IAE3D,mCAAmC;;IAEnC,mCAAmC;;IAEnC,oCAAoC;;IAEpC,mCAAmC;;IAEnC,uBAAuB;;IAEvB,sBAAsB;;IAEtB,0BAA0B;;CAElB,CAAC;AAwBX;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,MAAM,CAW5D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,QAAQ,CAE3D"}
+{"version":3,"file":"bases.d.ts","sourceRoot":"","sources":["../../src/bases.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAG5C;;;;;GAKG;AACH,eAAO,MAAM,KAAK;IAChB,mBAAmB;;IAEnB,wCAAwC;;IAExC,wCAAwC;;IAExC,mEAAmE;;IAEnE,2DAA2D;;IAE3D,2BAA2B;;IAE3B,2BAA2B;;IAE3B,2DAA2D;;IAE3D,6CAA6C;;IAE7C,sDAAsD;;IAEtD,oCAAoC;;IAEpC,mCAAmC;;IAEnC,yEAAyE;;IAEzE,qEAAqE;;IAErE,4FAA4F;;CAEpF,CAAC;AAKX;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;IAOhB;;;;;;OAMG;;;;;;;;;;;;IAQH,6DAA6D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAgB7D,6DAA6D;;;;;;;;;;;;;;;;IAM7D,2EAA2E;;;;;;IAE3E,yEAAyE;;;;;;;;;;;;;;;;;;;;;;CAQ7B,CAAC;AAE/C;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,OAAO,KAAK,CAAC;AAE1C;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,QAAQ,GAAG,SAAS,GAAG,SAAS,CASjE;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,QAAQ,CAE3D"}