web-dc-api 0.0.58 → 0.0.60

package/dist/esm/node_modules/jscrypto/es6/DES3.js

@@ -0,0 +1,120 @@
+import { SerializableCipher } from './lib/algorithm/cipher/SerializableCipher.js';
+import { BlockCipher } from './lib/algorithm/cipher/BlockCipher.js';
+import { Cipher } from './lib/algorithm/cipher/Cipher.js';
+import { DES } from './DES.js';
+import { Word32Array } from './lib/Word32Array.js';
+import { PasswordBasedCipher } from './lib/algorithm/cipher/PasswordBasedCipher.js';
+
+class DES3 extends BlockCipher {
+  constructor(props) {
+    super(props);
+    this._blockSize = 64 / 32;
+    this._props = props;
+    const TripleDES = this._get3DES();
+    // Create DES instances
+    this._des1 = TripleDES[0];
+    this._des2 = TripleDES[1];
+    this._des3 = TripleDES[2];
+  }
+  _get3DES() {
+    // Shortcuts
+    const key = this._key;
+    const keyWords = key.words;
+    // Make sure the key length is valid (64, 128 or >= 192 bit)
+    if (keyWords.length !== 2 && keyWords.length !== 4 && keyWords.length < 6) {
+      throw new Error("Invalid key length - 3DES requires the key length to be 64, 128, 192 or >192.");
+    }
+    // Extend the key according to the keying options defined in 3DES standard
+    const key1 = keyWords.slice(0, 2);
+    const key2 = keyWords.length < 4 ? keyWords.slice(0, 2) : keyWords.slice(2, 4);
+    const key3 = keyWords.length < 6 ? keyWords.slice(0, 2) : keyWords.slice(4, 6);
+    // Create DES instances
+    const des1 = DES.createEncryptor(new Word32Array(key1));
+    const des2 = DES.createEncryptor(new Word32Array(key2));
+    const des3 = DES.createEncryptor(new Word32Array(key3));
+    return [des1, des2, des3];
+  }
+  _doReset() {
+    const TripleDES = this._get3DES();
+    // Create DES instances
+    this._des1 = TripleDES[0];
+    this._des2 = TripleDES[1];
+    this._des3 = TripleDES[2];
+  }
+  encryptBlock(words, offset) {
+    this._des1.encryptBlock(words, offset);
+    this._des2.decryptBlock(words, offset);
+    this._des3.encryptBlock(words, offset);
+  }
+  decryptBlock(words, offset) {
+    this._des3.decryptBlock(words, offset);
+    this._des2.encryptBlock(words, offset);
+    this._des1.decryptBlock(words, offset);
+  }
+  /**
+   * Creates this cipher in encryption mode.
+   *
+   * @param {Word32Array} key The key.
+   * @param {Partial<CipherProps>?} props (Optional) The configuration options to use for this operation.
+   * @return {Cipher} A cipher instance.
+   * @example
+   *   var cipher = DES3.createEncryptor(keyWordArray, { iv: ivWordArray });
+   */
+  static createEncryptor(key, props) {
+    props = typeof props === "undefined" ? {} : props;
+    return new DES3(Object.assign(Object.assign({}, props), {
+      key,
+      transformMode: Cipher.ENC_TRANSFORM_MODE
+    }));
+  }
+  /**
+   * Creates this cipher in decryption mode.
+   *
+   * @param {Word32Array} key The key.
+   * @param {Partial<CipherProps>?} props (Optional) The configuration options to use for this operation.
+   * @return {Cipher} A cipher instance.
+   * @example
+   *   var cipher = DES3.createDecryptor(keyWordArray, { iv: ivWordArray });
+   */
+  static createDecryptor(key, props) {
+    props = typeof props === "undefined" ? {} : props;
+    return new DES3(Object.assign(Object.assign({}, props), {
+      key,
+      transformMode: Cipher.DEC_TRANSFORM_MODE
+    }));
+  }
+  /**
+   * Encrypt a message with key
+   *
+   * @param {Word32Array|string} message
+   * @param {Word32Array|string} key
+   * @param {Partial<AESProps>?} props
+   * @example
+   *   var encryptedMessage = DES3.encrypt("test", "pass");
+   */
+  static encrypt(message, key, props) {
+    if (typeof key === "string") {
+      return PasswordBasedCipher.encrypt(DES3, message, key, props);
+    }
+    return SerializableCipher.encrypt(DES3, message, key, props);
+  }
+  /**
+   * Encrypt a encrypted message with key
+   *
+   * @param {CipherParams} cipherText
+   * @param {Word32Array|string} key
+   * @param {Partial<AESProps>?} props
+   * @example
+   *   var encryptedMessage = DES3.decrypt(cipherProps, "pass");
+   */
+  static decrypt(cipherText, key, props) {
+    if (typeof key === "string") {
+      return PasswordBasedCipher.decrypt(DES3, cipherText, key, props);
+    }
+    return SerializableCipher.decrypt(DES3, cipherText, key, props);
+  }
+}
+DES3.keySize = 192 / 32;
+DES3.ivSize = 64 / 32;
+
+export { DES3 };

