@types/jsbn

  • Version 1.2.29
  • Published
  • No dependencies
  • MIT license

Install

npm i @types/jsbn
yarn add @types/jsbn
pnpm add @types/jsbn

Overview

TypeScript definitions for jsbn

Index

Classes

class BigInteger

class BigInteger {}

    constructor

    constructor(a: number, c: RandomGenerator);

      constructor

      constructor(a: number, b: number, c: RandomGenerator);

        constructor

        constructor(a: string, b?: number);

          constructor

          constructor(a: number[], b?: number);

            constructor

            constructor(a: BigInteger);

              property data

              data: number[];

                property DB

                DB: number;

                  property DM

                  DM: number;

                    property DV

                    DV: number;

                      property F1

                      F1: number;

                        property F2

                        F2: number;

                          property FV

                          FV: number;

                            property ONE

                            static ONE: BigInteger;

                              property s

                              s: number;

                                property t

                                t: number;

                                  property ZERO

                                  static ZERO: BigInteger;

                                    method abs

                                    abs: () => BigInteger;

                                      method add

                                      add: (a: BigInteger) => BigInteger;

                                        method addTo

                                        addTo: (a: BigInteger, r: BigInteger) => void;

                                          method am

                                          am: (
                                          i: number,
                                          x: number,
                                          w: BigInteger,
                                          j: number,
                                          c: number,
                                          n: number
                                          ) => number;

                                            method and

                                            and: (a: BigInteger) => BigInteger;

                                              method andNot

                                              andNot: (a: BigInteger) => BigInteger;

                                                method bitCount

                                                bitCount: () => number;

                                                  method bitLength

                                                  bitLength: () => number;

                                                    method bitwiseTo

                                                    bitwiseTo: (
                                                    a: BigInteger,
                                                    op: (x: number, y: number) => number,
                                                    r: BigInteger
                                                    ) => void;

                                                      method byteValue

                                                      byteValue: () => number;

                                                        method changeBit

                                                        changeBit: (n: number, op: (x: number, y: number) => number) => BigInteger;

                                                          method chunkSize

                                                          chunkSize: (r: number) => number;

                                                            method clamp

                                                            clamp: () => void;

                                                              method clearBit

                                                              clearBit: (n: number) => BigInteger;

                                                                method clone

                                                                clone: () => BigInteger;

                                                                  method compareTo

                                                                  compareTo: (a: BigInteger) => number;

                                                                    method copyTo

                                                                    copyTo: (r: BigInteger) => void;

                                                                      method dAddOffset

                                                                      dAddOffset: (n: number, w: number) => void;

                                                                        method divide

                                                                        divide: (a: BigInteger) => BigInteger;

                                                                          method divideAndRemainder

                                                                          divideAndRemainder: (a: BigInteger) => BigInteger[];

                                                                            method divRemTo

                                                                            divRemTo: (m: BigInteger, q: BigInteger, r: BigInteger) => void;

                                                                              method dlShiftTo

                                                                              dlShiftTo: (n: number, r: BigInteger) => void;

                                                                                method dMultiply

                                                                                dMultiply: (n: number) => void;

                                                                                  method drShiftTo

                                                                                  drShiftTo: (n: number, r: BigInteger) => void;

                                                                                    method equals

                                                                                    equals: (a: BigInteger) => boolean;

                                                                                      method exp

                                                                                      exp: (e: number, z: Reduction) => BigInteger;

                                                                                        method flipBit

                                                                                        flipBit: (n: number) => BigInteger;

                                                                                          method fromInt

                                                                                          fromInt: (x: number) => void;

                                                                                            method fromNumber

                                                                                            fromNumber: (a: number, b?: number, c?: number) => void;

                                                                                              method fromRadix

                                                                                              fromRadix: (s: string, b: number) => void;

                                                                                                method fromString

                                                                                                fromString: (x: string, b: number) => void;

                                                                                                  method gcd

                                                                                                  gcd: (a: BigInteger) => BigInteger;

                                                                                                    method getLowestSetBit

                                                                                                    getLowestSetBit: () => number;

                                                                                                      method intValue

                                                                                                      intValue: () => number;

                                                                                                        method invDigit

                                                                                                        invDigit: () => number;

                                                                                                          method isEven

                                                                                                          isEven: () => boolean;

                                                                                                            method isProbablePrime

                                                                                                            isProbablePrime: (t: number) => boolean;

                                                                                                              method lShiftTo

                                                                                                              lShiftTo: (n: number, r: BigInteger) => void;

                                                                                                                method max

                                                                                                                max: (a: BigInteger) => BigInteger;

                                                                                                                  method millerRabin

                                                                                                                  millerRabin: (t: number) => boolean;

                                                                                                                    method min

                                                                                                                    min: (a: BigInteger) => BigInteger;

                                                                                                                      method mod

                                                                                                                      mod: (a: BigInteger) => BigInteger;

                                                                                                                        method modInt

                                                                                                                        modInt: (n: number) => number;

                                                                                                                          method modInverse

                                                                                                                          modInverse: (m: BigInteger) => BigInteger;

                                                                                                                            method modPow

                                                                                                                            modPow: (e: BigInteger, m: BigInteger) => BigInteger;

                                                                                                                              method modPowInt

                                                                                                                              modPowInt: (e: number, m: BigInteger) => BigInteger;

                                                                                                                                method multiply

                                                                                                                                multiply: (a: BigInteger) => BigInteger;

                                                                                                                                  method multiplyLowerTo

                                                                                                                                  multiplyLowerTo: (a: BigInteger, n: number, r: BigInteger) => void;

                                                                                                                                    method multiplyTo

                                                                                                                                    multiplyTo: (a: BigInteger, r: BigInteger) => void;

                                                                                                                                      method multiplyUpperTo

                                                                                                                                      multiplyUpperTo: (a: BigInteger, n: number, r: BigInteger) => void;

                                                                                                                                        method negate

                                                                                                                                        negate: () => BigInteger;

                                                                                                                                          method not

                                                                                                                                          not: () => BigInteger;

                                                                                                                                            method or

                                                                                                                                            or: (a: BigInteger) => BigInteger;

                                                                                                                                              method pow

                                                                                                                                              pow: (e: number) => BigInteger;

                                                                                                                                                method remainder

                                                                                                                                                remainder: (a: BigInteger) => BigInteger;

                                                                                                                                                  method rShiftTo

                                                                                                                                                  rShiftTo: (n: number, r: BigInteger) => void;

                                                                                                                                                    method setBit

                                                                                                                                                    setBit: (n: number) => BigInteger;

                                                                                                                                                      method shiftLeft

                                                                                                                                                      shiftLeft: (n: number) => BigInteger;

                                                                                                                                                        method shiftRight

                                                                                                                                                        shiftRight: (n: number) => BigInteger;

                                                                                                                                                          method shortValue

                                                                                                                                                          shortValue: () => number;

                                                                                                                                                            method signum

                                                                                                                                                            signum: () => number;

                                                                                                                                                              method square

                                                                                                                                                              square: () => BigInteger;

                                                                                                                                                                method squareTo

                                                                                                                                                                squareTo: (r: BigInteger) => void;

                                                                                                                                                                  method subTo

                                                                                                                                                                  subTo: (a: BigInteger, r: BigInteger) => void;

                                                                                                                                                                    method subtract

                                                                                                                                                                    subtract: (a: BigInteger) => BigInteger;

                                                                                                                                                                      method testBit

                                                                                                                                                                      testBit: (n: number) => boolean;

                                                                                                                                                                        method toByteArray

                                                                                                                                                                        toByteArray: () => number[];

                                                                                                                                                                          method toRadix

                                                                                                                                                                          toRadix: (b: number) => string;

                                                                                                                                                                            method toString

                                                                                                                                                                            toString: (b?: number) => string;

                                                                                                                                                                              method xor

                                                                                                                                                                              xor: (a: BigInteger) => BigInteger;

                                                                                                                                                                                Interfaces

                                                                                                                                                                                interface RandomGenerator

                                                                                                                                                                                interface RandomGenerator {}

                                                                                                                                                                                  method nextBytes

                                                                                                                                                                                  nextBytes: (bytes: number[]) => void;

                                                                                                                                                                                    interface Reduction

                                                                                                                                                                                    interface Reduction {}

                                                                                                                                                                                      method convert

                                                                                                                                                                                      convert: (x: BigInteger) => BigInteger;

                                                                                                                                                                                        method mulTo

                                                                                                                                                                                        mulTo: (x: BigInteger, y: BigInteger, r: BigInteger) => void;

                                                                                                                                                                                          method reduce

                                                                                                                                                                                          reduce: (x: BigInteger) => void;

                                                                                                                                                                                            method revert

                                                                                                                                                                                            revert: (x: BigInteger) => BigInteger;

                                                                                                                                                                                              method sqrTo

                                                                                                                                                                                              sqrTo: (x: BigInteger, r: BigInteger) => void;

                                                                                                                                                                                                Package Files (1)

                                                                                                                                                                                                Dependencies (0)

                                                                                                                                                                                                No dependencies.

                                                                                                                                                                                                Dev Dependencies (0)

                                                                                                                                                                                                No dev dependencies.

                                                                                                                                                                                                Peer Dependencies (0)

                                                                                                                                                                                                No peer dependencies.

                                                                                                                                                                                                Badge

                                                                                                                                                                                                To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/jsbn.

                                                                                                                                                                                                • Markdown
                                                                                                                                                                                                  [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/jsbn)
                                                                                                                                                                                                • HTML
                                                                                                                                                                                                  <a href="https://www.jsdocs.io/package/@types/jsbn"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>