@pezkuwi/types-codec 16.5.8 → 16.5.9

package/build/types/interfaces.d.ts

@@ -1,74 +0,0 @@
-import type { BN } from '@pezkuwi/util';
-import type { ArgsDef, Codec } from './codec.js';
-import type { AnyTuple } from './helpers.js';
-export interface ICompact<T extends INumber = INumber> extends Codec {
-    toBigInt(): bigint;
-    toBn(): BN;
-    toNumber(): number;
-    unwrap(): T;
-}
-export interface IEnum extends Codec {
-    readonly defIndexes: number[];
-    readonly defKeys: string[];
-    readonly index: number;
-    readonly isBasic: boolean;
-    readonly type: string;
-    readonly value: Codec;
-    toNumber(): number;
-}
-export interface IMap<K extends Codec = Codec, V extends Codec = Codec> extends Map<K, V>, Codec {
-}
-export interface INumber extends Codec {
-    bitLength(): number;
-    toBigInt(): bigint;
-    toBn(): BN;
-    toNumber(): number;
-    toPrimitive(disableAscii?: boolean): string | number;
-}
-export interface IFloat extends Codec {
-    toNumber(): number;
-}
-export interface IOption<T extends Codec = Codec> extends Codec {
-    readonly isNone: boolean;
-    readonly isSome: boolean;
-    readonly value: Codec;
-    unwrap(): T;
-    unwrapOr<O>(other: O): T | O;
-    unwrapOrDefault(): T;
-}
-export interface IResult<O extends Codec = Codec, E extends Codec = Codec> extends IEnum {
-    readonly asErr: E;
-    readonly asOk: O;
-    readonly isErr: boolean;
-    readonly isOk: boolean;
-}
-export interface ISet<K = string> extends Set<K>, Codec {
-    readonly strings: string[];
-}
-export interface IStruct<K = string, V extends Codec = Codec> extends Map<K, V>, Codec {
-    readonly defKeys: string[];
-    getAtIndex(index: number): Codec;
-    toArray(): Codec[];
-}
-export interface IText extends String, Codec {
-}
-export type ITuple<T extends AnyTuple = Codec[]> = T & Codec;
-export interface IU8a extends Uint8Array, Codec {
-    readonly isAscii: boolean;
-    readonly isUtf8: boolean;
-    bitLength(): number;
-    toHuman(isExtended?: boolean, disableAscii?: boolean): any;
-    toJSON(): any;
-    toUtf8(): string;
-}
-export interface IVec<T extends Codec = Codec> extends Array<T>, Codec {
-    toArray(): T[];
-}
-export interface IMethod<A extends AnyTuple = AnyTuple, M = any> extends Codec {
-    readonly args: A;
-    readonly argsDef: ArgsDef;
-    readonly callIndex: Uint8Array;
-    readonly data: Uint8Array;
-    readonly meta: M;
-    is: (tx: IMethod<AnyTuple>) => tx is IMethod<A>;
-}

package/build/types/interfaces.js

@@ -1 +0,0 @@
-export {};

package/build/types/registry.d.ts