package/dist/esm/node_modules/jscrypto/es6/GMAC.js

@@ -0,0 +1,15 @@
+import { Utf8 } from './lib/encoder/Utf8.js';
+import { Word32Array } from './lib/Word32Array.js';
+import { AES } from './AES.js';
+import { GCM } from './lib/algorithm/cipher/mode/GCM.js';
+
+function GMAC(message, key, iv, tagLength, props) {
+  const aad = typeof message === "string" ? Utf8.parse(message) : message;
+  const initializingVector = iv ? iv : new Word32Array([0, 0, 0, 0]);
+  const Cipher = props && props.Cipher ? props.Cipher : AES;
+  const wKey = typeof key === "string" ? Utf8.parse(key) : key;
+  const t = tagLength || 16;
+  return GCM.mac(Cipher, wKey, initializingVector, aad, undefined, t);
+}
+
+export { GMAC };

package/dist/esm/node_modules/jscrypto/es6/Hmac.js

@@ -0,0 +1,72 @@
+import { Utf8 } from './lib/encoder/Utf8.js';
+
+class Hmac {
+  constructor(hasher, key) {
+    this._hasher = hasher;
+    // Convert string to WordArray, else assume WordArray already
+    if (typeof key == "string") {
+      key = Utf8.parse(key);
+    }
+    const hasherBlockSize = hasher.blockSize;
+    const hasherBlockSizeBytes = hasherBlockSize * 4;
+    // Allow arbitrary length keys
+    if (key.nSigBytes > hasherBlockSizeBytes) {
+      key = hasher.finalize(key);
+    }
+    // Clamp excess bits
+    key.clamp();
+    const oKey = this._oKey = key.clone();
+    const iKey = this._iKey = key.clone();
+    const oKeyWords = oKey.words;
+    const iKeyWords = iKey.words;
+    for (let i = 0; i < hasherBlockSize; i++) {
+      oKeyWords[i] ^= 0x5c5c5c5c;
+      iKeyWords[i] ^= 0x36363636;
+    }
+    iKey.nSigBytes = hasherBlockSizeBytes;
+    oKey.nSigBytes = hasherBlockSizeBytes;
+    // Set initial values
+    this.reset();
+  }
+  /**
+   * Resets this Hmac to its initial state.
+   *
+   * @example
+   *   hmacHasher.reset();
+   */
+  reset() {
+    this._hasher.reset();
+    this._hasher.update(this._iKey);
+  }
+  /**
+   * Updates this Hmac with a message.
+   *
+   * @param {Word32Array|string} messageUpdate The message to append.
+   * @return {Hmac} This Hmac instance.
+   * @example
+   *   hmacHasher.update('message');
+   *   hmacHasher.update(wordArray);
+   */
+  update(messageUpdate) {
+    this._hasher.update(messageUpdate);
+    return this;
+  }
+  /**
+   * Finalizes the Hmac computation.
+   * Note that the finalize operation is effectively a destructive, read-once operation.
+   *
+   * @param {Word32Array|string} messageUpdate (Optional) A final message update.
+   * @return {Word32Array} The Hmac.
+   * @example
+   *   var hmac = hmacHasher.finalize();
+   *   var hmac = hmacHasher.finalize('message');
+   *   var hmac = hmacHasher.finalize(wordArray);
+   */
+  finalize(messageUpdate) {
+    const innerHash = this._hasher.finalize(messageUpdate);
+    this._hasher.reset();
+    return this._hasher.finalize(this._oKey.clone().concat(innerHash));
+  }
+}
+
+export { Hmac };

