zeed 1.2.2 → 1.3.0

package/dist/array-Dwd6BYuK.d.cts

@@ -0,0 +1,197 @@
+import { n as NestedArray } from "./types-BCtWYsuv.cjs";
+
+//#region src/common/data/array.d.ts
+/**
+ * Return a new array with duplicate values removed. Maintains first occurrence order.
+ * @typeParam T - element type
+ * @param arr - input array
+ * @returns new array containing unique elements from `arr`
+ */
+declare function arrayUnique<T>(arr: T[]): T[];
+/**
+ * Return elements present in `x` but not in `y`.
+ * @typeParam T - element type
+ * @param left - left-hand array
+ * @param right - array of elements to exclude
+ * @returns new array with elements from `left` that are not included in `right`
+ */
+declare function arrayMinus<T>(left: T[], right: T[]): T[];
+/**
+ * Return the union of multiple arrays (unique elements across all inputs).
+ * @typeParam T - element type
+ * @param arrays - arrays to union
+ * @returns new array with unique elements from all provided arrays
+ */
+declare function arrayUnion<T>(...arrays: T[][]): T[];
+/** `[1,[2,3]]` becomes `[1,2,3]` */
+/**
+ * Flatten nested arrays to a single-level array.
+ * Example: `[1, [2, 3]]` becomes `[1, 2, 3]`.
+ * @typeParam T - element type
+ * @param arrays - one or more nested arrays to flatten
+ * @returns flattened array containing all elements
+ */
+declare function arrayFlatten<T>(...arrays: NestedArray<T>[]): T[];
+/**
+ * Return the intersection of two arrays (elements present in both).
+ * @typeParam T - element type
+ * @param left - first array
+ * @param right - second array
+ * @returns new array with elements present in both `left` and `right`
+ */
+declare function arrayIntersection<T>(left: T[], right: T[]): T[];
+/**
+ * Return the symmetric difference between two arrays (elements in either array but not both).
+ * @typeParam T - element type
+ */
+declare function arraySymmetricDifference<T>(left: T[], right: T[]): T[];
+/**
+ * Remove all occurrences of `el` from `arr` in-place and return the mutated array.
+ * If `arr` is not an array, returns an empty array.
+ * @typeParam T - element type
+ * @param arr - array to modify
+ * @param el - element to remove
+ * @returns the same array instance with `el` removed
+ */
+declare function arrayRemoveElement<T>(arr: T[], el: T): T[];
+/** Only have it once in the set */
+/**
+ * Ensure `el` exists in `arr`. If not present, push it and return the array.
+ * @typeParam T - element type
+ * @param arr - target array
+ * @param el - element to ensure
+ * @returns the same array instance (modified if `el` was added)
+ */
+declare function arraySetElement<T>(arr: T[], el: T): T[];
+/**
+ * Filter an array in-place using `fn` and return the same array instance.
+ * This replaces the array contents with the filtered result.
+ * @typeParam T - element type
+ * @param arr - array to filter in-place
+ * @param fn - predicate to determine which elements to keep
+ * @returns the same array instance after filtering
+ */
+declare function arrayFilterInPlace<T>(arr: T[], fn: (el: T) => boolean): T[];
+/**
+ * Toggle presence of `el` in `array` in-place: remove if present, add if missing.
+ * @typeParam T - element type
+ * @param arr - array to modify
+ * @param el - element to toggle
+ * @returns the same array instance after the toggle
+ */
+declare function arrayToggleInPlace<T>(arr: T[], el: T): T[];
+/**
+ * Empty an array in-place (remove all elements) and return it.
+ * @typeParam T - element type
+ */
+declare function arrayEmptyInPlace<T>(arr: T[]): T[];
+/**
+ * Replace the contents of `array` in-place with `newContent` and return it.
+ * @typeParam T - element type
+ * @param arr - target array to overwrite
+ * @param newContent - new contents to set
+ * @returns the same array instance after replacement
+ */
+declare function arraySetArrayInPlace<T>(arr: T[], newContent: T[]): T[];
+/**
+ * Return a sorted copy of the provided iterable or array-like object.
+ * @typeParam T - element type
+ * @param arr - iterable or array-like input
+ * @param compareFn - optional compare function (defaults to `cmp`)
+ * @returns a new array sorted according to `compareFn`
+ */
+declare function arraySorted<T>(arr: Iterable<T> | ArrayLike<T>, compareFn?: ((a: T, b: T) => number) | undefined): T[];
+/**
+ * Return a new array with numbers sorted in ascending order.
+ * @param arr - array of numbers
+ * @returns sorted array of numbers
+ */
+declare function arraySortedNumbers(arr: number[]): number[];
+/**
+ * Check strict equality of two arrays by length and element-wise === comparison.
+ * @typeParam T - element type
+ * @param array1 - first array
+ * @param array2 - second array
+ * @returns `true` if arrays are same length and all elements strictly equal
+ */
+declare function arrayIsEqual<T>(array1: T[], array2: T[]): boolean;
+/**
+ * Shuffle an array in-place using a secure random source if available.
+ * Note: uses Array.sort with random comparator which is sufficient for many cases but
+ * not perfectly uniform. Returns the same mutated array.
+ * @typeParam T - element type
+ * @param array - array to shuffle in-place
+ * @returns the shuffled array (same instance)
+ */
+declare function arrayShuffleInPlace<T>(arr: T[]): T[];
+/**
+ * Return a shuffled copy of `array` (original array is not modified).
+ * @typeParam T - element type
+ * @param array - input array
+ * @returns a new shuffled array
+ */
+declare function arrayShuffle<T>(arr: T[]): T[];
+/** Randomly shuffle the order of the array's elements. Force to have a different order if array has more than one element. */
+/**
+ * Shuffle `array` and ensure the returned order differs from the original when possible.
+ * If array length is 0 or 1 it is returned unchanged.
+ * @typeParam T - element type
+ * @param array - input array
+ * @returns a shuffled array that's different from the input when feasible
+ */
+declare function arrayShuffleForce<T>(arr: T[]): T[];
+/**
+ * Return a random element from `array` using a secure random source if available.
+ * @typeParam T - element type
+ * @param array - input array (must be non-empty)
+ * @returns a randomly selected element
+ */
+declare function arrayRandomElement<T>(arr: T[]): T;
+/**
+ * Return the maximum value from one or more nested arrays.
+ * Uses the `>` operator for comparison.
+ * @typeParam T - element type (should support `>` comparison)
+ * @param arrays - nested arrays to search
+ * @returns the maximum value or `undefined` if no elements present
+ */
+declare function arrayMax<T>(...arrays: NestedArray<T>[]): T;
+/**
+ * Return the minimum value from one or more nested arrays.
+ * Uses the `<` operator for comparison.
+ * @typeParam T - element type (should support `<` comparison)
+ * @param arrays - nested arrays to search
+ * @returns the minimum value or `undefined` if no elements present
+ */
+declare function arrayMin<T>(...arrays: NestedArray<T>[]): T;
+/**
+ * Sum all numbers in one or more nested arrays.
+ * @param arrays - nested arrays of numbers
+ * @returns the numeric sum (0 for empty input)
+ */
+declare function arraySum(...arrays: NestedArray<number>[]): number;
+/**
+ * Compute the average of numbers across one or more nested arrays.
+ * @param arrays - nested arrays of numbers
+ * @returns arithmetic mean (NaN if there are no elements)
+ */
+declare function arrayAvg(...arrays: NestedArray<number>[]): number;
+/**
+ * Split an array into chunks of `chunkLength` (last chunk may be smaller).
+ * @typeParam T - element type
+ * @param arr - input array
+ * @param chunkLength - chunk size (positive integer)
+ * @returns array of chunk arrays
+ */
+declare function arrayBatches<T>(arr: T[], chunkLength: number): T[][];
+/**
+ * Create an array of given `length` filled with `item` or the result of `item(index)`.
+ * If `length` is <= 0 an empty array is returned.
+ * @typeParam T - element type
+ * @param length - desired length of the array
+ * @param item - value to fill or a function producing a value per index
+ * @returns newly created array of length `length`
+ */
+declare function createArray<T>(length?: number, item?: T | ((index: number) => T)): T[];
+//#endregion
+export { arrayUnion as C, arrayToggleInPlace as S, createArray as T, arrayShuffleInPlace as _, arrayFlatten as a, arraySum as b, arrayMax as c, arrayRandomElement as d, arrayRemoveElement as f, arrayShuffleForce as g, arrayShuffle as h, arrayFilterInPlace as i, arrayMin as l, arraySetElement as m, arrayBatches as n, arrayIntersection as o, arraySetArrayInPlace as p, arrayEmptyInPlace as r, arrayIsEqual as s, arrayAvg as t, arrayMinus as u, arraySorted as v, arrayUnique as w, arraySymmetricDifference as x, arraySortedNumbers as y };
+//# sourceMappingURL=array-Dwd6BYuK.d.cts.map