@@ -1,67 +0,0 @@
-import type { BN } from '@pezkuwi/util';
-import type { Codec, CodecClass } from './codec.js';
-import type { AnyTuple, LookupString } from './helpers.js';
-import type { ICompact, IEnum, IMap, IMethod, INumber, IOption, IResult, ISet, IStruct, ITuple, IU8a, IVec } from './interfaces.js';
-export type OnlyCodec<K, T, Types> = K extends keyof Types ? Types[K] : T extends ICompact | IEnum | IMap | IMethod | INumber | IOption | IResult | ISet | IStruct | ITuple | IU8a | IVec ? T : T extends Codec ? T : never;
-export interface RegistryError {
-    args: string[];
-    docs: string[];
-    index: number;
-    method: string;
-    name: string;
-    section: string;
-}
-export type RegistryTypes = Record<string, CodecClass | string | Record<string, string> | {
-    _enum: string[] | Record<string, number> | Record<string, string | null>;
-} | {
-    _set: Record<string, number>;
-}>;
-export interface CodecCreateOptions {
-    blockHash?: Uint8Array | string | null | undefined;
-    isFallback?: boolean;
-    isOptional?: boolean;
-    isPedantic?: boolean;
-}
-export interface CallBase<A extends AnyTuple, M = any> extends IMethod<A, M> {
-    readonly method: string;
-    readonly section: string;
-    toJSON: () => any;
-}
-export interface CallFunction<A extends AnyTuple = AnyTuple, M = any> extends CallBase<A, M> {
-    (...args: any[]): IMethod<A, M>;
-}
-export interface Registry {
-    readonly chainDecimals: number[];
-    readonly chainIsEthereum: boolean;
-    readonly chainSS58: number | undefined;
-    readonly chainTokens: string[];
-    createdAtHash?: IU8a;
-    findMetaCall(callIndex: Uint8Array): CallFunction;
-    findMetaError(errorIndex: Uint8Array | {
-        error: BN;
-        index: BN;
-    } | {
-        error: BN | Uint8Array;
-        index: BN;
-    }): RegistryError;
-    findMetaEvent(eventIndex: Uint8Array): CodecClass<any>;
-    isLookupType(value: string): value is LookupString;
-    createLookupType(lookupId: ICompact<INumber> | number): LookupString;
-    createClassUnsafe<T extends Codec = Codec, K extends string = string>(type: K): CodecClass<T>;
-    createTypeUnsafe<T extends Codec = Codec, K extends string = string>(type: K, params: unknown[], options?: CodecCreateOptions): T;
-    get(...params: never[]): any;
-    getClassName(clazz: CodecClass): string | undefined;
-    getOrThrow<T extends Codec = Codec, K extends string = string>(name: K, msg?: string): CodecClass<T>;
-    getOrUnknown<T extends Codec = Codec, K extends string = string>(name: K): CodecClass<T>;
-    getTransactionExtensionVersion(): number;
-    getSignedExtensionExtra(): Record<string, string>;
-    getSignedExtensionTypes(): Record<string, string>;
-    hasClass(name: string): boolean;
-    hasDef(name: string): boolean;
-    hasType(name: string): boolean;
-    hash(data: Uint8Array): IU8a;
-    register(type: CodecClass | RegistryTypes): void;
-    register(name: string, type: CodecClass): void;
-    register(arg1: string | CodecClass | RegistryTypes, arg2?: CodecClass): void;
-    setMetadata(metadata: unknown, signedExtensions?: string[], userExtensions?: unknown, noInitWarn?: boolean): void;
-}

package/build/types/registry.js

@@ -1 +0,0 @@
-export {};

package/build/utils/compareArray.d.ts

@@ -1 +0,0 @@
-export declare function compareArray(a: unknown[], b?: unknown): boolean;

package/build/utils/compareArray.js

@@ -1,10 +0,0 @@
-import { isUndefined } from '@pezkuwi/util';
-import { hasEq } from './util.js';
-export function compareArray(a, b) {
-    if (Array.isArray(b)) {
-        return (a.length === b.length) && isUndefined(a.find((v, index) => hasEq(v)
-            ? !v.eq(b[index])
-            : v !== b[index]));
-    }
-    return false;
-}

package/build/utils/compareMap.d.ts

@@ -1 +0,0 @@
-export declare function compareMap(a: Map<unknown, unknown>, b?: unknown): boolean;

package/build/utils/compareMap.js

@@ -1,27 +0,0 @@
-import { isObject, isUndefined } from '@pezkuwi/util';
-import { hasEq } from './util.js';
-function hasMismatch(a, b) {
-    return isUndefined(a) || (hasEq(a)
-        ? !a.eq(b)
-        : a !== b);
-}
-function notEntry(value) {
-    return !Array.isArray(value) || value.length !== 2;
-}
-function compareMapArray(a, b) {
-    // equal number of entries and each entry in the array should match
-    return (a.size === b.length) && !b.some((e) => notEntry(e) ||
-        hasMismatch(a.get(e[0]), e[1]));
-}
-export function compareMap(a, b) {
-    if (Array.isArray(b)) {
-        return compareMapArray(a, b);
-    }
-    else if (b instanceof Map) {
-        return compareMapArray(a, [...b.entries()]);
-    }
-    else if (isObject(b)) {
-        return compareMapArray(a, Object.entries(b));
-    }
-    return false;
-}

package/build/utils/compareSet.d.ts

@@ -1 +0,0 @@
-export declare function compareSet(a: Set<unknown>, b?: unknown): boolean;

package/build/utils/compareSet.js