package/dist/esm/node_modules/jscrypto/es6/HmacMD5.js

@@ -0,0 +1,8 @@
+import { Hmac } from './Hmac.js';
+import { MD5 } from './MD5.js';
+
+function HmacMD5(message, key) {
+  return new Hmac(new MD5(), key).finalize(message);
+}
+
+export { HmacMD5 };

package/dist/esm/node_modules/jscrypto/es6/HmacSHA1.js

@@ -0,0 +1,8 @@
+import { Hmac } from './Hmac.js';
+import { SHA1 } from './SHA1.js';
+
+function HmacSHA1(message, key) {
+  return new Hmac(new SHA1(), key).finalize(message);
+}
+
+export { HmacSHA1 };

package/dist/esm/node_modules/jscrypto/es6/HmacSHA224.js

@@ -0,0 +1,8 @@
+import { Hmac } from './Hmac.js';
+import { SHA224 } from './SHA224.js';
+
+function HmacSHA224(message, key) {
+  return new Hmac(new SHA224(), key).finalize(message);
+}
+
+export { HmacSHA224 };

package/dist/esm/node_modules/jscrypto/es6/HmacSHA256.js

@@ -0,0 +1,8 @@
+import { Hmac } from './Hmac.js';
+import { SHA256 } from './SHA256.js';
+
+function HmacSHA256(message, key) {
+  return new Hmac(new SHA256(), key).finalize(message);
+}
+
+export { HmacSHA256 };

package/dist/esm/node_modules/jscrypto/es6/HmacSHA384.js

@@ -0,0 +1,8 @@
+import { Hmac } from './Hmac.js';
+import { SHA384 } from './SHA384.js';
+
+function HmacSHA384(message, key) {
+  return new Hmac(new SHA384(), key).finalize(message);
+}
+
+export { HmacSHA384 };

package/dist/esm/node_modules/jscrypto/es6/HmacSHA512.js

@@ -0,0 +1,8 @@
+import { Hmac } from './Hmac.js';
+import { SHA512 } from './SHA512.js';
+
+function HmacSHA512(message, key) {
+  return new Hmac(new SHA512(), key).finalize(message);
+}
+
+export { HmacSHA512 };

package/dist/esm/node_modules/jscrypto/es6/MD5.js

