ccxt-ir 4.9.13 → 4.9.14

package/js/src/static_dependencies/jsencrypt/lib/jsbn/jsbn.d.ts

@@ -1,101 +1,101 @@
-import { SecureRandom } from "./rng.js";
-/**
- * @type Class
- */
-export declare class BigInteger {
-    constructor(a: number | number[] | string, b?: number | SecureRandom, c?: number | SecureRandom);
-    toString(b: number): string;
-    protected negate(): BigInteger;
-    abs(): BigInteger;
-    compareTo(a: BigInteger): number;
-    bitLength(): number;
-    mod(a: BigInteger): BigInteger;
-    modPowInt(e: number, m: BigInteger): BigInteger;
-    protected clone(): BigInteger;
-    protected intValue(): number;
-    protected byteValue(): number;
-    protected shortValue(): number;
-    protected signum(): 1 | 0 | -1;
-    toByteArray(): number[];
-    protected equals(a: BigInteger): boolean;
-    protected min(a: BigInteger): BigInteger;
-    protected max(a: BigInteger): BigInteger;
-    protected and(a: BigInteger): BigInteger;
-    protected or(a: BigInteger): BigInteger;
-    protected xor(a: BigInteger): BigInteger;
-    protected andNot(a: BigInteger): BigInteger;
-    protected not(): BigInteger;
-    protected shiftLeft(n: number): BigInteger;
-    protected shiftRight(n: number): BigInteger;
-    protected getLowestSetBit(): number;
-    protected bitCount(): number;
-    protected testBit(n: number): boolean;
-    protected setBit(n: number): BigInteger;
-    protected clearBit(n: number): BigInteger;
-    protected flipBit(n: number): BigInteger;
-    add(a: BigInteger): BigInteger;
-    subtract(a: BigInteger): BigInteger;
-    multiply(a: BigInteger): BigInteger;
-    divide(a: BigInteger): BigInteger;
-    protected remainder(a: BigInteger): BigInteger;
-    protected divideAndRemainder(a: BigInteger): BigInteger[];
-    modPow(e: BigInteger, m: BigInteger): BigInteger;
-    modInverse(m: BigInteger): BigInteger;
-    protected pow(e: number): BigInteger;
-    gcd(a: BigInteger): BigInteger;
-    isProbablePrime(t: number): boolean;
-    copyTo(r: BigInteger): void;
-    fromInt(x: number): void;
-    protected fromString(s: string | number[], b: number): void;
-    clamp(): void;
-    dlShiftTo(n: number, r: BigInteger): void;
-    drShiftTo(n: number, r: BigInteger): void;
-    protected lShiftTo(n: number, r: BigInteger): void;
-    protected rShiftTo(n: number, r: BigInteger): void;
-    subTo(a: BigInteger, r: BigInteger): void;
-    multiplyTo(a: BigInteger, r: BigInteger): void;
-    squareTo(r: BigInteger): void;
-    divRemTo(m: BigInteger, q: BigInteger, r: BigInteger): void;
-    invDigit(): number;
-    protected isEven(): boolean;
-    protected exp(e: number, z: IReduction): BigInteger;
-    protected chunkSize(r: number): number;
-    protected toRadix(b: number): string;
-    fromRadix(s: string, b: number): void;
-    protected fromNumber(a: number, b: number | SecureRandom, c?: number | SecureRandom): void;
-    protected bitwiseTo(a: BigInteger, op: (a: number, b: number) => number, r: BigInteger): void;
-    protected changeBit(n: number, op: (a: number, b: number) => number): BigInteger;
-    protected addTo(a: BigInteger, r: BigInteger): void;
-    protected dMultiply(n: number): void;
-    dAddOffset(n: number, w: number): void;
-    multiplyLowerTo(a: BigInteger, n: number, r: BigInteger): void;
-    multiplyUpperTo(a: BigInteger, n: number, r: BigInteger): void;
-    protected modInt(n: number): number;
-    protected millerRabin(t: number): boolean;
-    protected square(): BigInteger;
-    gcda(a: BigInteger, callback: (x: BigInteger) => void): void;
-    fromNumberAsync(a: number, b: number | SecureRandom, c: number | SecureRandom, callback: () => void): void;
-    s: number;
-    t: number;
-    DB: number;
-    DM: number;
-    DV: number;
-    FV: number;
-    F1: number;
-    F2: number;
-    am: (i: number, x: number, w: BigInteger, j: number, c: number, n: number) => number;
-    [index: number]: number;
-    static ONE: BigInteger;
-    static ZERO: BigInteger;
-}
-export interface IReduction {
-    convert(x: BigInteger): BigInteger;
-    revert(x: BigInteger): BigInteger;
-    mulTo(x: BigInteger, y: BigInteger, r: BigInteger): void;
-    sqrTo(x: BigInteger, r: BigInteger): void;
-}
-export declare function nbi(): BigInteger;
-export declare function parseBigInt(str: string, r: number): BigInteger;
-export declare function intAt(s: string, i: number): number;
-export declare function nbv(i: number): BigInteger;
-export declare function nbits(x: number): number;
+import { SecureRandom } from "./rng.js";
+/**
+ * @type Class
+ */
+export declare class BigInteger {
+    constructor(a: number | number[] | string, b?: number | SecureRandom, c?: number | SecureRandom);
+    toString(b: number): string;
+    protected negate(): BigInteger;
+    abs(): BigInteger;
+    compareTo(a: BigInteger): number;
+    bitLength(): number;
+    mod(a: BigInteger): BigInteger;
+    modPowInt(e: number, m: BigInteger): BigInteger;
+    protected clone(): BigInteger;
+    protected intValue(): number;
+    protected byteValue(): number;
+    protected shortValue(): number;
+    protected signum(): 1 | 0 | -1;
+    toByteArray(): number[];
+    protected equals(a: BigInteger): boolean;
+    protected min(a: BigInteger): BigInteger;
+    protected max(a: BigInteger): BigInteger;
+    protected and(a: BigInteger): BigInteger;
+    protected or(a: BigInteger): BigInteger;
+    protected xor(a: BigInteger): BigInteger;
+    protected andNot(a: BigInteger): BigInteger;
+    protected not(): BigInteger;
+    protected shiftLeft(n: number): BigInteger;
+    protected shiftRight(n: number): BigInteger;
+    protected getLowestSetBit(): number;
+    protected bitCount(): number;
+    protected testBit(n: number): boolean;
+    protected setBit(n: number): BigInteger;
+    protected clearBit(n: number): BigInteger;
+    protected flipBit(n: number): BigInteger;
+    add(a: BigInteger): BigInteger;
+    subtract(a: BigInteger): BigInteger;
+    multiply(a: BigInteger): BigInteger;
+    divide(a: BigInteger): BigInteger;
+    protected remainder(a: BigInteger): BigInteger;
+    protected divideAndRemainder(a: BigInteger): BigInteger[];
+    modPow(e: BigInteger, m: BigInteger): BigInteger;
+    modInverse(m: BigInteger): BigInteger;
+    protected pow(e: number): BigInteger;
+    gcd(a: BigInteger): BigInteger;
+    isProbablePrime(t: number): boolean;
+    copyTo(r: BigInteger): void;
+    fromInt(x: number): void;
+    protected fromString(s: string | number[], b: number): void;
+    clamp(): void;
+    dlShiftTo(n: number, r: BigInteger): void;
+    drShiftTo(n: number, r: BigInteger): void;
+    protected lShiftTo(n: number, r: BigInteger): void;
+    protected rShiftTo(n: number, r: BigInteger): void;
+    subTo(a: BigInteger, r: BigInteger): void;
+    multiplyTo(a: BigInteger, r: BigInteger): void;
+    squareTo(r: BigInteger): void;
+    divRemTo(m: BigInteger, q: BigInteger, r: BigInteger): void;
+    invDigit(): number;
+    protected isEven(): boolean;
+    protected exp(e: number, z: IReduction): BigInteger;
+    protected chunkSize(r: number): number;
+    protected toRadix(b: number): string;
+    fromRadix(s: string, b: number): void;
+    protected fromNumber(a: number, b: number | SecureRandom, c?: number | SecureRandom): void;
+    protected bitwiseTo(a: BigInteger, op: (a: number, b: number) => number, r: BigInteger): void;
+    protected changeBit(n: number, op: (a: number, b: number) => number): BigInteger;
+    protected addTo(a: BigInteger, r: BigInteger): void;
+    protected dMultiply(n: number): void;
+    dAddOffset(n: number, w: number): void;
+    multiplyLowerTo(a: BigInteger, n: number, r: BigInteger): void;
+    multiplyUpperTo(a: BigInteger, n: number, r: BigInteger): void;
+    protected modInt(n: number): number;
+    protected millerRabin(t: number): boolean;
+    protected square(): BigInteger;
+    gcda(a: BigInteger, callback: (x: BigInteger) => void): void;
+    fromNumberAsync(a: number, b: number | SecureRandom, c: number | SecureRandom, callback: () => void): void;
+    s: number;
+    t: number;
+    DB: number;
+    DM: number;
+    DV: number;
+    FV: number;
+    F1: number;
+    F2: number;
+    am: (i: number, x: number, w: BigInteger, j: number, c: number, n: number) => number;
+    [index: number]: number;
+    static ONE: BigInteger;
+    static ZERO: BigInteger;
+}
+export interface IReduction {
+    convert(x: BigInteger): BigInteger;
+    revert(x: BigInteger): BigInteger;
+    mulTo(x: BigInteger, y: BigInteger, r: BigInteger): void;
+    sqrTo(x: BigInteger, r: BigInteger): void;
+}
+export declare function nbi(): BigInteger;
+export declare function parseBigInt(str: string, r: number): BigInteger;
+export declare function intAt(s: string, i: number): number;
+export declare function nbv(i: number): BigInteger;
+export declare function nbits(x: number): number;