package/dist/assert-BJxQedEz.d.mts

@@ -0,0 +1,10 @@
+//#region src/common/assert.d.ts
+/** Always throws. */
+declare function fatal(...messages: any[]): never;
+/** Throws if condition is not truthy. */
+declare function assert(condition: unknown, ...messages: any[]): asserts condition;
+/** Alias for `assert` for better differentiation to unit test's assert function. */
+declare function assertCondition(condition: unknown, ...messages: any[]): asserts condition;
+//#endregion
+export { assertCondition as n, fatal as r, assert as t };
+//# sourceMappingURL=assert-BJxQedEz.d.mts.map

package/dist/assert-DbBUaDad.d.cts

@@ -0,0 +1,10 @@
+//#region src/common/assert.d.ts
+/** Always throws. */
+declare function fatal(...messages: any[]): never;
+/** Throws if condition is not truthy. */
+declare function assert(condition: unknown, ...messages: any[]): asserts condition;
+/** Alias for `assert` for better differentiation to unit test's assert function. */
+declare function assertCondition(condition: unknown, ...messages: any[]): asserts condition;
+//#endregion
+export { assertCondition as n, fatal as r, assert as t };
+//# sourceMappingURL=assert-DbBUaDad.d.cts.map

package/dist/base64-180QQxnf.d.cts

@@ -0,0 +1,6 @@
+//#region src/browser/base64.d.ts
+/** @deprecated use fromBase64 instead */
+declare function urlBase64ToUint8Array(base64String: string): Uint8Array | undefined;
+//#endregion
+export { urlBase64ToUint8Array as t };
+//# sourceMappingURL=base64-180QQxnf.d.cts.map

package/dist/base64-Dj_zVMm9.d.mts

@@ -0,0 +1,6 @@
+//#region src/browser/base64.d.ts
+/** @deprecated use fromBase64 instead */
+declare function urlBase64ToUint8Array(base64String: string): Uint8Array | undefined;
+//#endregion
+export { urlBase64ToUint8Array as t };
+//# sourceMappingURL=base64-Dj_zVMm9.d.mts.map

package/dist/basex-D8lNbS7O.d.mts

@@ -0,0 +1,25 @@
+import { t as BinInput } from "./bin-types-CKGKqfwj.mjs";
+
+//#region src/common/data/basex.d.ts
+type BaseXEncodeFunction = (source: BinInput, padToLength?: number) => string;
+type BaseXDecodeFunction = (source: string, padToLength?: number) => Uint8Array;
+declare function _useBase(alphaOrBase: string | number): {
+  encode: BaseXEncodeFunction;
+  decode: BaseXDecodeFunction;
+};
+declare function useBase(alphaOrBase: string | number): {
+  encode: (source: BinInput, padToLength?: number) => string;
+  decode: (source: string, padToLength?: number) => Uint8Array;
+};
+declare function encodeBase32(bin: BinInput, padding?: number): string;
+declare function decodeBase32(s: string, padding?: number): Uint8Array<ArrayBufferLike>;
+declare function encodeBase16(bin: BinInput, padding?: number): string;
+declare function decodeBase16(s: string, padding?: number): Uint8Array<ArrayBufferLike>;
+declare function encodeBase58(bin: BinInput, padding?: number): string;
+declare function decodeBase58(s: string, padding?: number): Uint8Array<ArrayBufferLike>;
+declare function encodeBase62(bin: BinInput, padding?: number): string;
+declare function decodeBase62(s: string, padding?: number): Uint8Array<ArrayBufferLike>;
+declare function estimateSizeForBase(bytes: number, base: number): number;
+//#endregion
+export { decodeBase32 as a, encodeBase16 as c, encodeBase62 as d, estimateSizeForBase as f, decodeBase16 as i, encodeBase32 as l, BaseXEncodeFunction as n, decodeBase58 as o, useBase as p, _useBase as r, decodeBase62 as s, BaseXDecodeFunction as t, encodeBase58 as u };
+//# sourceMappingURL=basex-D8lNbS7O.d.mts.map

package/dist/basex-csOMK5K7.d.cts

