Telegram Web K with changes to work inside I2P
https://web.telegram.i2p/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
249 lines
6.5 KiB
249 lines
6.5 KiB
// Type definitions for jsbn v1.2.29 |
|
// Project: http://www-cs-students.stanford.edu/%7Etjw/jsbn/ |
|
// Definitions by: Eugene Chernyshov <https://github.com/Evgenus>, Al Tabayoyon <https://github.com/al2xed> |
|
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped |
|
|
|
export class SecureRandom { |
|
nextBytes(bytes: number[]): void; |
|
} |
|
|
|
export class BigInteger { |
|
constructor(a: number, c: SecureRandom); |
|
constructor(a: number, b: number, c: SecureRandom); |
|
constructor(a: string, b?: number); |
|
constructor(a: number[], b?: number); |
|
constructor(a: BigInteger); |
|
|
|
s: number; |
|
t: number; |
|
data: number[]; // forge specific |
|
|
|
DB: number; |
|
DM: number; |
|
DV: number; |
|
|
|
FV: number; |
|
F1: number; |
|
F2: number; |
|
|
|
// am: Compute w_j += (x*this_i), propagate carries, |
|
am(i: number, x: number, w: BigInteger, j: number, c: number, n: number): number; |
|
|
|
// (protected) copy this to r |
|
copyTo(r: BigInteger): void; |
|
|
|
// (protected) set from integer value x, -DV <= x < DV |
|
fromInt(x: number): void; |
|
|
|
// (protected) set from string and radix |
|
fromString(x: string, b: number): void; |
|
|
|
// (protected) clamp off excess high words |
|
clamp(): void; |
|
|
|
// (public) return string representation in given radix |
|
toString(b?: number): string; |
|
|
|
// (public) -this |
|
negate(): BigInteger; |
|
|
|
// (public) |this| |
|
abs(): BigInteger; |
|
|
|
// (public) return + if this > a, - if this < a, 0 if equal |
|
compareTo(a: BigInteger): number; |
|
|
|
// (public) return the number of bits in "this" |
|
bitLength(): number; |
|
|
|
// (protected) r = this << n*DB |
|
dlShiftTo(n: number, r: BigInteger): void; |
|
|
|
// (protected) r = this >> n*DB |
|
drShiftTo(n: number, r: BigInteger): void; |
|
|
|
// (protected) r = this << n |
|
lShiftTo(n: number, r: BigInteger): void; |
|
|
|
// (protected) r = this >> n |
|
rShiftTo(n: number, r: BigInteger): void; |
|
|
|
// (protected) r = this - a |
|
subTo(a: BigInteger, r: BigInteger): void; |
|
|
|
// (protected) r = this * a, r != this,a (HAC 14.12) |
|
multiplyTo(a: BigInteger, r: BigInteger): void; |
|
|
|
// (protected) r = this^2, r != this (HAC 14.16) |
|
squareTo(r: BigInteger): void; |
|
|
|
// (protected) divide this by m, quotient and remainder to q, r (HAC 14.20) |
|
// r != q, this != m. q or r may be null. |
|
divRemTo(m: BigInteger, q: BigInteger, r: BigInteger): void; |
|
|
|
// (public) this mod a |
|
mod(a: BigInteger): BigInteger; |
|
|
|
// (protected) return "-1/this % 2^DB"; useful for Mont. reduction |
|
invDigit(): number; |
|
|
|
// (protected) true iff this is even |
|
isEven(): boolean; |
|
|
|
// (protected) this^e, e < 2^32, doing sqr and mul with "r" (HAC 14.79) |
|
exp(e: number, z: Reduction): BigInteger; |
|
|
|
// (public) this^e % m, 0 <= e < 2^32 |
|
modPowInt(e: number, m: BigInteger): BigInteger; |
|
|
|
// (public) |
|
clone(): BigInteger; |
|
|
|
// (public) return value as integer |
|
intValue(): number; |
|
|
|
// (public) return value as byte |
|
byteValue(): number; |
|
|
|
// (public) return value as short (assumes DB>=16) |
|
shortValue(): number; |
|
|
|
// (protected) return x s.t. r^x < DV |
|
chunkSize(r: number): number; |
|
|
|
// (public) 0 if this == 0, 1 if this > 0 |
|
signum(): number; |
|
|
|
// (protected) convert to radix string |
|
toRadix(b: number): string; |
|
|
|
// (protected) convert from radix string |
|
fromRadix(s: string, b: number): void; |
|
|
|
// (protected) alternate constructor |
|
fromNumber(a: number, b?: number, c?: number): void; |
|
|
|
// (public) convert to bigendian byte array |
|
toByteArray(): number[]; |
|
|
|
equals(a: BigInteger): boolean; |
|
|
|
min(a: BigInteger): BigInteger; |
|
|
|
max(a: BigInteger): BigInteger; |
|
|
|
// (protected) r = this op a (bitwise) |
|
bitwiseTo(a: BigInteger, op: (x: number, y: number) => number, r: BigInteger): void; |
|
|
|
// (public) this & a |
|
and(a: BigInteger): BigInteger; |
|
|
|
// (public) this | a |
|
or(a: BigInteger): BigInteger; |
|
|
|
// (public) this ^ a |
|
xor(a: BigInteger): BigInteger; |
|
|
|
// (public) this & ~a |
|
andNot(a: BigInteger): BigInteger; |
|
|
|
// (public) ~this |
|
not(): BigInteger; |
|
|
|
// (public) this << n |
|
shiftLeft(n: number): BigInteger; |
|
|
|
// (public) this >> n |
|
shiftRight(n: number): BigInteger; |
|
|
|
// (public) returns index of lowest 1-bit (or -1 if none) |
|
getLowestSetBit(): number; |
|
|
|
// (public) return number of set bits |
|
bitCount(): number; |
|
|
|
// (public) true iff nth bit is set |
|
testBit(n: number): boolean; |
|
|
|
// (protected) this op (1<<n) |
|
changeBit(n: number, op: (x: number, y: number) => number): BigInteger; |
|
|
|
// (protected) this op (1<<n) |
|
setBit(n: number): BigInteger; |
|
|
|
// (public) this & ~(1<<n) |
|
clearBit(n: number): BigInteger |
|
|
|
// (public) this ^ (1<<n) |
|
flipBit(n: number): BigInteger |
|
|
|
// (protected) r = this + a |
|
addTo(a: BigInteger, r: BigInteger): void; |
|
|
|
// (public) this + a |
|
add(a: BigInteger): BigInteger; |
|
|
|
// (public) this - a |
|
subtract(a: BigInteger): BigInteger; |
|
|
|
// (public) this * a |
|
multiply(a: BigInteger): BigInteger; |
|
|
|
// (public) this^2 |
|
square(): BigInteger; |
|
|
|
// (public) this / a |
|
divide(a: BigInteger): BigInteger; |
|
|
|
// (public) this % a |
|
remainder(a: BigInteger): BigInteger; |
|
|
|
// (public) [this/a,this%a] |
|
divideAndRemainder(a: BigInteger): BigInteger[]; // Array of 2 items |
|
|
|
// (protected) this *= n, this >= 0, 1 < n < DV |
|
dMultiply(n: number): void; |
|
|
|
// (protected) this += n << w words, this >= 0 |
|
dAddOffset(n: number, w: number): void; |
|
|
|
// (public) this^e |
|
pow(e: number): BigInteger; |
|
|
|
// (protected) r = lower n words of "this * a", a.t <= n |
|
multiplyLowerTo(a: BigInteger, n: number, r: BigInteger): void; |
|
|
|
// (protected) r = "this * a" without lower n words, n > 0 |
|
multiplyUpperTo(a: BigInteger, n: number, r: BigInteger): void; |
|
|
|
// (public) this^e % m (HAC 14.85) |
|
modPow(e: BigInteger, m: BigInteger): BigInteger; |
|
|
|
// (public) gcd(this,a) (HAC 14.54) |
|
gcd(a: BigInteger): BigInteger; |
|
|
|
// (protected) this % n, n < 2^26 |
|
modInt(n: number): number; |
|
|
|
// (public) 1/this % m (HAC 14.61) |
|
modInverse(m: BigInteger): BigInteger; |
|
|
|
// (public) test primality with certainty >= 1-.5^t |
|
isProbablePrime(t: number): boolean; |
|
|
|
// (protected) true if probably prime (HAC 4.24, Miller-Rabin) |
|
millerRabin(t: number): boolean; |
|
|
|
static ZERO: BigInteger; |
|
static ONE: BigInteger; |
|
} |
|
|
|
export interface Reduction { |
|
convert(x: BigInteger): BigInteger; |
|
revert(x: BigInteger): BigInteger; |
|
reduce(x: BigInteger): void; |
|
mulTo(x: BigInteger, y: BigInteger, r: BigInteger): void; |
|
sqrTo(x: BigInteger, r: BigInteger): void; |
|
} |
|
|
|
export as namespace jsbn;
|
|
|