package/js/src/static_dependencies/noble-curves/abstract/weierstrass.d.ts

@@ -1,204 +1,204 @@
-/// <reference types="node" />
-/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-import * as mod from './modular.js';
-import * as ut from './utils.js';
-import { CHash, Hex, PrivKey } from './utils.js';
-import { Group, GroupConstructor, BasicCurve, AffinePoint } from './curve.js';
-export type { AffinePoint };
-declare type HmacFnSync = (key: Uint8Array, ...messages: Uint8Array[]) => Uint8Array;
-declare type EndomorphismOpts = {
-    beta: bigint;
-    splitScalar: (k: bigint) => {
-        k1neg: boolean;
-        k1: bigint;
-        k2neg: boolean;
-        k2: bigint;
-    };
-};
-export declare type BasicWCurve<T> = BasicCurve<T> & {
-    a: T;
-    b: T;
-    allowedPrivateKeyLengths?: readonly number[];
-    wrapPrivateKey?: boolean;
-    endo?: EndomorphismOpts;
-    isTorsionFree?: (c: ProjConstructor<T>, point: ProjPointType<T>) => boolean;
-    clearCofactor?: (c: ProjConstructor<T>, point: ProjPointType<T>) => ProjPointType<T>;
-};
-declare type Entropy = Hex | true;
-export declare type SignOpts = {
-    lowS?: boolean;
-    extraEntropy?: Entropy;
-    prehash?: boolean;
-};
-export declare type VerOpts = {
-    lowS?: boolean;
-    prehash?: boolean;
-};
-/**
- * ### Design rationale for types
- *
- * * Interaction between classes from different curves should fail:
- *   `k256.Point.BASE.add(p256.Point.BASE)`
- * * For this purpose we want to use `instanceof` operator, which is fast and works during runtime
- * * Different calls of `curve()` would return different classes -
- *   `curve(params) !== curve(params)`: if somebody decided to monkey-patch their curve,
- *   it won't affect others
- *
- * TypeScript can't infer types for classes created inside a function. Classes is one instance of nominative types in TypeScript and interfaces only check for shape, so it's hard to create unique type for every function call.
- *
- * We can use generic types via some param, like curve opts, but that would:
- *     1. Enable interaction between `curve(params)` and `curve(params)` (curves of same params)
- *     which is hard to debug.
- *     2. Params can be generic and we can't enforce them to be constant value:
- *     if somebody creates curve from non-constant params,
- *     it would be allowed to interact with other curves with non-constant params
- *
- * TODO: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-7.html#unique-symbol
- */
-export interface ProjPointType<T> extends Group<ProjPointType<T>> {
-    readonly px: T;
-    readonly py: T;
-    readonly pz: T;
-    multiply(scalar: bigint): ProjPointType<T>;
-    toAffine(iz?: T): AffinePoint<T>;
-    isTorsionFree(): boolean;
-    clearCofactor(): ProjPointType<T>;
-    assertValidity(): void;
-    hasEvenY(): boolean;
-    toRawBytes(isCompressed?: boolean): Uint8Array;
-    toHex(isCompressed?: boolean): string;
-    multiplyUnsafe(scalar: bigint): ProjPointType<T>;
-    multiplyAndAddUnsafe(Q: ProjPointType<T>, a: bigint, b: bigint): ProjPointType<T> | undefined;
-    _setWindowSize(windowSize: number): void;
-}
-export interface ProjConstructor<T> extends GroupConstructor<ProjPointType<T>> {
-    new (x: T, y: T, z: T): ProjPointType<T>;
-    fromAffine(p: AffinePoint<T>): ProjPointType<T>;
-    fromHex(hex: Hex): ProjPointType<T>;
-    fromPrivateKey(privateKey: PrivKey): ProjPointType<T>;
-    normalizeZ(points: ProjPointType<T>[]): ProjPointType<T>[];
-}
-export declare type CurvePointsType<T> = BasicWCurve<T> & {
-    fromBytes: (bytes: Uint8Array) => AffinePoint<T>;
-    toBytes: (c: ProjConstructor<T>, point: ProjPointType<T>, compressed: boolean) => Uint8Array;
-};
-export declare type CurvePointsRes<T> = {
-    ProjectivePoint: ProjConstructor<T>;
-    normPrivateKeyToScalar: (key: PrivKey) => bigint;
-    weierstrassEquation: (x: T) => T;
-    isWithinCurveOrder: (num: bigint) => boolean;
-};
-export declare const DER: {
-    Err: {
-        new (m?: string): {
-            name: string;
-            message: string;
-            stack?: string;
-        };
-        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-        prepareStackTrace?: (err: Error, stackTraces: NodeJS.CallSite[]) => any;
-        stackTraceLimit: number;
-    };
-    _parseInt(data: Uint8Array): {
-        d: bigint;
-        l: Uint8Array;
-    };
-    toSig(hex: string | Uint8Array): {
-        r: bigint;
-        s: bigint;
-    };
-    hexFromSig(sig: {
-        r: bigint;
-        s: bigint;
-    }): string;
-};
-export declare function weierstrassPoints<T>(opts: CurvePointsType<T>): {
-    ProjectivePoint: ProjConstructor<T>;
-    normPrivateKeyToScalar: (key: PrivKey) => bigint;
-    weierstrassEquation: (x: T) => T;
-    isWithinCurveOrder: (num: bigint) => boolean;
-};
-export interface SignatureType {
-    readonly r: bigint;
-    readonly s: bigint;
-    readonly recovery?: number;
-    assertValidity(): void;
-    addRecoveryBit(recovery: number): SignatureType;
-    hasHighS(): boolean;
-    normalizeS(): SignatureType;
-    recoverPublicKey(msgHash: Hex): ProjPointType<bigint>;
-    toCompactRawBytes(): Uint8Array;
-    toCompactHex(): string;
-    toDERRawBytes(isCompressed?: boolean): Uint8Array;
-    toDERHex(isCompressed?: boolean): string;
-}
-export declare type SignatureConstructor = {
-    new (r: bigint, s: bigint): SignatureType;
-    fromCompact(hex: Hex): SignatureType;
-    fromDER(hex: Hex): SignatureType;
-};
-declare type SignatureLike = {
-    r: bigint;
-    s: bigint;
-};
-export declare type PubKey = Hex | ProjPointType<bigint>;
-export declare type CurveType = BasicWCurve<bigint> & {
-    hash: CHash;
-    hmac: HmacFnSync;
-    randomBytes: (bytesLength?: number) => Uint8Array;
-    lowS?: boolean;
-    bits2int?: (bytes: Uint8Array) => bigint;
-    bits2int_modN?: (bytes: Uint8Array) => bigint;
-};
-declare function validateOpts(curve: CurveType): Readonly<{
-    readonly nBitLength: number;
-    readonly nByteLength: number;
-    readonly Fp: mod.Field<bigint>;
-    readonly n: bigint;
-    readonly h: bigint;
-    readonly hEff?: bigint;
-    readonly Gx: bigint;
-    readonly Gy: bigint;
-    readonly allowInfinityPoint?: boolean;
-    readonly a: bigint;
-    readonly b: bigint;
-    readonly allowedPrivateKeyLengths?: readonly number[];
-    readonly wrapPrivateKey?: boolean;
-    readonly endo?: EndomorphismOpts;
-    readonly isTorsionFree?: (c: ProjConstructor<bigint>, point: ProjPointType<bigint>) => boolean;
-    readonly clearCofactor?: (c: ProjConstructor<bigint>, point: ProjPointType<bigint>) => ProjPointType<bigint>;
-    readonly hash: ut.CHash;
-    readonly hmac: HmacFnSync;
-    readonly randomBytes: (bytesLength?: number) => Uint8Array;
-    lowS: boolean;
-    readonly bits2int?: (bytes: Uint8Array) => bigint;
-    readonly bits2int_modN?: (bytes: Uint8Array) => bigint;
-}>;
-export declare type CurveFn = {
-    CURVE: ReturnType<typeof validateOpts>;
-    getPublicKey: (privateKey: PrivKey, isCompressed?: boolean) => Uint8Array;
-    getSharedSecret: (privateA: PrivKey, publicB: Hex, isCompressed?: boolean) => Uint8Array;
-    sign: (msgHash: Hex, privKey: PrivKey, opts?: SignOpts) => SignatureType;
-    verify: (signature: Hex | SignatureLike, msgHash: Hex, publicKey: Hex, opts?: VerOpts) => boolean;
-    ProjectivePoint: ProjConstructor<bigint>;
-    Signature: SignatureConstructor;
-    utils: {
-        normPrivateKeyToScalar: (key: PrivKey) => bigint;
-        isValidPrivateKey(privateKey: PrivKey): boolean;
-        randomPrivateKey: () => Uint8Array;
-        precompute: (windowSize?: number, point?: ProjPointType<bigint>) => ProjPointType<bigint>;
-    };
-};
-export declare function weierstrass(curveDef: CurveType): CurveFn;
-export declare function SWUFpSqrtRatio<T>(Fp: mod.Field<T>, Z: T): (u: T, v: T) => {
-    isValid: boolean;
-    value: T;
-};
-export declare function mapToCurveSimpleSWU<T>(Fp: mod.Field<T>, opts: {
-    A: T;
-    B: T;
-    Z: T;
-}): (u: T) => {
-    x: T;
-    y: T;
-};
+/// <reference types="node" />
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+import * as mod from './modular.js';
+import * as ut from './utils.js';
+import { CHash, Hex, PrivKey } from './utils.js';
+import { Group, GroupConstructor, BasicCurve, AffinePoint } from './curve.js';
+export type { AffinePoint };
+declare type HmacFnSync = (key: Uint8Array, ...messages: Uint8Array[]) => Uint8Array;
+declare type EndomorphismOpts = {
+    beta: bigint;
+    splitScalar: (k: bigint) => {
+        k1neg: boolean;
+        k1: bigint;
+        k2neg: boolean;
+        k2: bigint;
+    };
+};
+export declare type BasicWCurve<T> = BasicCurve<T> & {
+    a: T;
+    b: T;
+    allowedPrivateKeyLengths?: readonly number[];
+    wrapPrivateKey?: boolean;
+    endo?: EndomorphismOpts;
+    isTorsionFree?: (c: ProjConstructor<T>, point: ProjPointType<T>) => boolean;
+    clearCofactor?: (c: ProjConstructor<T>, point: ProjPointType<T>) => ProjPointType<T>;
+};
+declare type Entropy = Hex | true;
+export declare type SignOpts = {
+    lowS?: boolean;
+    extraEntropy?: Entropy;
+    prehash?: boolean;
+};
+export declare type VerOpts = {
+    lowS?: boolean;
+    prehash?: boolean;
+};
+/**
+ * ### Design rationale for types
+ *
+ * * Interaction between classes from different curves should fail:
+ *   `k256.Point.BASE.add(p256.Point.BASE)`
+ * * For this purpose we want to use `instanceof` operator, which is fast and works during runtime
+ * * Different calls of `curve()` would return different classes -
+ *   `curve(params) !== curve(params)`: if somebody decided to monkey-patch their curve,
+ *   it won't affect others
+ *
+ * TypeScript can't infer types for classes created inside a function. Classes is one instance of nominative types in TypeScript and interfaces only check for shape, so it's hard to create unique type for every function call.
+ *
+ * We can use generic types via some param, like curve opts, but that would:
+ *     1. Enable interaction between `curve(params)` and `curve(params)` (curves of same params)
+ *     which is hard to debug.
+ *     2. Params can be generic and we can't enforce them to be constant value:
+ *     if somebody creates curve from non-constant params,
+ *     it would be allowed to interact with other curves with non-constant params
+ *
+ * TODO: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-7.html#unique-symbol
+ */
+export interface ProjPointType<T> extends Group<ProjPointType<T>> {
+    readonly px: T;
+    readonly py: T;
+    readonly pz: T;
+    multiply(scalar: bigint): ProjPointType<T>;
+    toAffine(iz?: T): AffinePoint<T>;
+    isTorsionFree(): boolean;
+    clearCofactor(): ProjPointType<T>;
+    assertValidity(): void;
+    hasEvenY(): boolean;
+    toRawBytes(isCompressed?: boolean): Uint8Array;
+    toHex(isCompressed?: boolean): string;
+    multiplyUnsafe(scalar: bigint): ProjPointType<T>;
+    multiplyAndAddUnsafe(Q: ProjPointType<T>, a: bigint, b: bigint): ProjPointType<T> | undefined;
+    _setWindowSize(windowSize: number): void;
+}
+export interface ProjConstructor<T> extends GroupConstructor<ProjPointType<T>> {
+    new (x: T, y: T, z: T): ProjPointType<T>;
+    fromAffine(p: AffinePoint<T>): ProjPointType<T>;
+    fromHex(hex: Hex): ProjPointType<T>;
+    fromPrivateKey(privateKey: PrivKey): ProjPointType<T>;
+    normalizeZ(points: ProjPointType<T>[]): ProjPointType<T>[];
+}
+export declare type CurvePointsType<T> = BasicWCurve<T> & {
+    fromBytes: (bytes: Uint8Array) => AffinePoint<T>;
+    toBytes: (c: ProjConstructor<T>, point: ProjPointType<T>, compressed: boolean) => Uint8Array;
+};
+export declare type CurvePointsRes<T> = {
+    ProjectivePoint: ProjConstructor<T>;
+    normPrivateKeyToScalar: (key: PrivKey) => bigint;
+    weierstrassEquation: (x: T) => T;
+    isWithinCurveOrder: (num: bigint) => boolean;
+};
+export declare const DER: {
+    Err: {
+        new (m?: string): {
+            name: string;
+            message: string;
+            stack?: string;
+        };
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace?: (err: Error, stackTraces: NodeJS.CallSite[]) => any;
+        stackTraceLimit: number;
+    };
+    _parseInt(data: Uint8Array): {
+        d: bigint;
+        l: Uint8Array;
+    };
+    toSig(hex: string | Uint8Array): {
+        r: bigint;
+        s: bigint;
+    };
+    hexFromSig(sig: {
+        r: bigint;
+        s: bigint;
+    }): string;
+};
+export declare function weierstrassPoints<T>(opts: CurvePointsType<T>): {
+    ProjectivePoint: ProjConstructor<T>;
+    normPrivateKeyToScalar: (key: PrivKey) => bigint;
+    weierstrassEquation: (x: T) => T;
+    isWithinCurveOrder: (num: bigint) => boolean;
+};
+export interface SignatureType {
+    readonly r: bigint;
+    readonly s: bigint;
+    readonly recovery?: number;
+    assertValidity(): void;
+    addRecoveryBit(recovery: number): SignatureType;
+    hasHighS(): boolean;
+    normalizeS(): SignatureType;
+    recoverPublicKey(msgHash: Hex): ProjPointType<bigint>;
+    toCompactRawBytes(): Uint8Array;
+    toCompactHex(): string;
+    toDERRawBytes(isCompressed?: boolean): Uint8Array;
+    toDERHex(isCompressed?: boolean): string;
+}
+export declare type SignatureConstructor = {
+    new (r: bigint, s: bigint): SignatureType;
+    fromCompact(hex: Hex): SignatureType;
+    fromDER(hex: Hex): SignatureType;
+};
+declare type SignatureLike = {
+    r: bigint;
+    s: bigint;
+};
+export declare type PubKey = Hex | ProjPointType<bigint>;
+export declare type CurveType = BasicWCurve<bigint> & {
+    hash: CHash;
+    hmac: HmacFnSync;
+    randomBytes: (bytesLength?: number) => Uint8Array;
+    lowS?: boolean;
+    bits2int?: (bytes: Uint8Array) => bigint;
+    bits2int_modN?: (bytes: Uint8Array) => bigint;
+};
+declare function validateOpts(curve: CurveType): Readonly<{
+    readonly nBitLength: number;
+    readonly nByteLength: number;
+    readonly Fp: mod.Field<bigint>;
+    readonly n: bigint;
+    readonly h: bigint;
+    readonly hEff?: bigint;
+    readonly Gx: bigint;
+    readonly Gy: bigint;
+    readonly allowInfinityPoint?: boolean;
+    readonly a: bigint;
+    readonly b: bigint;
+    readonly allowedPrivateKeyLengths?: readonly number[];
+    readonly wrapPrivateKey?: boolean;
+    readonly endo?: EndomorphismOpts;
+    readonly isTorsionFree?: (c: ProjConstructor<bigint>, point: ProjPointType<bigint>) => boolean;
+    readonly clearCofactor?: (c: ProjConstructor<bigint>, point: ProjPointType<bigint>) => ProjPointType<bigint>;
+    readonly hash: ut.CHash;
+    readonly hmac: HmacFnSync;
+    readonly randomBytes: (bytesLength?: number) => Uint8Array;
+    lowS: boolean;
+    readonly bits2int?: (bytes: Uint8Array) => bigint;
+    readonly bits2int_modN?: (bytes: Uint8Array) => bigint;
+}>;
+export declare type CurveFn = {
+    CURVE: ReturnType<typeof validateOpts>;
+    getPublicKey: (privateKey: PrivKey, isCompressed?: boolean) => Uint8Array;
+    getSharedSecret: (privateA: PrivKey, publicB: Hex, isCompressed?: boolean) => Uint8Array;
+    sign: (msgHash: Hex, privKey: PrivKey, opts?: SignOpts) => SignatureType;
+    verify: (signature: Hex | SignatureLike, msgHash: Hex, publicKey: Hex, opts?: VerOpts) => boolean;
+    ProjectivePoint: ProjConstructor<bigint>;
+    Signature: SignatureConstructor;
+    utils: {
+        normPrivateKeyToScalar: (key: PrivKey) => bigint;
+        isValidPrivateKey(privateKey: PrivKey): boolean;
+        randomPrivateKey: () => Uint8Array;
+        precompute: (windowSize?: number, point?: ProjPointType<bigint>) => ProjPointType<bigint>;
+    };
+};
+export declare function weierstrass(curveDef: CurveType): CurveFn;
+export declare function SWUFpSqrtRatio<T>(Fp: mod.Field<T>, Z: T): (u: T, v: T) => {
+    isValid: boolean;
+    value: T;
+};
+export declare function mapToCurveSimpleSWU<T>(Fp: mod.Field<T>, opts: {
+    A: T;
+    B: T;
+    Z: T;
+}): (u: T) => {
+    x: T;
+    y: T;
+};