@@ -0,0 +1,184 @@
+import { Word32Array } from './lib/Word32Array.js';
+import { Hasher } from './lib/algorithm/Hasher.js';
+
+// Constants table
+const T = [];
+(function computeConstant() {
+  for (let i = 0; i < 64; i++) {
+    T[i] = Math.abs(Math.sin(i + 1)) * 0x100000000 | 0;
+  }
+})();
+function FF(a, b, c, d, x, s, t) {
+  const n = a + (b & c | ~b & d) + x + t;
+  return (n << s | n >>> 32 - s) + b;
+}
+function GG(a, b, c, d, x, s, t) {
+  const n = a + (b & d | c & ~d) + x + t;
+  return (n << s | n >>> 32 - s) + b;
+}
+function HH(a, b, c, d, x, s, t) {
+  const n = a + (b ^ c ^ d) + x + t;
+  return (n << s | n >>> 32 - s) + b;
+}
+function II(a, b, c, d, x, s, t) {
+  const n = a + (c ^ (b | ~d)) + x + t;
+  return (n << s | n >>> 32 - s) + b;
+}
+/**
+ * MD5 hash algorithm
+ */
+class MD5 extends Hasher {
+  constructor(props) {
+    super(props);
+    this._hash = new Word32Array([0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476]);
+    if (props && typeof props.hash !== "undefined") {
+      this._hash = props.hash.clone();
+    }
+  }
+  _doReset() {
+    this._hash = new Word32Array([0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476]);
+  }
+  _doProcessBlock(words, offset) {
+    // Swap endian
+    for (let i = 0; i < 16; i++) {
+      // Shortcuts
+      const offsetI = offset + i;
+      const wordsOffsetI = words[offsetI];
+      words[offsetI] = (wordsOffsetI << 8 | wordsOffsetI >>> 24) & 0x00ff00ff | (wordsOffsetI << 24 | wordsOffsetI >>> 8) & 0xff00ff00;
+    }
+    // Shortcuts
+    const H = this._hash.words;
+    const wordOffset0 = words[offset];
+    const wordOffset1 = words[offset + 1];
+    const wordOffset2 = words[offset + 2];
+    const wordOffset3 = words[offset + 3];
+    const wordOffset4 = words[offset + 4];
+    const wordOffset5 = words[offset + 5];
+    const wordOffset6 = words[offset + 6];
+    const wordOffset7 = words[offset + 7];
+    const wordOffset8 = words[offset + 8];
+    const wordOffset9 = words[offset + 9];
+    const wordOffset10 = words[offset + 10];
+    const wordOffset11 = words[offset + 11];
+    const wordOffset12 = words[offset + 12];
+    const wordOffset13 = words[offset + 13];
+    const wordOffset14 = words[offset + 14];
+    const wordOffset15 = words[offset + 15];
+    // Working variables
+    let a = H[0];
+    let b = H[1];
+    let c = H[2];
+    let d = H[3];
+    // Computation
+    a = FF(a, b, c, d, wordOffset0, 7, T[0]);
+    d = FF(d, a, b, c, wordOffset1, 12, T[1]);
+    c = FF(c, d, a, b, wordOffset2, 17, T[2]);
+    b = FF(b, c, d, a, wordOffset3, 22, T[3]);
+    a = FF(a, b, c, d, wordOffset4, 7, T[4]);
+    d = FF(d, a, b, c, wordOffset5, 12, T[5]);
+    c = FF(c, d, a, b, wordOffset6, 17, T[6]);
+    b = FF(b, c, d, a, wordOffset7, 22, T[7]);
+    a = FF(a, b, c, d, wordOffset8, 7, T[8]);
+    d = FF(d, a, b, c, wordOffset9, 12, T[9]);
+    c = FF(c, d, a, b, wordOffset10, 17, T[10]);
+    b = FF(b, c, d, a, wordOffset11, 22, T[11]);
+    a = FF(a, b, c, d, wordOffset12, 7, T[12]);
+    d = FF(d, a, b, c, wordOffset13, 12, T[13]);
+    c = FF(c, d, a, b, wordOffset14, 17, T[14]);
+    b = FF(b, c, d, a, wordOffset15, 22, T[15]);
+    a = GG(a, b, c, d, wordOffset1, 5, T[16]);
+    d = GG(d, a, b, c, wordOffset6, 9, T[17]);
+    c = GG(c, d, a, b, wordOffset11, 14, T[18]);
+    b = GG(b, c, d, a, wordOffset0, 20, T[19]);
+    a = GG(a, b, c, d, wordOffset5, 5, T[20]);
+    d = GG(d, a, b, c, wordOffset10, 9, T[21]);
+    c = GG(c, d, a, b, wordOffset15, 14, T[22]);
+    b = GG(b, c, d, a, wordOffset4, 20, T[23]);
+    a = GG(a, b, c, d, wordOffset9, 5, T[24]);
+    d = GG(d, a, b, c, wordOffset14, 9, T[25]);
+    c = GG(c, d, a, b, wordOffset3, 14, T[26]);
+    b = GG(b, c, d, a, wordOffset8, 20, T[27]);
+    a = GG(a, b, c, d, wordOffset13, 5, T[28]);
+    d = GG(d, a, b, c, wordOffset2, 9, T[29]);
+    c = GG(c, d, a, b, wordOffset7, 14, T[30]);
+    b = GG(b, c, d, a, wordOffset12, 20, T[31]);
+    a = HH(a, b, c, d, wordOffset5, 4, T[32]);
+    d = HH(d, a, b, c, wordOffset8, 11, T[33]);
+    c = HH(c, d, a, b, wordOffset11, 16, T[34]);
+    b = HH(b, c, d, a, wordOffset14, 23, T[35]);
+    a = HH(a, b, c, d, wordOffset1, 4, T[36]);
+    d = HH(d, a, b, c, wordOffset4, 11, T[37]);
+    c = HH(c, d, a, b, wordOffset7, 16, T[38]);
+    b = HH(b, c, d, a, wordOffset10, 23, T[39]);
+    a = HH(a, b, c, d, wordOffset13, 4, T[40]);
+    d = HH(d, a, b, c, wordOffset0, 11, T[41]);
+    c = HH(c, d, a, b, wordOffset3, 16, T[42]);
+    b = HH(b, c, d, a, wordOffset6, 23, T[43]);
+    a = HH(a, b, c, d, wordOffset9, 4, T[44]);
+    d = HH(d, a, b, c, wordOffset12, 11, T[45]);
+    c = HH(c, d, a, b, wordOffset15, 16, T[46]);
+    b = HH(b, c, d, a, wordOffset2, 23, T[47]);
+    a = II(a, b, c, d, wordOffset0, 6, T[48]);
+    d = II(d, a, b, c, wordOffset7, 10, T[49]);
+    c = II(c, d, a, b, wordOffset14, 15, T[50]);
+    b = II(b, c, d, a, wordOffset5, 21, T[51]);
+    a = II(a, b, c, d, wordOffset12, 6, T[52]);
+    d = II(d, a, b, c, wordOffset3, 10, T[53]);
+    c = II(c, d, a, b, wordOffset10, 15, T[54]);
+    b = II(b, c, d, a, wordOffset1, 21, T[55]);
+    a = II(a, b, c, d, wordOffset8, 6, T[56]);
+    d = II(d, a, b, c, wordOffset15, 10, T[57]);
+    c = II(c, d, a, b, wordOffset6, 15, T[58]);
+    b = II(b, c, d, a, wordOffset13, 21, T[59]);
+    a = II(a, b, c, d, wordOffset4, 6, T[60]);
+    d = II(d, a, b, c, wordOffset11, 10, T[61]);
+    c = II(c, d, a, b, wordOffset2, 15, T[62]);
+    b = II(b, c, d, a, wordOffset9, 21, T[63]);
+    // Intermediate hash value
+    H[0] = H[0] + a | 0;
+    H[1] = H[1] + b | 0;
+    H[2] = H[2] + c | 0;
+    H[3] = H[3] + d | 0;
+  }
+  _doFinalize() {
+    // Shortcuts
+    const data = this._data;
+    const dataWords = data.words;
+    const nBitsTotal = this._nBytes * 8;
+    const nBitsLeft = data.nSigBytes * 8;
+    // Add padding
+    dataWords[nBitsLeft >>> 5] |= 0x80 << 24 - nBitsLeft % 32;
+    const nBitsTotalH = Math.floor(nBitsTotal / 0x100000000);
+    const nBitsTotalL = nBitsTotal;
+    dataWords[(nBitsLeft + 64 >>> 9 << 4) + 15] = (nBitsTotalH << 8 | nBitsTotalH >>> 24) & 0x00ff00ff | (nBitsTotalH << 24 | nBitsTotalH >>> 8) & 0xff00ff00;
+    dataWords[(nBitsLeft + 64 >>> 9 << 4) + 14] = (nBitsTotalL << 8 | nBitsTotalL >>> 24) & 0x00ff00ff | (nBitsTotalL << 24 | nBitsTotalL >>> 8) & 0xff00ff00;
+    data.nSigBytes = (dataWords.length + 1) * 4;
+    // Hash final blocks
+    this._process();
+    // Shortcuts
+    const hash = this._hash;
+    const H = hash.words;
+    // Swap endian
+    for (let i = 0; i < 4; i++) {
+      // Shortcut
+      const Hi = H[i];
+      H[i] = (Hi << 8 | Hi >>> 24) & 0x00ff00ff | (Hi << 24 | Hi >>> 8) & 0xff00ff00;
+    }
+    // Return final computed hash
+    return hash;
+  }
+  clone() {
+    const props = {
+      hash: this._hash,
+      blockSize: this._blockSize,
+      data: this._data,
+      nBytes: this._nBytes
+    };
+    return new MD5(props);
+  }
+  static hash(message) {
+    return new MD5().finalize(message);
+  }
+}
+
+export { MD5 };