@@ -0,0 +1,25 @@
+import { t as BinInput } from "./bin-types-DD2CqRPc.cjs";
+
+//#region src/common/data/basex.d.ts
+type BaseXEncodeFunction = (source: BinInput, padToLength?: number) => string;
+type BaseXDecodeFunction = (source: string, padToLength?: number) => Uint8Array;
+declare function _useBase(alphaOrBase: string | number): {
+  encode: BaseXEncodeFunction;
+  decode: BaseXDecodeFunction;
+};
+declare function useBase(alphaOrBase: string | number): {
+  encode: (source: BinInput, padToLength?: number) => string;
+  decode: (source: string, padToLength?: number) => Uint8Array;
+};
+declare function encodeBase32(bin: BinInput, padding?: number): string;
+declare function decodeBase32(s: string, padding?: number): Uint8Array<ArrayBufferLike>;
+declare function encodeBase16(bin: BinInput, padding?: number): string;
+declare function decodeBase16(s: string, padding?: number): Uint8Array<ArrayBufferLike>;
+declare function encodeBase58(bin: BinInput, padding?: number): string;
+declare function decodeBase58(s: string, padding?: number): Uint8Array<ArrayBufferLike>;
+declare function encodeBase62(bin: BinInput, padding?: number): string;
+declare function decodeBase62(s: string, padding?: number): Uint8Array<ArrayBufferLike>;
+declare function estimateSizeForBase(bytes: number, base: number): number;
+//#endregion
+export { decodeBase32 as a, encodeBase16 as c, encodeBase62 as d, estimateSizeForBase as f, decodeBase16 as i, encodeBase32 as l, BaseXEncodeFunction as n, decodeBase58 as o, useBase as p, _useBase as r, decodeBase62 as s, BaseXDecodeFunction as t, encodeBase58 as u };
+//# sourceMappingURL=basex-csOMK5K7.d.cts.map

package/dist/basex-secure-Cn6hLMwc.d.mts

@@ -0,0 +1,132 @@
+//#region src/common/data/basex-secure.d.ts
+/**
+ * @__NO_SIDE_EFFECTS__
+ */
+declare function assertNumber(n: number): void;
+interface Coder<F, T> {
+  encode(from: F): T;
+  decode(to: T): F;
+}
+interface BytesCoder extends Coder<Uint8Array, string> {
+  encode: (data: Uint8Array) => string;
+  decode: (str: string) => Uint8Array;
+}
+type BaseXChain = [Coder<any, any>, ...Coder<any, any>[]];
+type BaseXInput<F> = F extends Coder<infer T, any> ? T : never;
+type BaseXOutput<F> = F extends Coder<any, infer T> ? T : never;
+type BaseXFirst<T> = T extends [infer U, ...any[]] ? U : never;
+type BaseXLast<T> = T extends [...any[], infer U] ? U : never;
+type BaseXTail<T> = T extends [any, ...infer U] ? U : never;
+type BaseXAsChain<C extends BaseXChain, Rest = BaseXTail<C>> = { [K in keyof C]: Coder<BaseXInput<C[K]>, BaseXInput<K extends keyof Rest ? Rest[K] : any>> };
+/**
+ * @__NO_SIDE_EFFECTS__
+ */
+declare function chain<T extends BaseXChain & BaseXAsChain<T>>(...args: T): Coder<BaseXInput<BaseXFirst<T>>, BaseXOutput<BaseXLast<T>>>;
+type BaseXAlphabet = string[] | string;
+/**
+ * Encodes integer radix representation to array of strings using alphabet and back
+ * @__NO_SIDE_EFFECTS__
+ */
+declare function alphabet(alphabet: BaseXAlphabet): Coder<number[], string[]>;
+/**
+ * @__NO_SIDE_EFFECTS__
+ */
+declare function join(separator?: string): Coder<string[], string>;
+/**
+ * Pad strings array so it has integer number of bits
+ * @__NO_SIDE_EFFECTS__
+ */
+declare function padding(bits: number, chr?: string): Coder<string[], string[]>;
+/**
+ * Slow: O(n^2) time complexity
+ * @__NO_SIDE_EFFECTS__
+ */
+declare function convertRadix(data: number[], from: number, to: number): number[];
+/**
+ * Implemented with numbers, because BigInt is 5x slower
+ * @__NO_SIDE_EFFECTS__
+ */
+declare function convertRadix2(data: number[], from: number, to: number, padding: boolean): number[];
+/**
+ * @__NO_SIDE_EFFECTS__
+ */
+declare function radix(num: number): Coder<Uint8Array, number[]>;
+/**
+ * If both bases are power of same number (like `2**8 <-> 2**64`),
+ * there is a linear algorithm. For now we have implementation for power-of-two bases only.
+ * @__NO_SIDE_EFFECTS__
+ */
+declare function radix2(bits: number, revPadding?: boolean): Coder<Uint8Array, number[]>;
+/**
+ * @__NO_SIDE_EFFECTS__
+ */
+declare function checksum(len: number, fn: (data: Uint8Array) => Uint8Array): Coder<Uint8Array, Uint8Array>;
+declare const utils: {
+  alphabet: typeof alphabet;
+  chain: typeof chain;
+  checksum: typeof checksum;
+  convertRadix: typeof convertRadix;
+  convertRadix2: typeof convertRadix2;
+  radix: typeof radix;
+  radix2: typeof radix2;
+  join: typeof join;
+  padding: typeof padding;
+};
+declare const base16: BytesCoder;
+declare const base32: BytesCoder;
+declare const base32nopad: BytesCoder;
+declare const base32hex: BytesCoder;
+declare const base32hexnopad: BytesCoder;
+declare const base32agnoster: BytesCoder;
+declare const base32crockford: BytesCoder;
+declare const base64: BytesCoder;
+declare const base64nopad: BytesCoder;
+declare const base64url: BytesCoder;
+declare const base64urlnopad: BytesCoder;
+declare const base58: BytesCoder;
+declare const base58flickr: BytesCoder;
+declare const base58xrp: BytesCoder;
+declare const base58xmr: BytesCoder;
+declare const createBase58check: (sha256: (data: Uint8Array) => Uint8Array) => BytesCoder;
+declare const base58check: (sha256: (data: Uint8Array) => Uint8Array) => BytesCoder;
+interface Bech32Decoded<Prefix extends string = string> {
+  prefix: Prefix;
+  words: number[];
+}
+interface Bech32DecodedWithArray<Prefix extends string = string> {
+  prefix: Prefix;
+  words: number[];
+  bytes: Uint8Array;
+}
+interface Bech32 {
+  encode<Prefix extends string>(prefix: Prefix, words: number[] | Uint8Array, limit?: number | false): `${Lowercase<Prefix>}1${string}`;
+  decode<Prefix extends string>(str: `${Prefix}1${string}`, limit?: number | false): Bech32Decoded<Prefix>;
+  encodeFromBytes(prefix: string, bytes: Uint8Array): string;
+  decodeToBytes(str: string): Bech32DecodedWithArray;
+  decodeUnsafe(str: string, limit?: number | false): void | Bech32Decoded<string>;
+  fromWords(to: number[]): Uint8Array;
+  fromWordsUnsafe(to: number[]): void | Uint8Array;
+  toWords(from: Uint8Array): number[];
+}
+declare const bech32: Bech32;
+declare const bech32m: Bech32;
+declare const utf8: BytesCoder;
+declare const hex: BytesCoder;
+declare const CODERS: {
+  utf8: BytesCoder;
+  hex: BytesCoder;
+  base16: BytesCoder;
+  base32: BytesCoder;
+  base64: BytesCoder;
+  base64url: BytesCoder;
+  base58: BytesCoder;
+  base58xmr: BytesCoder;
+};
+type CoderType = keyof typeof CODERS;
+declare const bytesToString: (type: CoderType, bytes: Uint8Array) => string;
+declare const str: (type: CoderType, bytes: Uint8Array) => string;
+declare const stringToBytes: (type: CoderType, str: string) => Uint8Array;
+declare const bytes: (type: CoderType, str: string) => Uint8Array;
+//#endregion
+export { base64urlnopad as A, utils as B, base58check as C, base64 as D, base58xrp as E, createBase58check as F, hex as I, str as L, bech32m as M, bytes as N, base64nopad as O, bytesToString as P, stringToBytes as R, base58 as S, base58xmr as T, base32agnoster as _, BaseXInput as a, base32hexnopad as b, BaseXTail as c, Bech32DecodedWithArray as d, BytesCoder as f, base32 as g, base16 as h, BaseXFirst as i, bech32 as j, base64url as k, Bech32 as l, assertNumber as m, BaseXAsChain as n, BaseXLast as o, Coder as p, BaseXChain as r, BaseXOutput as s, BaseXAlphabet as t, Bech32Decoded as u, base32crockford as v, base58flickr as w, base32nopad as x, base32hex as y, utf8 as z };
+//# sourceMappingURL=basex-secure-Cn6hLMwc.d.mts.map