package/js/src/static_dependencies/qs/formats.d.cts

@@ -1,8 +1,8 @@
-declare const _default: string;
-export declare namespace formatters {
-    function RFC1738(value: any): string;
-    function RFC3986(value: any): any;
-}
-declare const RFC1738_1: string;
-declare const RFC3986_1: string;
-export { _default as default, RFC1738_1 as RFC1738, RFC3986_1 as RFC3986 };
+declare const _default: string;
+export declare namespace formatters {
+    function RFC1738(value: any): string;
+    function RFC3986(value: any): any;
+}
+declare const RFC1738_1: string;
+declare const RFC3986_1: string;
+export { _default as default, RFC1738_1 as RFC1738, RFC3986_1 as RFC3986 };

package/js/src/static_dependencies/qs/index.d.cts

@@ -1,4 +1,4 @@
-import formats = require("./formats.cjs");
-import parse = require("./parse.cjs");
-import stringify = require("./stringify.cjs");
-export { formats, parse, stringify };
+import formats = require("./formats.cjs");
+import parse = require("./parse.cjs");
+import stringify = require("./stringify.cjs");
+export { formats, parse, stringify };

package/js/src/static_dependencies/qs/parse.d.cts

@@ -1,2 +1,2 @@
-declare function _exports(str: any, opts: any): any;
-export = _exports;
+declare function _exports(str: any, opts: any): any;
+export = _exports;

package/js/src/static_dependencies/qs/stringify.d.cts

@@ -1,2 +1,2 @@
-declare function _exports(object: any, opts: any): string;
-export = _exports;
+declare function _exports(object: any, opts: any): string;
+export = _exports;