package/dist/esm/node_modules/jscrypto/es6/RC4.js

@@ -0,0 +1,125 @@
+import { StreamCipher } from './lib/algorithm/cipher/StreamCipher.js';
+import { PasswordBasedCipher } from './lib/algorithm/cipher/PasswordBasedCipher.js';
+import { SerializableCipher } from './lib/algorithm/cipher/SerializableCipher.js';
+
+class RC4 extends StreamCipher {
+  constructor(props) {
+    super(props);
+    this.S = [];
+    this.i = 0;
+    this.j = 0;
+    this._props = props;
+    this._doReset();
+  }
+  _doReset() {
+    // Shortcuts
+    const key = this._key;
+    const keyWords = key.words;
+    const keySigBytes = key.nSigBytes;
+    // Init sbox
+    this.S = [];
+    for (let i = 0; i < 256; i++) {
+      this.S[i] = i;
+    }
+    // Key setup
+    for (let i = 0, j = 0; i < 256; i++) {
+      const keyByteIndex = i % keySigBytes;
+      const keyByte = keyWords[keyByteIndex >>> 2] >>> 24 - keyByteIndex % 4 * 8 & 0xff;
+      j = (j + this.S[i] + keyByte) % 256;
+      // Swap
+      const t = this.S[i];
+      this.S[i] = this.S[j];
+      this.S[j] = t;
+    }
+    // Counters
+    this.i = this.j = 0;
+  }
+  _doProcessBlock(words, offset) {
+    words[offset] ^= this.generateKeyStreamWord();
+  }
+  generateKeyStreamWord() {
+    // Shortcuts
+    const S = this.S;
+    let i = this.i;
+    let j = this.j;
+    // Generate keyStream word
+    let keyStreamWord = 0;
+    for (let n = 0; n < 4; n++) {
+      i = (i + 1) % 256;
+      j = (j + S[i]) % 256;
+      // Swap
+      const t = S[i];
+      S[i] = S[j];
+      S[j] = t;
+      keyStreamWord |= S[(S[i] + S[j]) % 256] << 24 - n * 8;
+    }
+    // Update counters
+    this.i = i;
+    this.j = j;
+    return keyStreamWord;
+  }
+  /**
+   * Creates this cipher in encryption mode.
+   *
+   * @param {Word32Array} key The key.
+   * @param {Partial<CipherProps>?} props (Optional) The configuration options to use for this operation.
+   * @return {Cipher} A cipher instance.
+   * @example
+   *   var cipher = RC4.createEncryptor(keyWordArray);
+   */
+  static createEncryptor(key, props) {
+    props = typeof props === "undefined" ? {} : props;
+    return new RC4(Object.assign(Object.assign({}, props), {
+      key
+    }));
+  }
+  /**
+   * Creates this cipher in decryption mode.
+   *
+   * @param {Word32Array} key The key.
+   * @param {Partial<CipherProps>?} props (Optional) The configuration options to use for this operation.
+   * @return {Cipher} A cipher instance.
+   * @example
+   *   var cipher = RC4.createDecryptor(keyWordArray, { iv: ivWordArray });
+   */
+  static createDecryptor(key, props) {
+    props = typeof props === "undefined" ? {} : props;
+    return new RC4(Object.assign(Object.assign({}, props), {
+      key
+    }));
+  }
+  /**
+   * Encrypt a message with key
+   *
+   * @param {Word32Array|string} message
+   * @param {Word32Array|string} key
+   * @param {Partial<AESProps>?} props
+   * @example
+   *   var encryptedMessage = RC4.encrypt("test", "pass");
+   */
+  static encrypt(message, key, props) {
+    if (typeof key === "string") {
+      return PasswordBasedCipher.encrypt(RC4, message, key, props);
+    }
+    return SerializableCipher.encrypt(RC4, message, key, props);
+  }
+  /**
+   * Encrypt a encrypted message with key
+   *
+   * @param {CipherParams} cipherText
+   * @param {Word32Array|string} key
+   * @param {Partial<AESProps>?} props
+   * @example
+   *   var encryptedMessage = RC4.decrypt(cipherProps, "pass");
+   */
+  static decrypt(cipherText, key, props) {
+    if (typeof key === "string") {
+      return PasswordBasedCipher.decrypt(RC4, cipherText, key, props);
+    }
+    return SerializableCipher.decrypt(RC4, cipherText, key, props);
+  }
+}
+RC4.ivSize = 0;
+RC4.keySize = 256 / 32;
+
+export { RC4 };