@@ -1,17 +0,0 @@
-import { isObject } from '@pezkuwi/util';
-function compareSetArray(a, b) {
-    // equal number of entries and each entry in the array should match
-    return (a.size === b.length) && !b.some((e) => !a.has(e));
-}
-export function compareSet(a, b) {
-    if (Array.isArray(b)) {
-        return compareSetArray(a, b);
-    }
-    else if (b instanceof Set) {
-        return compareSetArray(a, [...b.values()]);
-    }
-    else if (isObject(b)) {
-        return compareSetArray(a, Object.values(b));
-    }
-    return false;
-}

package/build/utils/decodeU8a.d.ts

@@ -1,26 +0,0 @@
-import type { Codec, CodecClass, Registry } from '../types/index.js';
-/**
- * @internal
- *
- * Given an u8a, and an array of Type constructors, decode the u8a against the
- * types, and return an array of decoded values.
- *
- * @param u8a - The u8a to decode.
- * @param result - The result array (will be returned with values pushed)
- * @param types - The array of CodecClass to decode the U8a against.
- */
-export declare function decodeU8a<T extends Codec = Codec>(registry: Registry, result: T[], u8a: Uint8Array, [Types, keys]: [CodecClass<T>[], string[]]): [T[], number];
-/**
- * @internal
- *
- * Split from decodeU8a since this is specialized to zip returns ... while we duplicate, this
- * is all on the hot-path, so it is not great, however there is (some) method behind the madness
- */
-export declare function decodeU8aStruct(registry: Registry, result: [string, Codec][], u8a: Uint8Array, [Types, keys]: [CodecClass[], string[]]): [[string, Codec][], number];
-/**
- * @internal
- *
- * Split from decodeU8a since this is specialized to 1 instance ... while we duplicate, this
- * is all on the hot-path, so it is not great, however there is (some) method behind the madness
- */
-export declare function decodeU8aVec<T extends Codec = Codec>(registry: Registry, result: unknown[], u8a: Uint8Array, startAt: number, Type: CodecClass<T>): [number, number];

package/build/utils/decodeU8a.js

@@ -1,100 +0,0 @@
-import { u8aToHex } from '@pezkuwi/util';
-const MAX_DEPTH = 1024;
-/** @internal */
-function isComplexType(Type) {
-    const typeName = Type.name?.toLowerCase() || '';
-    return ['enum', 'hashmap', 'linkage', 'null', 'option', 'range', 'rangeinclusive', 'result', 'struct', 'tuple', 'vec', 'vecfixed'].includes(typeName);
-}
-/** @internal */
-function formatFailure(registry, fn, _result, { message }, u8a, i, count, Type, key) {
-    let type = '';
-    try {
-        type = `: ${new Type(registry).toRawType()}`;
-    }
-    catch {
-        // ignore
-    }
-    // This is extra debugging info (we most-probably want this in in some way, shape or form,
-    // but at this point not quite sure how to include and format it (it can be quite massive)
-    // console.error(JSON.stringify(result, null, 2));
-    return `${fn}: failed at ${u8aToHex(u8a.subarray(0, 16))}…${key ? ` on ${key}` : ''} (index ${i + 1}/${count})${type}:: ${message}`;
-}
-/**
- * @internal
- *
- * Given an u8a, and an array of Type constructors, decode the u8a against the
- * types, and return an array of decoded values.
- *
- * @param u8a - The u8a to decode.
- * @param result - The result array (will be returned with values pushed)
- * @param types - The array of CodecClass to decode the U8a against.
- */
-export function decodeU8a(registry, result, u8a, [Types, keys]) {
-    const count = result.length;
-    let offset = 0;
-    let i = 0;
-    try {
-        while (i < count) {
-            const value = new Types[i](registry, u8a.subarray(offset));
-            offset += value.initialU8aLength || value.encodedLength;
-            result[i] = value;
-            i++;
-        }
-    }
-    catch (error) {
-        throw new Error(formatFailure(registry, 'decodeU8a', result, error, u8a.subarray(offset), i, count, Types[i], keys[i]));
-    }
-    return [result, offset];
-}
-/**
- * @internal
- *
- * Split from decodeU8a since this is specialized to zip returns ... while we duplicate, this
- * is all on the hot-path, so it is not great, however there is (some) method behind the madness
- */
-export function decodeU8aStruct(registry, result, u8a, [Types, keys]) {
-    const count = result.length;
-    let offset = 0;
-    let i = 0;
-    if (count > MAX_DEPTH && isComplexType(Types[i])) {
-        throw new Error(`decodeU8aStruct: Maximum depth exceeded, received ${count} elements, limit ${MAX_DEPTH}`);
-    }
-    try {
-        while (i < count) {
-            const value = new Types[i](registry, u8a.subarray(offset));
-            offset += value.initialU8aLength || value.encodedLength;
-            result[i] = [keys[i], value];
-            i++;
-        }
-    }
-    catch (error) {
-        throw new Error(formatFailure(registry, 'decodeU8aStruct', result, error, u8a.subarray(offset), i, count, Types[i], keys[i]));
-    }
-    return [result, offset];
-}
-/**
- * @internal
- *
- * Split from decodeU8a since this is specialized to 1 instance ... while we duplicate, this
- * is all on the hot-path, so it is not great, however there is (some) method behind the madness
- */
-export function decodeU8aVec(registry, result, u8a, startAt, Type) {
-    const count = result.length;
-    if (count > MAX_DEPTH && isComplexType(Type)) {
-        throw new Error(`decodeU8aVec: Maximum depth exceeded, received ${count} elements, limit ${MAX_DEPTH}`);
-    }
-    let offset = startAt;
-    let i = 0;
-    try {
-        while (i < count) {
-            const value = new Type(registry, u8a.subarray(offset));
-            offset += value.initialU8aLength || value.encodedLength;
-            result[i] = value;
-            i++;
-        }
-    }
-    catch (error) {
-        throw new Error(formatFailure(registry, 'decodeU8aVec', result, error, u8a.subarray(offset), i, count, Type));
-    }
-    return [offset, offset - startAt];
-}