package/dist/basex-secure-Det7yzQU.d.cts

@@ -0,0 +1,132 @@
+//#region src/common/data/basex-secure.d.ts
+/**
+ * @__NO_SIDE_EFFECTS__
+ */
+declare function assertNumber(n: number): void;
+interface Coder<F, T> {
+  encode(from: F): T;
+  decode(to: T): F;
+}
+interface BytesCoder extends Coder<Uint8Array, string> {
+  encode: (data: Uint8Array) => string;
+  decode: (str: string) => Uint8Array;
+}
+type BaseXChain = [Coder<any, any>, ...Coder<any, any>[]];
+type BaseXInput<F> = F extends Coder<infer T, any> ? T : never;
+type BaseXOutput<F> = F extends Coder<any, infer T> ? T : never;
+type BaseXFirst<T> = T extends [infer U, ...any[]] ? U : never;
+type BaseXLast<T> = T extends [...any[], infer U] ? U : never;
+type BaseXTail<T> = T extends [any, ...infer U] ? U : never;
+type BaseXAsChain<C extends BaseXChain, Rest = BaseXTail<C>> = { [K in keyof C]: Coder<BaseXInput<C[K]>, BaseXInput<K extends keyof Rest ? Rest[K] : any>> };
+/**
+ * @__NO_SIDE_EFFECTS__
+ */
+declare function chain<T extends BaseXChain & BaseXAsChain<T>>(...args: T): Coder<BaseXInput<BaseXFirst<T>>, BaseXOutput<BaseXLast<T>>>;
+type BaseXAlphabet = string[] | string;
+/**
+ * Encodes integer radix representation to array of strings using alphabet and back
+ * @__NO_SIDE_EFFECTS__
+ */
+declare function alphabet(alphabet: BaseXAlphabet): Coder<number[], string[]>;
+/**
+ * @__NO_SIDE_EFFECTS__
+ */
+declare function join(separator?: string): Coder<string[], string>;
+/**
+ * Pad strings array so it has integer number of bits
+ * @__NO_SIDE_EFFECTS__
+ */
+declare function padding(bits: number, chr?: string): Coder<string[], string[]>;
+/**
+ * Slow: O(n^2) time complexity
+ * @__NO_SIDE_EFFECTS__
+ */
+declare function convertRadix(data: number[], from: number, to: number): number[];
+/**
+ * Implemented with numbers, because BigInt is 5x slower
+ * @__NO_SIDE_EFFECTS__
+ */
+declare function convertRadix2(data: number[], from: number, to: number, padding: boolean): number[];
+/**
+ * @__NO_SIDE_EFFECTS__
+ */
+declare function radix(num: number): Coder<Uint8Array, number[]>;
+/**
+ * If both bases are power of same number (like `2**8 <-> 2**64`),
+ * there is a linear algorithm. For now we have implementation for power-of-two bases only.
+ * @__NO_SIDE_EFFECTS__
+ */
+declare function radix2(bits: number, revPadding?: boolean): Coder<Uint8Array, number[]>;
+/**
+ * @__NO_SIDE_EFFECTS__
+ */
+declare function checksum(len: number, fn: (data: Uint8Array) => Uint8Array): Coder<Uint8Array, Uint8Array>;
+declare const utils: {
+  alphabet: typeof alphabet;
+  chain: typeof chain;
+  checksum: typeof checksum;
+  convertRadix: typeof convertRadix;
+  convertRadix2: typeof convertRadix2;
+  radix: typeof radix;
+  radix2: typeof radix2;
+  join: typeof join;
+  padding: typeof padding;
+};
+declare const base16: BytesCoder;
+declare const base32: BytesCoder;
+declare const base32nopad: BytesCoder;
+declare const base32hex: BytesCoder;
+declare const base32hexnopad: BytesCoder;
+declare const base32agnoster: BytesCoder;
+declare const base32crockford: BytesCoder;
+declare const base64: BytesCoder;
+declare const base64nopad: BytesCoder;
+declare const base64url: BytesCoder;
+declare const base64urlnopad: BytesCoder;
+declare const base58: BytesCoder;
+declare const base58flickr: BytesCoder;
+declare const base58xrp: BytesCoder;
+declare const base58xmr: BytesCoder;
+declare const createBase58check: (sha256: (data: Uint8Array) => Uint8Array) => BytesCoder;
+declare const base58check: (sha256: (data: Uint8Array) => Uint8Array) => BytesCoder;
+interface Bech32Decoded<Prefix extends string = string> {
+  prefix: Prefix;
+  words: number[];
+}
+interface Bech32DecodedWithArray<Prefix extends string = string> {
+  prefix: Prefix;
+  words: number[];
+  bytes: Uint8Array;
+}
+interface Bech32 {
+  encode<Prefix extends string>(prefix: Prefix, words: number[] | Uint8Array, limit?: number | false): `${Lowercase<Prefix>}1${string}`;
+  decode<Prefix extends string>(str: `${Prefix}1${string}`, limit?: number | false): Bech32Decoded<Prefix>;
+  encodeFromBytes(prefix: string, bytes: Uint8Array): string;
+  decodeToBytes(str: string): Bech32DecodedWithArray;
+  decodeUnsafe(str: string, limit?: number | false): void | Bech32Decoded<string>;
+  fromWords(to: number[]): Uint8Array;
+  fromWordsUnsafe(to: number[]): void | Uint8Array;
+  toWords(from: Uint8Array): number[];
+}
+declare const bech32: Bech32;
+declare const bech32m: Bech32;
+declare const utf8: BytesCoder;
+declare const hex: BytesCoder;
+declare const CODERS: {
+  utf8: BytesCoder;
+  hex: BytesCoder;
+  base16: BytesCoder;
+  base32: BytesCoder;
+  base64: BytesCoder;
+  base64url: BytesCoder;
+  base58: BytesCoder;
+  base58xmr: BytesCoder;
+};
+type CoderType = keyof typeof CODERS;
+declare const bytesToString: (type: CoderType, bytes: Uint8Array) => string;
+declare const str: (type: CoderType, bytes: Uint8Array) => string;
+declare const stringToBytes: (type: CoderType, str: string) => Uint8Array;
+declare const bytes: (type: CoderType, str: string) => Uint8Array;
+//#endregion
+export { base64urlnopad as A, utils as B, base58check as C, base64 as D, base58xrp as E, createBase58check as F, hex as I, str as L, bech32m as M, bytes as N, base64nopad as O, bytesToString as P, stringToBytes as R, base58 as S, base58xmr as T, base32agnoster as _, BaseXInput as a, base32hexnopad as b, BaseXTail as c, Bech32DecodedWithArray as d, BytesCoder as f, base32 as g, base16 as h, BaseXFirst as i, bech32 as j, base64url as k, Bech32 as l, assertNumber as m, BaseXAsChain as n, BaseXLast as o, Coder as p, BaseXChain as r, BaseXOutput as s, BaseXAlphabet as t, Bech32Decoded as u, base32crockford as v, base58flickr as w, base32nopad as x, base32hex as y, utf8 as z };
+//# sourceMappingURL=basex-secure-Det7yzQU.d.cts.map