package/dist/esm/node_modules/jscrypto/es6/RC4Drop.js

@@ -0,0 +1,84 @@
+import { PasswordBasedCipher } from './lib/algorithm/cipher/PasswordBasedCipher.js';
+import { SerializableCipher } from './lib/algorithm/cipher/SerializableCipher.js';
+import { RC4 } from './RC4.js';
+
+class RC4Drop extends RC4 {
+  constructor(props) {
+    super(props);
+    this.drop = 192;
+    this._props = props;
+    if (props && typeof props.drop === "number") {
+      this.drop = props.drop;
+    }
+    this._doReset();
+  }
+  _doReset() {
+    super._doReset();
+    // Drop
+    for (let i = this.drop; i > 0; i--) {
+      this.generateKeyStreamWord();
+    }
+  }
+  /**
+   * Creates this cipher in encryption mode.
+   *
+   * @param {Word32Array} key The key.
+   * @param {Partial<CipherProps>?} props (Optional) The configuration options to use for this operation.
+   * @return {Cipher} A cipher instance.
+   * @example
+   *   var cipher = RC4Drop.createEncryptor(keyWordArray);
+   */
+  static createEncryptor(key, props) {
+    props = typeof props === "undefined" ? {} : props;
+    return new RC4Drop(Object.assign(Object.assign({}, props), {
+      key
+    }));
+  }
+  /**
+   * Creates this cipher in decryption mode.
+   *
+   * @param {Word32Array} key The key.
+   * @param {Partial<CipherProps>?} props (Optional) The configuration options to use for this operation.
+   * @return {Cipher} A cipher instance.
+   * @example
+   *   var cipher = RC4Drop.createDecryptor(keyWordArray, { iv: ivWordArray });
+   */
+  static createDecryptor(key, props) {
+    props = typeof props === "undefined" ? {} : props;
+    return new RC4Drop(Object.assign(Object.assign({}, props), {
+      key
+    }));
+  }
+  /**
+   * Encrypt a message with key
+   *
+   * @param {Word32Array|string} message
+   * @param {Word32Array|string} key
+   * @param {Partial<AESProps>?} props
+   * @example
+   *   var encryptedMessage = RC4Drop.encrypt("test", "pass");
+   */
+  static encrypt(message, key, props) {
+    if (typeof key === "string") {
+      return PasswordBasedCipher.encrypt(RC4Drop, message, key, props);
+    }
+    return SerializableCipher.encrypt(RC4Drop, message, key, props);
+  }
+  /**
+   * Encrypt a encrypted message with key
+   *
+   * @param {CipherParams} cipherText
+   * @param {Word32Array|string} key
+   * @param {Partial<AESProps>?} props
+   * @example
+   *   var encryptedMessage = RC4Drop.decrypt(cipherProps, "pass");
+   */
+  static decrypt(cipherText, key, props) {
+    if (typeof key === "string") {
+      return PasswordBasedCipher.decrypt(RC4Drop, cipherText, key, props);
+    }
+    return SerializableCipher.decrypt(RC4Drop, cipherText, key, props);
+  }
+}
+
+export { RC4Drop };