package/build/utils/index.d.ts

@@ -1,8 +0,0 @@
-export { compareArray } from './compareArray.js';
-export { compareMap } from './compareMap.js';
-export { compareSet } from './compareSet.js';
-export { decodeU8a, decodeU8aStruct, decodeU8aVec } from './decodeU8a.js';
-export { sanitize } from './sanitize.js';
-export { sortAsc, sortMap, sortSet } from './sortValues.js';
-export { mapToTypeMap, typesToConstructors, typeToConstructor } from './toConstructors.js';
-export { typesToMap } from './typesToMap.js';

package/build/utils/index.js

@@ -1,8 +0,0 @@
-export { compareArray } from './compareArray.js';
-export { compareMap } from './compareMap.js';
-export { compareSet } from './compareSet.js';
-export { decodeU8a, decodeU8aStruct, decodeU8aVec } from './decodeU8a.js';
-export { sanitize } from './sanitize.js';
-export { sortAsc, sortMap, sortSet } from './sortValues.js';
-export { mapToTypeMap, typesToConstructors, typeToConstructor } from './toConstructors.js';
-export { typesToMap } from './typesToMap.js';

package/build/utils/sanitize.d.ts

@@ -1,15 +0,0 @@
-import type { AnyString } from '../types/index.js';
-type Mapper = (value: string) => string;
-export declare function trim(): Mapper;
-export declare function findClosing(value: string, start: number): number;
-export declare function alias(src: string, dest: string, withChecks?: boolean): Mapper;
-export declare function cleanupCompact(): Mapper;
-export declare function flattenSingleTuple(): Mapper;
-export declare function removeExtensions(type: string, isSized: boolean): Mapper;
-export declare function removeColons(): Mapper;
-export declare function removeGenerics(): Mapper;
-export declare function removePairOf(): Mapper;
-export declare function removeTraits(): Mapper;
-export declare function removeWrap(check: string): Mapper;
-export declare function sanitize(value: AnyString): string;
-export {};

package/build/utils/sanitize.js