package/dist/bin-CEF44EVH.d.mts

@@ -0,0 +1,33 @@
+import { t as BinInput } from "./bin-types-CKGKqfwj.mjs";
+
+//#region src/common/data/bin.d.ts
+declare function _encodeUtf8Polyfill(str: string): Uint8Array;
+declare function _decodeUtf8Polyfill(buf: Uint8Array<ArrayBufferLike>): string;
+declare function stringToUInt8Array(text: string): Uint8Array;
+declare function Uint8ArrayToString(bin: Uint8Array): string;
+declare function toArrayBuffer(bin: BinInput): ArrayBuffer;
+declare function toUint8Array(data: BinInput): Uint8Array;
+/**
+ * Ensures a Uint8Array is backed by a real ArrayBuffer (not SharedArrayBuffer).
+ * This is needed for Web Crypto API compatibility which requires BufferSource with ArrayBuffer.
+ */
+declare function ensureUint8Array(data: Uint8Array): Uint8Array<ArrayBuffer>;
+declare function joinToUint8Array(...args: BinInput[] | BinInput[][]): Uint8Array<ArrayBuffer>;
+declare function toHex(bin: BinInput): string;
+declare function fromHex(hexString: string): Uint8Array;
+/** Regular base64 */
+declare function toBase64(bin: BinInput, stripPadding?: boolean): string;
+/** Converts `+` -> `-` and `/` -> `_`. Always strips `=` */
+declare function toBase64Url(bin: BinInput): string;
+/** Also parses toBase64Url encoded strings. */
+declare function fromBase64(s: string): Uint8Array;
+/** Also parses toBase64Url encoded strings. */
+declare function fromBase64String(s: string): string;
+/** Compare contents of binary arrays */
+declare function equalBinary(a: ArrayBuffer | Uint8Array, b: ArrayBuffer | Uint8Array): boolean;
+declare function jsonToUint8Array(json: any): Uint8Array | never;
+declare function Uint8ArrayToJson<T = any>(data: Uint8Array): T | never;
+declare function Uint8ArrayToHexDump(buffer: Uint8Array | ArrayBuffer | string | Array<number>, blockSize?: number): string | false;
+//#endregion
+export { toHex as _, _encodeUtf8Polyfill as a, fromBase64 as c, joinToUint8Array as d, jsonToUint8Array as f, toBase64Url as g, toBase64 as h, _decodeUtf8Polyfill as i, fromBase64String as l, toArrayBuffer as m, Uint8ArrayToJson as n, ensureUint8Array as o, stringToUInt8Array as p, Uint8ArrayToString as r, equalBinary as s, Uint8ArrayToHexDump as t, fromHex as u, toUint8Array as v };
+//# sourceMappingURL=bin-CEF44EVH.d.mts.map

package/dist/bin-Ce3i6ABn.cjs

