Variable ecConst

ec: {
    bitMask: ((n: number) => bigint);
    isNegativeLE: ((num: bigint, modulo: bigint) => boolean);
    notImplemented: (() => never);
    p256: Readonly<{
        create: ((hash: CHash) => CurveFn);
        CURVE: ReturnType<((curve: CurveType) => Readonly<{
            a: bigint;
            allowedPrivateKeyLengths?: readonly number[];
            allowInfinityPoint?: boolean;
            b: bigint;
            bits2int?: ((bytes: Uint8Array) => bigint);
            bits2int_modN?: ((bytes: Uint8Array) => bigint);
            clearCofactor?: ((c: ProjConstructor, point: ProjPointType) => ProjPointType);
            endo?: {
                beta: bigint;
                splitScalar: ((k: bigint) => {
                    k1: bigint;
                    k1neg: boolean;
                    k2: bigint;
                    k2neg: boolean;
                });
            };
            Fp: IField;
            Gx: bigint;
            Gy: bigint;
            h: bigint;
            hash: CHash;
            hEff?: bigint;
            hmac: ((key: Uint8Array, ...messages: Uint8Array[]) => Uint8Array);
            isTorsionFree?: ((c: ProjConstructor, point: ProjPointType) => boolean);
            lowS: boolean;
            n: bigint;
            nBitLength: number;
            nByteLength: number;
            p: bigint;
            randomBytes: ((bytesLength?: number) => Uint8Array);
            wrapPrivateKey?: boolean;
        }>)>;
        getPublicKey: ((privateKey: PrivKey, isCompressed?: boolean) => Uint8Array);
        getSharedSecret: ((privateA: PrivKey, publicB: Hex, isCompressed?: boolean) => Uint8Array);
        ProjectivePoint: ProjConstructor;
        sign: ((msgHash: Hex, privKey: PrivKey, opts?: SignOpts) => RecoveredSignatureType);
        Signature: SignatureConstructor;
        utils: {
            normPrivateKeyToScalar: ((key: PrivKey) => bigint);
            precompute: ((windowSize?: number, point?: ProjPointType) => ProjPointType);
            randomPrivateKey: (() => Uint8Array);
            isValidPrivateKey(privateKey: PrivKey): boolean;
        };
        verify: ((signature: Hex | {
            r: bigint;
            s: bigint;
        }, msgHash: Hex, publicKey: Hex, opts?: VerOpts) => boolean);
    }>;
    abool(title: string, value: boolean): void;
    abytes(item: unknown): void;
    aInRange(title: string, n: bigint, min: bigint, max: bigint): void;
    bitGet(n: bigint, pos: number): bigint;
    bitLen(n: bigint): number;
    bitSet(n: bigint, pos: number, value: boolean): bigint;
    bytesToHex(bytes: Uint8Array): string;
    bytesToNumberBE(bytes: Uint8Array): bigint;
    bytesToNumberLE(bytes: Uint8Array): bigint;
    concatBytes(...arrays: Uint8Array[]): Uint8Array;
    createHmacDrbg<T>(hashLen: number, qByteLen: number, hmacFn: ((key: Uint8Array, ...messages: Uint8Array[]) => Uint8Array)): ((seed: Uint8Array, predicate: ((v: Uint8Array) => undefined | T)) => T);
    ensureBytes(title: string, hex: Hex, expectedLength?: number): Uint8Array;
    equalBytes(a: Uint8Array, b: Uint8Array): boolean;
    Field(ORDER: bigint, bitLen?: number, isLE?: boolean, redef?: Partial<IField<bigint>>): Readonly<IField<bigint> & Required<Pick<IField<bigint>, "isOdd">>>;
    FpDiv<T>(f: IField<T>, lhs: T, rhs: bigint | T): T;
    FpInvertBatch<T>(f: IField<T>, nums: T[]): T[];
    FpIsSquare<T>(f: IField<T>): ((x: T) => boolean);
    FpLegendre(order: bigint): (<T>(f: IField<T>, x: T) => T);
    FpPow<T>(f: IField<T>, num: T, power: bigint): T;
    FpSqrt(P: bigint): (<T>(Fp: IField<T>, n: T) => T);
    FpSqrtEven<T>(Fp: IField<T>, elm: T): T;
    FpSqrtOdd<T>(Fp: IField<T>, elm: T): T;
    getFieldBytesLength(fieldOrder: bigint): number;
    getMinHashLength(fieldOrder: bigint): number;
    hashToPrivateScalar(hash: string | Uint8Array, groupOrder: bigint, isLE?: boolean): bigint;
    hexToBytes(hex: string): Uint8Array;
    hexToNumber(hex: string): bigint;
    inRange(n: bigint, min: bigint, max: bigint): boolean;
    invert(number: bigint, modulo: bigint): bigint;
    isBytes(a: unknown): a is Uint8Array;
    mapHashToField(key: Uint8Array, fieldOrder: bigint, isLE?: boolean): Uint8Array;
    memoized<T, R, O>(fn: ((arg: T, ...args: O) => R)): ((arg: T, ...args: O) => R);
    mod(a: bigint, b: bigint): bigint;
    nLength(n: bigint, nBitLength?: number): {
        nBitLength: number;
        nByteLength: number;
    };
    numberToBytesBE(n: number | bigint, len: number): Uint8Array;
    numberToBytesLE(n: number | bigint, len: number): Uint8Array;
    numberToHexUnpadded(num: number | bigint): string;
    numberToVarBytesBE(n: number | bigint): Uint8Array;
    pow(num: bigint, power: bigint, modulo: bigint): bigint;
    pow2(x: bigint, power: bigint, modulo: bigint): bigint;
    tonelliShanks(P: bigint): (<T>(Fp: IField<T>, n: T) => T);
    utf8ToBytes(str: string): Uint8Array;
    validateField<T>(field: IField<T>): IField<T>;
    validateObject<T>(object: T, validators: {
        [K in string | number | symbol]?:
            | "string"
            | "bigint"
            | "boolean"
            | "function"
            | "hash"
            | "stringOrUint8Array"
            | "isSafeInteger"
            | "array"
            | "field"
    }, optValidators?: {
        [K in string | number | symbol]?:
            | "string"
            | "bigint"
            | "boolean"
            | "function"
            | "hash"
            | "stringOrUint8Array"
            | "isSafeInteger"
            | "array"
            | "field"
    }): T;
}