@@ -1,219 +0,0 @@
-const BOUNDED = ['BTreeMap', 'BTreeSet', 'HashMap', 'Vec'];
-const ALLOWED_BOXES = BOUNDED.concat(['Compact', 'DoNotConstruct', 'Int', 'Linkage', 'Range', 'RangeInclusive', 'Result', 'Opaque', 'Option', 'UInt', 'WrapperKeepOpaque', 'WrapperOpaque']);
-const BOX_PRECEDING = ['<', '(', '[', '"', ',', ' ']; // start of vec, tuple, fixed array, part of struct def or in tuple
-const mappings = [
-    // alias <T::InherentOfflineReport as InherentOfflineReport>::Inherent -> InherentOfflineReport
-    alias('<T::InherentOfflineReport as InherentOfflineReport>::Inherent', 'InherentOfflineReport', false),
-    alias('VecDeque<', 'Vec<', false),
-    // <T::Balance as HasCompact>
-    cleanupCompact(),
-    // Change BoundedVec<Type, Size> to Vec<Type>
-    removeExtensions('Bounded', true),
-    // Change WeakVec<Type> to Vec<Type>
-    removeExtensions('Weak', false),
-    // Remove all the trait prefixes
-    removeTraits(),
-    // remove PairOf<T> -> (T, T)
-    removePairOf(),
-    // remove boxing, `Box<Proposal>` -> `Proposal`
-    removeWrap('Box<'),
-    // remove generics, `MisbehaviorReport<Hash, BlockNumber>` -> `MisbehaviorReport`
-    removeGenerics(),
-    // alias String -> Text (compat with jsonrpc methods)
-    alias('String', 'Text'),
-    // alias Vec<u8> -> Bytes
-    alias('Vec<u8>', 'Bytes'),
-    alias('&\\[u8\\]', 'Bytes'),
-    alias("&'static\\[u8\\]", 'Bytes'),
-    // alias RawAddress -> Address
-    alias('RawAddress', 'Address'),
-    // lookups, mapped to Address/AccountId as appropriate in runtime
-    alias('Lookup::Source', 'LookupSource'),
-    alias('Lookup::Target', 'LookupTarget'),
-    // HACK duplication between contracts & primitives, however contracts prefixed with exec
-    alias('exec::StorageKey', 'ContractStorageKey'),
-    // flattens tuples with one value, `(AccountId)` -> `AccountId`
-    flattenSingleTuple(),
-    // converts ::Type to Type, <T as Trait<I>>::Proposal -> Proposal
-    removeColons(),
-    // remove all trailing spaces - this should always be the last
-    trim()
-];
-export function trim() {
-    return (value) => value.trim();
-}
-export function findClosing(value, start) {
-    let depth = 0;
-    for (let i = start, count = value.length; i < count; i++) {
-        if (value[i] === '>') {
-            if (!depth) {
-                return i;
-            }
-            depth--;
-        }
-        else if (value[i] === '<') {
-            depth++;
-        }
-    }
-    throw new Error(`Unable to find closing matching <> on '${value}' (start ${start})`);
-}
-export function alias(src, dest, withChecks = true) {
-    const from = new RegExp(`(^${src}|${BOX_PRECEDING.map((box) => `\\${box}${src}`).join('|')})`, 'g');
-    const to = (src) => {
-        from.lastIndex = 0;
-        return withChecks && BOX_PRECEDING.includes(src[0])
-            ? `${src[0]}${dest}`
-            : dest;
-    };
-    return (value) => value.replace(from, to);
-}
-export function cleanupCompact() {
-    return (value) => {
-        if (value.includes(' as HasCompact')) {
-            for (let i = 0, count = value.length; i < count; i++) {
-                if (value[i] === '<') {
-                    const end = findClosing(value, i + 1) - 14;
-                    if (value.substring(end, end + 14) === ' as HasCompact') {
-                        value = `Compact<${value.substring(i + 1, end)}>`;
-                    }
-                }
-            }
-        }
-        return value;
-    };
-}
-export function flattenSingleTuple() {
-    const from1 = /,\)/g;
-    const from2 = /\(([^,]+)\)/;
-    return (value) => {
-        from1.lastIndex = 0;
-        return value
-            // tuples may have trailing commas, e.g. (u32, BlockNumber, )
-            .replace(from1, ')')
-            // change (u32) -> u32
-            .replace(from2, '$1');
-    };
-}
-function replaceTagWith(value, matcher, replacer) {
-    let index = -1;
-    while (true) {
-        index = value.indexOf(matcher, index + 1);
-        if (index === -1) {
-            return value;
-        }
-        const start = index + matcher.length;
-        const end = findClosing(value, start);
-        value = `${value.substring(0, index)}${replacer(value.substring(start, end))}${value.substring(end + 1)}`;
-    }
-}
-export function removeExtensions(type, isSized) {
-    return (value) => {
-        for (let i = 0, count = BOUNDED.length; i < count; i++) {
-            const tag = BOUNDED[i];
-            value = replaceTagWith(value, `${type}${tag}<`, (v) => {
-                const parts = v
-                    .split(',')
-                    .map((s) => s.trim())
-                    .filter((s) => s);
-                if (isSized) {
-                    parts.pop();
-                }
-                return `${tag}<${parts.join(',')}>`;
-            });
-        }
-        return value;
-    };
-}
-export function removeColons() {
-    return (value) => {
-        let index = 0;
-        while (index !== -1) {
-            index = value.indexOf('::');
-            if (index === 0) {
-                value = value.substring(2);
-            }
-            else if (index !== -1) {
-                let start = index;
-                while (start !== -1 && !BOX_PRECEDING.includes(value[start])) {
-                    start--;
-                }
-                value = `${value.substring(0, start + 1)}${value.substring(index + 2)}`;
-            }
-        }
-        return value;
-    };
-}
-export function removeGenerics() {
-    return (value) => {
-        for (let i = 0, count = value.length; i < count; i++) {
-            if (value[i] === '<') {
-                // check against the allowed wrappers, be it Vec<..>, Option<...> ...
-                const box = ALLOWED_BOXES.find((box) => {
-                    const start = i - box.length;
-                    return ((start >= 0 &&
-                        value.substring(start, i) === box) && (
-                    // make sure it is stand-alone, i.e. don't catch ElectionResult<...> as Result<...>
-                    start === 0 ||
-                        BOX_PRECEDING.includes(value[start - 1])));
-                });
-                // we have not found anything, unwrap generic innards
-                if (!box) {
-                    const end = findClosing(value, i + 1);
-                    value = `${value.substring(0, i)}${value.substring(end + 1)}`;
-                }
-            }
-        }
-        return value;
-    };
-}
-export function removePairOf() {
-    const replacer = (v) => `(${v},${v})`;
-    return (value) => replaceTagWith(value, 'PairOf<', replacer);
-}
-export function removeTraits() {
-    const from1 = /\s/g;
-    const from2 = /(T|Self)::/g;
-    const from3 = /<(T|Self)asTrait>::/g;
-    const from4 = /<Tas[a-z]+::Trait>::/g;
-    const from5 = /<LookupasStaticLookup>/g;
-    const from6 = /::Type/g;
-    return (value) => {
-        from1.lastIndex = 0;
-        from2.lastIndex = 0;
-        from3.lastIndex = 0;
-        from4.lastIndex = 0;
-        from5.lastIndex = 0;
-        from6.lastIndex = 0;
-        return value
-            // remove all whitespaces
-            .replace(from1, '')
-            // anything `T::<type>` to end up as `<type>`
-            .replace(from2, '')
-            // replace `<T as Trait>::` (whitespaces were removed above)
-            .replace(from3, '')
-            // replace `<T as something::Trait>::` (whitespaces were removed above)
-            .replace(from4, '')
-            // replace <Lookup as StaticLookup>
-            .replace(from5, 'Lookup')
-            // replace `<...>::Type`
-            .replace(from6, '');
-    };
-}
-export function removeWrap(check) {
-    const replacer = (v) => v;
-    return (value) => replaceTagWith(value, check, replacer);
-}
-const sanitizeMap = new Map();
-export function sanitize(value) {
-    const startValue = value.toString();
-    const memoized = sanitizeMap.get(startValue);
-    if (memoized) {
-        return memoized;
-    }
-    let result = startValue;
-    for (let i = 0, count = mappings.length; i < count; i++) {
-        result = mappings[i](result);
-    }
-    sanitizeMap.set(startValue, result);
-    return result;
-}

package/build/utils/sortValues.d.ts

@@ -1,12 +0,0 @@
-import type { BN } from '@pezkuwi/util';
-import type { Codec } from '../types/index.js';
-type SortArg = Codec | Codec[] | number[] | BN | bigint | number | Uint8Array;
-/**
-* Sort keys/values of BTreeSet/BTreeMap in ascending order for encoding compatibility with Rust's BTreeSet/BTreeMap
-* (https://doc.rust-lang.org/stable/std/collections/struct.BTreeSet.html)
-* (https://doc.rust-lang.org/stable/std/collections/struct.BTreeMap.html)
-*/
-export declare function sortAsc<V extends SortArg = Codec>(a: V, b: V): number;
-export declare function sortSet<V extends Codec = Codec>(set: Set<V>): Set<V>;
-export declare function sortMap<K extends Codec = Codec, V extends Codec = Codec>(map: Map<K, V>): Map<K, V>;
-export {};