@@ -0,0 +1,3 @@
+const e=require(`./common/data/json.cjs`);function t(e){if(!Number.isSafeInteger(e))throw Error(`Wrong integer: ${e}`)}function n(e){return e instanceof Uint8Array||typeof e==`object`&&!!e&&e.constructor.name===`Uint8Array`}function r(...e){let t=e=>e,n=(e,t)=>n=>e(t(n));return{encode:e.map(e=>e.encode).reduceRight(n,t),decode:e.map(e=>e.decode).reduce(n,t)}}function i(e){return{encode:n=>{if(!Array.isArray(n)||n.length&&typeof n[0]!=`number`)throw Error(`alphabet.encode input should be an array of numbers`);return n.map(n=>{if(t(n),n<0||n>=e.length)throw Error(`Digit index outside alphabet: ${n} (alphabet: ${e.length})`);return e[n]})},decode:t=>{if(!Array.isArray(t)||t.length&&typeof t[0]!=`string`)throw Error(`alphabet.decode input should be array of strings`);return t.map(t=>{if(typeof t!=`string`)throw Error(`alphabet.decode: not string element=${t}`);let n=e.indexOf(t);if(n===-1)throw Error(`Unknown letter: "${t}". Allowed: ${e}`);return n})}}}function a(e=``){if(typeof e!=`string`)throw Error(`join separator should be string`);return{encode:t=>{if(!Array.isArray(t)||t.length&&typeof t[0]!=`string`)throw Error(`join.encode input should be array of strings`);for(let e of t)if(typeof e!=`string`)throw Error(`join.encode: non-string input=${e}`);return t.join(e)},decode:t=>{if(typeof t!=`string`)throw Error(`join.decode input should be string`);return t.split(e)}}}function o(e,n=`=`){if(t(e),typeof n!=`string`)throw Error(`padding chr should be string`);return{encode(t){if(!Array.isArray(t)||t.length&&typeof t[0]!=`string`)throw Error(`padding.encode input should be array of strings`);for(let e of t)if(typeof e!=`string`)throw Error(`padding.encode: non-string input=${e}`);for(;t.length*e%8;)t.push(n);return t},decode(t){if(!Array.isArray(t)||t.length&&typeof t[0]!=`string`)throw Error(`padding.encode input should be array of strings`);for(let e of t)if(typeof e!=`string`)throw Error(`padding.decode: non-string input=${e}`);let r=t.length;if(r*e%8)throw Error(`Invalid padding: string should have whole number of bytes`);for(;r>0&&t[r-1]===n;r--)if(!((r-1)*e%8))throw Error(`Invalid padding: string has too much padding`);return t.slice(0,r)}}}function s(e){if(typeof e!=`function`)throw Error(`normalize fn should be function`);return{encode:e=>e,decode:t=>e(t)}}function c(e,n,r){if(n<2)throw Error(`convertRadix: wrong from=${n}, base cannot be less than 2`);if(r<2)throw Error(`convertRadix: wrong to=${r}, base cannot be less than 2`);if(!Array.isArray(e))throw Error(`convertRadix: data should be array`);if(!e.length)return[];let i=0,a=[],o=Array.from(e);for(o.forEach(e=>{if(t(e),e<0||e>=n)throw Error(`Wrong integer: ${e}`)});;){let e=0,t=!0;for(let a=i;a<o.length;a++){let s=o[a],c=n*e+s;if(!Number.isSafeInteger(c)||n*e/n!==e||c-s!==n*e)throw Error(`convertRadix: carry overflow`);e=c%r;let l=Math.floor(c/r);if(o[a]=l,!Number.isSafeInteger(l)||l*r+e!==c)throw Error(`convertRadix: carry overflow`);if(t)l?t=!1:i=a;else continue}if(a.push(e),t)break}for(let t=0;t<e.length-1&&e[t]===0;t++)a.push(0);return a.reverse()}const l=(e,t)=>t?l(t,e%t):e,u=(e,t)=>e+(t-l(e,t));function d(e,n,r,i){if(!Array.isArray(e))throw Error(`convertRadix2: data should be array`);if(n<=0||n>32)throw Error(`convertRadix2: wrong from=${n}`);if(r<=0||r>32)throw Error(`convertRadix2: wrong to=${r}`);if(u(n,r)>32)throw Error(`convertRadix2: carry overflow from=${n} to=${r} carryBits=${u(n,r)}`);let a=0,o=0,s=2**r-1,c=[];for(let i of e){if(t(i),i>=2**n)throw Error(`convertRadix2: invalid data word=${i} from=${n}`);if(a=a<<n|i,o+n>32)throw Error(`convertRadix2: carry overflow pos=${o} from=${n}`);for(o+=n;o>=r;o-=r)c.push((a>>o-r&s)>>>0);a&=2**o-1}if(a=a<<r-o&s,!i&&o>=n)throw Error(`Excess padding`);if(!i&&a)throw Error(`Non-zero padding: ${a}`);return i&&o>0&&c.push(a>>>0),c}function f(e){return t(e),{encode:t=>{if(!n(t))throw Error(`radix.encode input should be Uint8Array`);return c(Array.from(t),2**8,e)},decode:t=>{if(!Array.isArray(t)||t.length&&typeof t[0]!=`number`)throw Error(`radix.decode input should be array of numbers`);return Uint8Array.from(c(t,e,2**8))}}}function p(e,r=!1){if(t(e),e<=0||e>32)throw Error(`radix2: bits should be in (0..32]`);if(u(8,e)>32||u(e,8)>32)throw Error(`radix2: carry overflow`);return{encode:t=>{if(!n(t))throw Error(`radix2.encode input should be Uint8Array`);return d(Array.from(t),8,e,!r)},decode:t=>{if(!Array.isArray(t)||t.length&&typeof t[0]!=`number`)throw Error(`radix2.decode input should be array of numbers`);return Uint8Array.from(d(t,e,8,r))}}}function m(e){if(typeof e!=`function`)throw Error(`unsafeWrapper fn should be function`);return function(...t){try{return e.apply(null,t)}catch{}}}function h(e,r){if(t(e),typeof r!=`function`)throw Error(`checksum fn should be function`);return{encode(t){if(!n(t))throw Error(`checksum.encode: input should be Uint8Array`);let i=r(t).slice(0,e),a=new Uint8Array(t.length+e);return a.set(t),a.set(i,t.length),a},decode(t){if(!n(t))throw Error(`checksum.decode: input should be Uint8Array`);let i=t.slice(0,-e),a=r(i).slice(0,e),o=t.slice(-e);for(let t=0;t<e;t++)if(a[t]!==o[t])throw Error(`Invalid checksum`);return i}}}const g={alphabet:i,chain:r,checksum:h,convertRadix:c,convertRadix2:d,radix:f,radix2:p,join:a,padding:o},_=r(p(4),i(`0123456789ABCDEF`),a(``)),v=r(p(5),i(`ABCDEFGHIJKLMNOPQRSTUVWXYZ234567`),o(5),a(``)),ee=r(p(5),i(`ABCDEFGHIJKLMNOPQRSTUVWXYZ234567`),a(``)),y=r(p(5),i(`0123456789ABCDEFGHIJKLMNOPQRSTUV`),o(5),a(``)),te=r(p(5),i(`0123456789ABCDEFGHIJKLMNOPQRSTUV`),a(``)),ne=r(p(5),i(`0123456789abcdefghjkmnpqrtuvwxyz`),a(``)),re=r(p(5),i(`0123456789ABCDEFGHJKMNPQRSTVWXYZ`),a(``),s(e=>e.toUpperCase().replace(/O/g,`0`).replace(/[IL]/g,`1`))),b=r(p(6),i(`ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/`),o(6),a(``)),x=r(p(6),i(`ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/`),a(``)),S=r(p(6),i(`ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_`),o(6),a(``)),C=r(p(6),i(`ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_`),a(``)),w=e=>r(f(58),i(e),a(``)),T=w(`123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz`),ie=w(`123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ`),E=w(`rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz`),D=[0,2,3,5,6,7,9,10,11],O={encode(e){let t=``;for(let n=0;n<e.length;n+=8){let r=e.subarray(n,n+8);t+=T.encode(r).padStart(D[r.length],`1`)}return t},decode(e){let t=[];for(let n=0;n<e.length;n+=11){let r=e.slice(n,n+11),i=D.indexOf(r.length),a=T.decode(r);for(let e=0;e<a.length-i;e++)if(a[e]!==0)throw Error(`base58xmr: wrong padding`);t=t.concat(Array.from(a.slice(a.length-i)))}return Uint8Array.from(t)}},k=e=>r(h(4,t=>e(e(t))),T),ae=k,A=r(i(`qpzry9x8gf2tvdw0s3jn54khce6mua7l`),a(``)),j=[996825010,642813549,513874426,1027748829,705979059];function M(e){let t=e>>25,n=(e&33554431)<<5;for(let e=0;e<j.length;e++)(t>>e&1)==1&&(n^=j[e]);return n}function N(e,t,n=1){let r=e.length,i=1;for(let t=0;t<r;t++){let n=e.charCodeAt(t);if(n<33||n>126)throw Error(`Invalid prefix (${e})`);i=M(i)^n>>5}i=M(i);for(let t=0;t<r;t++)i=M(i)^e.charCodeAt(t)&31;for(let e of t)i=M(i)^e;for(let e=0;e<6;e++)i=M(i);return i^=n,A.encode(d([i%2**30],30,5,!1))}function P(e){let t=e===`bech32`?1:734539939,n=p(5),r=n.decode,i=n.encode,a=m(r);function o(e,n,r=90){if(typeof e!=`string`)throw Error(`bech32.encode prefix should be string, not ${typeof e}`);if(n instanceof Uint8Array&&(n=Array.from(n)),!Array.isArray(n)||n.length&&typeof n[0]!=`number`)throw Error(`bech32.encode words should be array of numbers, not ${typeof n}`);if(e.length===0)throw TypeError(`Invalid prefix length ${e.length}`);let i=e.length+7+n.length;if(r!==!1&&i>r)throw TypeError(`Length ${i} exceeds limit ${r}`);let a=e.toLowerCase(),o=N(a,n,t);return`${a}1${A.encode(n)}${o}`}function s(e,n=90){if(typeof e!=`string`)throw Error(`bech32.decode input should be string, not ${typeof e}`);if(e.length<8||n!==!1&&e.length>n)throw TypeError(`Wrong string length: ${e.length} (${e}). Expected (8..${n})`);let r=e.toLowerCase();if(e!==r&&e!==e.toUpperCase())throw Error(`String must be lowercase or uppercase`);let i=r.lastIndexOf(`1`);if(i===0||i===-1)throw Error(`Letter "1" must be present between prefix and data only`);let a=r.slice(0,i),o=r.slice(i+1);if(o.length<6)throw Error(`Data must be at least 6 characters long`);let s=A.decode(o).slice(0,-6),c=N(a,s,t);if(!o.endsWith(c))throw Error(`Invalid checksum in ${e}: expected "${c}"`);return{prefix:a,words:s}}let c=m(s);function l(e){let{prefix:t,words:n}=s(e,!1);return{prefix:t,words:n,bytes:r(n)}}function u(e,t){return o(e,i(t))}return{encode:o,decode:s,encodeFromBytes:u,decodeToBytes:l,decodeUnsafe:c,fromWords:r,fromWordsUnsafe:a,toWords:i}}const F=P(`bech32`),I=P(`bech32m`),L={encode:e=>X(e),decode:e=>J(e)},R=r(p(4),i(`0123456789abcdef`),a(``),s(e=>{if(typeof e!=`string`||e.length%2)throw TypeError(`hex.decode: expected string, got ${typeof e} with length ${e.length}`);return e.toLowerCase()})),z={utf8:L,hex:R,base16:_,base32:v,base64:b,base64url:S,base58:T,base58xmr:O},B=`Invalid encoding type. Available types: utf8, hex, base16, base32, base64, base64url, base58, base58xmr`,V=(e,t)=>{if(typeof e!=`string`||!z.hasOwnProperty(e))throw TypeError(B);if(!n(t))throw TypeError(`bytesToString() expects Uint8Array`);return z[e].encode(t)},H=V,U=(e,t)=>{if(!z.hasOwnProperty(e))throw TypeError(B);if(typeof t!=`string`)throw TypeError(`stringToBytes() expects string`);return z[e].decode(t)},W=U;function G(e){let t=unescape(encodeURIComponent(e)),n=t.length,r=new Uint8Array(n);for(let e=0;e<n;e++)r[e]=t.codePointAt(e)||0;return r}function K(e){let t=e.length,n=``,r=0;for(;t>0;){let i=t<1e4?t:1e4,a=e.subarray(r,r+i);r+=i,n+=String.fromCodePoint.apply(null,a),t-=i}return decodeURIComponent(escape(n))}let q;function J(e){if(q==null&&(q=G,typeof TextEncoder<`u`)){let e=new TextEncoder;q=t=>e.encode(t)}return q(e.normalize(`NFC`))}let Y;function X(e){if(Y==null&&(Y=K,typeof TextDecoder<`u`)){let e=new TextDecoder(`utf-8`,{ignoreBOM:!0});Y=t=>e.decode(t)}return Y(e).normalize(`NFC`)}function oe(e){let t=Z(e);return t.buffer.byteLength===t.byteLength?t.buffer:t.buffer.slice(t.byteOffset,t.byteOffset+t.byteLength)}function Z(e){return e instanceof ArrayBuffer?new Uint8Array(e):typeof e==`string`?J(e):e.length?new Uint8Array(e):e}function se(e){return e.buffer instanceof ArrayBuffer?e:new Uint8Array(e)}function Q(...e){let t=0,n=e.flat(1).map(e=>{let n=Z(e);return t+=n.length,n}),r=new Uint8Array(t),i=0;for(let e of n)r.set(e,i),i+=e.length;return r}function ce(e){if(typeof Buffer<`u`)return Buffer.from(Z(e)).toString(`hex`);let t=`0123456789abcdef`,n=``;for(let r of[...Z(e)])n+=t[r>>4]+t[r&15];return n}function le(e){return Uint8Array.from(e.match(/.{1,2}/g).map(e=>Number.parseInt(e,16)))}function ue(e,t=!1){let n=Z(e),r=``;return typeof Buffer<`u`?(r=Buffer.from(n).toString(`base64`),t?r.replace(/\=/g,``):r):t?x.encode(n):b.encode(n)}function de(e){let t=Z(e);return typeof Buffer<`u`?Buffer.from(t).toString(`base64url`).replace(/\=/g,``):C.encode(t)}function $(e){if(e=e.replace(/\-/g,`+`).replace(/\_/g,`/`),typeof Buffer<`u`){let t=Buffer.from(e,`base64`);return new Uint8Array(t.buffer,t.byteOffset,t.byteLength)}if(typeof atob<`u`){let t=atob(e),n=new Uint8Array(t.length);for(let e=0;e<t.length;e++)n[e]=t.charCodeAt(e);return n}return b.decode(e)}function fe(e){return X($(e))}function pe(e,t){if(e.byteLength!==t.byteLength)return!1;let n=Z(e),r=Z(t);for(let e=0;e<n.length;e++)if(n[e]!==r[e])return!1;return!0}function me(t){return J(e.jsonStringifySafe(t))}function he(e){return JSON.parse(X(e))}function ge(e,t){if(typeof e!=`string`)if(e instanceof ArrayBuffer&&e.byteLength!==void 0)e=String.fromCharCode.apply(String,[].slice.call(new Uint8Array(e)));else if(Array.isArray(e))e=String.fromCharCode.apply(String,e);else if(e.constructor===Uint8Array)e=String.fromCharCode.apply(String,[].slice.call(e));else return!1;t||=16;let n=[],r=`0123456789abcdef`;for(let i=0;i<e.length;i+=t){let a=e.slice(i,Math.min(i+t,e.length)),o=`0000${i.toString(16)}`.slice(-4),s=a.split(``).map(e=>{let t=e.charCodeAt(0);return` ${r[(240&t)>>4]}${r[15&t]}`}).join(``);s+=`   `.repeat(t-a.length);let c=a.replace(/[\x00-\x1F\x20\x7F-\xA0\xAD]/g,`.`);c+=` `.repeat(t-a.length),n.push(`${o} ${s}  ${c}`)}return n.join(`
+`)}Object.defineProperty(exports,`A`,{enumerable:!0,get:function(){return O}}),Object.defineProperty(exports,`B`,{enumerable:!0,get:function(){return k}}),Object.defineProperty(exports,`C`,{enumerable:!0,get:function(){return re}}),Object.defineProperty(exports,`D`,{enumerable:!0,get:function(){return T}}),Object.defineProperty(exports,`E`,{enumerable:!0,get:function(){return ee}}),Object.defineProperty(exports,`F`,{enumerable:!0,get:function(){return C}}),Object.defineProperty(exports,`G`,{enumerable:!0,get:function(){return g}}),Object.defineProperty(exports,`H`,{enumerable:!0,get:function(){return H}}),Object.defineProperty(exports,`I`,{enumerable:!0,get:function(){return F}}),Object.defineProperty(exports,`L`,{enumerable:!0,get:function(){return I}}),Object.defineProperty(exports,`M`,{enumerable:!0,get:function(){return b}}),Object.defineProperty(exports,`N`,{enumerable:!0,get:function(){return x}}),Object.defineProperty(exports,`O`,{enumerable:!0,get:function(){return ae}}),Object.defineProperty(exports,`P`,{enumerable:!0,get:function(){return S}}),Object.defineProperty(exports,`R`,{enumerable:!0,get:function(){return W}}),Object.defineProperty(exports,`S`,{enumerable:!0,get:function(){return ne}}),Object.defineProperty(exports,`T`,{enumerable:!0,get:function(){return te}}),Object.defineProperty(exports,`U`,{enumerable:!0,get:function(){return U}}),Object.defineProperty(exports,`V`,{enumerable:!0,get:function(){return R}}),Object.defineProperty(exports,`W`,{enumerable:!0,get:function(){return L}}),Object.defineProperty(exports,`_`,{enumerable:!0,get:function(){return ce}}),Object.defineProperty(exports,`a`,{enumerable:!0,get:function(){return G}}),Object.defineProperty(exports,`b`,{enumerable:!0,get:function(){return _}}),Object.defineProperty(exports,`c`,{enumerable:!0,get:function(){return $}}),Object.defineProperty(exports,`d`,{enumerable:!0,get:function(){return Q}}),Object.defineProperty(exports,`f`,{enumerable:!0,get:function(){return me}}),Object.defineProperty(exports,`g`,{enumerable:!0,get:function(){return de}}),Object.defineProperty(exports,`h`,{enumerable:!0,get:function(){return ue}}),Object.defineProperty(exports,`i`,{enumerable:!0,get:function(){return K}}),Object.defineProperty(exports,`j`,{enumerable:!0,get:function(){return E}}),Object.defineProperty(exports,`k`,{enumerable:!0,get:function(){return ie}}),Object.defineProperty(exports,`l`,{enumerable:!0,get:function(){return fe}}),Object.defineProperty(exports,`m`,{enumerable:!0,get:function(){return oe}}),Object.defineProperty(exports,`n`,{enumerable:!0,get:function(){return he}}),Object.defineProperty(exports,`o`,{enumerable:!0,get:function(){return se}}),Object.defineProperty(exports,`p`,{enumerable:!0,get:function(){return J}}),Object.defineProperty(exports,`r`,{enumerable:!0,get:function(){return X}}),Object.defineProperty(exports,`s`,{enumerable:!0,get:function(){return pe}}),Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return ge}}),Object.defineProperty(exports,`u`,{enumerable:!0,get:function(){return le}}),Object.defineProperty(exports,`v`,{enumerable:!0,get:function(){return Z}}),Object.defineProperty(exports,`w`,{enumerable:!0,get:function(){return y}}),Object.defineProperty(exports,`x`,{enumerable:!0,get:function(){return v}}),Object.defineProperty(exports,`y`,{enumerable:!0,get:function(){return t}}),Object.defineProperty(exports,`z`,{enumerable:!0,get:function(){return V}});
+//# sourceMappingURL=bin-Ce3i6ABn.cjs.map