pixel-react 1.15.21 → 1.15.23

package/lib/node_modules/node-forge/lib/rc2.js

@@ -0,0 +1,382 @@
+import { __require as requireForge } from './forge.js';
+import { __require as requireUtil } from './util.js';
+
+/**
+ * RC2 implementation.
+ *
+ * @author Stefan Siegl
+ *
+ * Copyright (c) 2012 Stefan Siegl <stesie@brokenpipe.de>
+ *
+ * Information on the RC2 cipher is available from RFC #2268,
+ * http://www.ietf.org/rfc/rfc2268.txt
+ */
+var rc2;
+var hasRequiredRc2;
+function requireRc2() {
+  if (hasRequiredRc2) return rc2;
+  hasRequiredRc2 = 1;
+  var forge = requireForge();
+  requireUtil();
+  var piTable = [0xd9, 0x78, 0xf9, 0xc4, 0x19, 0xdd, 0xb5, 0xed, 0x28, 0xe9, 0xfd, 0x79, 0x4a, 0xa0, 0xd8, 0x9d, 0xc6, 0x7e, 0x37, 0x83, 0x2b, 0x76, 0x53, 0x8e, 0x62, 0x4c, 0x64, 0x88, 0x44, 0x8b, 0xfb, 0xa2, 0x17, 0x9a, 0x59, 0xf5, 0x87, 0xb3, 0x4f, 0x13, 0x61, 0x45, 0x6d, 0x8d, 0x09, 0x81, 0x7d, 0x32, 0xbd, 0x8f, 0x40, 0xeb, 0x86, 0xb7, 0x7b, 0x0b, 0xf0, 0x95, 0x21, 0x22, 0x5c, 0x6b, 0x4e, 0x82, 0x54, 0xd6, 0x65, 0x93, 0xce, 0x60, 0xb2, 0x1c, 0x73, 0x56, 0xc0, 0x14, 0xa7, 0x8c, 0xf1, 0xdc, 0x12, 0x75, 0xca, 0x1f, 0x3b, 0xbe, 0xe4, 0xd1, 0x42, 0x3d, 0xd4, 0x30, 0xa3, 0x3c, 0xb6, 0x26, 0x6f, 0xbf, 0x0e, 0xda, 0x46, 0x69, 0x07, 0x57, 0x27, 0xf2, 0x1d, 0x9b, 0xbc, 0x94, 0x43, 0x03, 0xf8, 0x11, 0xc7, 0xf6, 0x90, 0xef, 0x3e, 0xe7, 0x06, 0xc3, 0xd5, 0x2f, 0xc8, 0x66, 0x1e, 0xd7, 0x08, 0xe8, 0xea, 0xde, 0x80, 0x52, 0xee, 0xf7, 0x84, 0xaa, 0x72, 0xac, 0x35, 0x4d, 0x6a, 0x2a, 0x96, 0x1a, 0xd2, 0x71, 0x5a, 0x15, 0x49, 0x74, 0x4b, 0x9f, 0xd0, 0x5e, 0x04, 0x18, 0xa4, 0xec, 0xc2, 0xe0, 0x41, 0x6e, 0x0f, 0x51, 0xcb, 0xcc, 0x24, 0x91, 0xaf, 0x50, 0xa1, 0xf4, 0x70, 0x39, 0x99, 0x7c, 0x3a, 0x85, 0x23, 0xb8, 0xb4, 0x7a, 0xfc, 0x02, 0x36, 0x5b, 0x25, 0x55, 0x97, 0x31, 0x2d, 0x5d, 0xfa, 0x98, 0xe3, 0x8a, 0x92, 0xae, 0x05, 0xdf, 0x29, 0x10, 0x67, 0x6c, 0xba, 0xc9, 0xd3, 0x00, 0xe6, 0xcf, 0xe1, 0x9e, 0xa8, 0x2c, 0x63, 0x16, 0x01, 0x3f, 0x58, 0xe2, 0x89, 0xa9, 0x0d, 0x38, 0x34, 0x1b, 0xab, 0x33, 0xff, 0xb0, 0xbb, 0x48, 0x0c, 0x5f, 0xb9, 0xb1, 0xcd, 0x2e, 0xc5, 0xf3, 0xdb, 0x47, 0xe5, 0xa5, 0x9c, 0x77, 0x0a, 0xa6, 0x20, 0x68, 0xfe, 0x7f, 0xc1, 0xad];
+  var s = [1, 2, 3, 5];
+
+  /**
+   * Rotate a word left by given number of bits.
+   *
+   * Bits that are shifted out on the left are put back in on the right
+   * hand side.
+   *
+   * @param word The word to shift left.
+   * @param bits The number of bits to shift by.
+   * @return The rotated word.
+   */
+  var rol = function (word, bits) {
+    return word << bits & 0xffff | (word & 0xffff) >> 16 - bits;
+  };
+
+  /**
+   * Rotate a word right by given number of bits.
+   *
+   * Bits that are shifted out on the right are put back in on the left
+   * hand side.
+   *
+   * @param word The word to shift right.
+   * @param bits The number of bits to shift by.
+   * @return The rotated word.
+   */
+  var ror = function (word, bits) {
+    return (word & 0xffff) >> bits | word << 16 - bits & 0xffff;
+  };
+
+  /* RC2 API */
+  rc2 = forge.rc2 = forge.rc2 || {};
+
+  /**
+   * Perform RC2 key expansion as per RFC #2268, section 2.
+   *
+   * @param key variable-length user key (between 1 and 128 bytes)
+   * @param effKeyBits number of effective key bits (default: 128)
+   * @return the expanded RC2 key (ByteBuffer of 128 bytes)
+   */
+  forge.rc2.expandKey = function (key, effKeyBits) {
+    if (typeof key === 'string') {
+      key = forge.util.createBuffer(key);
+    }
+    effKeyBits = effKeyBits || 128;
+
+    /* introduce variables that match the names used in RFC #2268 */
+    var L = key;
+    var T = key.length();
+    var T1 = effKeyBits;
+    var T8 = Math.ceil(T1 / 8);
+    var TM = 0xff >> (T1 & 0x07);
+    var i;
+    for (i = T; i < 128; i++) {
+      L.putByte(piTable[L.at(i - 1) + L.at(i - T) & 0xff]);
+    }
+    L.setAt(128 - T8, piTable[L.at(128 - T8) & TM]);
+    for (i = 127 - T8; i >= 0; i--) {
+      L.setAt(i, piTable[L.at(i + 1) ^ L.at(i + T8)]);
+    }
+    return L;
+  };
+
+  /**
+   * Creates a RC2 cipher object.
+   *
+   * @param key the symmetric key to use (as base for key generation).
+   * @param bits the number of effective key bits.
+   * @param encrypt false for decryption, true for encryption.
+   *
+   * @return the cipher.
+   */
+  var createCipher = function (key, bits, encrypt) {
+    var _finish = false,
+      _input = null,
+      _output = null,
+      _iv = null;
+    var mixRound, mashRound;
+    var i,
+      j,
+      K = [];
+
+    /* Expand key and fill into K[] Array */
+    key = forge.rc2.expandKey(key, bits);
+    for (i = 0; i < 64; i++) {
+      K.push(key.getInt16Le());
+    }
+    if (encrypt) {
+      /**
+       * Perform one mixing round "in place".
+       *
+       * @param R Array of four words to perform mixing on.
+       */
+      mixRound = function (R) {
+        for (i = 0; i < 4; i++) {
+          R[i] += K[j] + (R[(i + 3) % 4] & R[(i + 2) % 4]) + (~R[(i + 3) % 4] & R[(i + 1) % 4]);
+          R[i] = rol(R[i], s[i]);
+          j++;
+        }
+      };
+
+      /**
+       * Perform one mashing round "in place".
+       *
+       * @param R Array of four words to perform mashing on.
+       */
+      mashRound = function (R) {
+        for (i = 0; i < 4; i++) {
+          R[i] += K[R[(i + 3) % 4] & 63];
+        }
+      };
+    } else {
+      /**
+       * Perform one r-mixing round "in place".
+       *
+       * @param R Array of four words to perform mixing on.
+       */
+      mixRound = function (R) {
+        for (i = 3; i >= 0; i--) {
+          R[i] = ror(R[i], s[i]);
+          R[i] -= K[j] + (R[(i + 3) % 4] & R[(i + 2) % 4]) + (~R[(i + 3) % 4] & R[(i + 1) % 4]);
+          j--;
+        }
+      };
+
+      /**
+       * Perform one r-mashing round "in place".
+       *
+       * @param R Array of four words to perform mashing on.
+       */
+      mashRound = function (R) {
+        for (i = 3; i >= 0; i--) {
+          R[i] -= K[R[(i + 3) % 4] & 63];
+        }
+      };
+    }
+
+    /**
+     * Run the specified cipher execution plan.
+     *
+     * This function takes four words from the input buffer, applies the IV on
+     * it (if requested) and runs the provided execution plan.
+     *
+     * The plan must be put together in form of a array of arrays.  Where the
+     * outer one is simply a list of steps to perform and the inner one needs
+     * to have two elements: the first one telling how many rounds to perform,
+     * the second one telling what to do (i.e. the function to call).
+     *
+     * @param {Array} plan The plan to execute.
+     */
+    var runPlan = function (plan) {
+      var R = [];
+
+      /* Get data from input buffer and fill the four words into R */
+      for (i = 0; i < 4; i++) {
+        var val = _input.getInt16Le();
+        if (_iv !== null) {
+          if (encrypt) {
+            /* We're encrypting, apply the IV first. */
+            val ^= _iv.getInt16Le();
+          } else {
+            /* We're decryption, keep cipher text for next block. */
+            _iv.putInt16Le(val);
+          }
+        }
+        R.push(val & 0xffff);
+      }
+
+      /* Reset global "j" variable as per spec. */
+      j = encrypt ? 0 : 63;
+
+      /* Run execution plan. */
+      for (var ptr = 0; ptr < plan.length; ptr++) {
+        for (var ctr = 0; ctr < plan[ptr][0]; ctr++) {
+          plan[ptr][1](R);
+        }
+      }
+
+      /* Write back result to output buffer. */
+      for (i = 0; i < 4; i++) {
+        if (_iv !== null) {
+          if (encrypt) {
+            /* We're encrypting in CBC-mode, feed back encrypted bytes into
+               IV buffer to carry it forward to next block. */
+            _iv.putInt16Le(R[i]);
+          } else {
+            R[i] ^= _iv.getInt16Le();
+          }
+        }
+        _output.putInt16Le(R[i]);
+      }
+    };
+
+    /* Create cipher object */
+    var cipher = null;
+    cipher = {
+      /**
+       * Starts or restarts the encryption or decryption process, whichever
+       * was previously configured.
+       *
+       * To use the cipher in CBC mode, iv may be given either as a string
+       * of bytes, or as a byte buffer.  For ECB mode, give null as iv.
+       *
+       * @param iv the initialization vector to use, null for ECB mode.
+       * @param output the output the buffer to write to, null to create one.
+       */
+      start: function (iv, output) {
+        if (iv) {
+          /* CBC mode */
+          if (typeof iv === 'string') {
+            iv = forge.util.createBuffer(iv);
+          }
+        }
+        _finish = false;
+        _input = forge.util.createBuffer();
+        _output = output || new forge.util.createBuffer();
+        _iv = iv;
+        cipher.output = _output;
+      },
+      /**
+       * Updates the next block.
+       *
+       * @param input the buffer to read from.
+       */
+      update: function (input) {
+        if (!_finish) {
+          // not finishing, so fill the input buffer with more input
+          _input.putBuffer(input);
+        }
+        while (_input.length() >= 8) {
+          runPlan([[5, mixRound], [1, mashRound], [6, mixRound], [1, mashRound], [5, mixRound]]);
+        }
+      },
+      /**
+       * Finishes encrypting or decrypting.
+       *
+       * @param pad a padding function to use, null for PKCS#7 padding,
+       *           signature(blockSize, buffer, decrypt).
+       *
+       * @return true if successful, false on error.
+       */
+      finish: function (pad) {
+        var rval = true;
+        if (encrypt) {
+          if (pad) {
+            rval = pad(8, _input, !encrypt);
+          } else {
+            // add PKCS#7 padding to block (each pad byte is the
+            // value of the number of pad bytes)
+            var padding = _input.length() === 8 ? 8 : 8 - _input.length();
+            _input.fillWithByte(padding, padding);
+          }
+        }
+        if (rval) {
+          // do final update
+          _finish = true;
+          cipher.update();
+        }
+        if (!encrypt) {
+          // check for error: input data not a multiple of block size
+          rval = _input.length() === 0;
+          if (rval) {
+            if (pad) {
+              rval = pad(8, _output, !encrypt);
+            } else {
+              // ensure padding byte count is valid
+              var len = _output.length();
+              var count = _output.at(len - 1);
+              if (count > len) {
+                rval = false;
+              } else {
+                // trim off padding bytes
+                _output.truncate(count);
+              }
+            }
+          }
+        }
+        return rval;
+      }
+    };
+    return cipher;
+  };
+
+  /**
+   * Creates an RC2 cipher object to encrypt data in ECB or CBC mode using the
+   * given symmetric key. The output will be stored in the 'output' member
+   * of the returned cipher.
+   *
+   * The key and iv may be given as a string of bytes or a byte buffer.
+   * The cipher is initialized to use 128 effective key bits.
+   *
+   * @param key the symmetric key to use.
+   * @param iv the initialization vector to use.
+   * @param output the buffer to write to, null to create one.
+   *
+   * @return the cipher.
+   */
+  forge.rc2.startEncrypting = function (key, iv, output) {
+    var cipher = forge.rc2.createEncryptionCipher(key, 128);
+    cipher.start(iv, output);
+    return cipher;
+  };
+
+  /**
+   * Creates an RC2 cipher object to encrypt data in ECB or CBC mode using the
+   * given symmetric key.
+   *
+   * The key may be given as a string of bytes or a byte buffer.
+   *
+   * To start encrypting call start() on the cipher with an iv and optional
+   * output buffer.
+   *
+   * @param key the symmetric key to use.
+   *
+   * @return the cipher.
+   */
+  forge.rc2.createEncryptionCipher = function (key, bits) {
+    return createCipher(key, bits, true);
+  };
+
+  /**
+   * Creates an RC2 cipher object to decrypt data in ECB or CBC mode using the
+   * given symmetric key. The output will be stored in the 'output' member
+   * of the returned cipher.
+   *
+   * The key and iv may be given as a string of bytes or a byte buffer.
+   * The cipher is initialized to use 128 effective key bits.
+   *
+   * @param key the symmetric key to use.
+   * @param iv the initialization vector to use.
+   * @param output the buffer to write to, null to create one.
+   *
+   * @return the cipher.
+   */
+  forge.rc2.startDecrypting = function (key, iv, output) {
+    var cipher = forge.rc2.createDecryptionCipher(key, 128);
+    cipher.start(iv, output);
+    return cipher;
+  };
+
+  /**
+   * Creates an RC2 cipher object to decrypt data in ECB or CBC mode using the
+   * given symmetric key.
+   *
+   * The key may be given as a string of bytes or a byte buffer.
+   *
+   * To start decrypting call start() on the cipher with an iv and optional
+   * output buffer.
+   *
+   * @param key the symmetric key to use.
+   *
+   * @return the cipher.
+   */
+  forge.rc2.createDecryptionCipher = function (key, bits) {
+    return createCipher(key, bits, false);
+  };
+  return rc2;
+}
+
+export { requireRc2 as __require };
+//# sourceMappingURL=rc2.js.map

package/lib/node_modules/node-forge/lib/rc2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rc2.js","sources":["../../../../node_modules/node-forge/lib/rc2.js"],"sourcesContent":["/**\n * RC2 implementation.\n *\n * @author Stefan Siegl\n *\n * Copyright (c) 2012 Stefan Siegl <stesie@brokenpipe.de>\n *\n * Information on the RC2 cipher is available from RFC #2268,\n * http://www.ietf.org/rfc/rfc2268.txt\n */\nvar forge = require('./forge');\nrequire('./util');\n\nvar piTable = [\n  0xd9, 0x78, 0xf9, 0xc4, 0x19, 0xdd, 0xb5, 0xed, 0x28, 0xe9, 0xfd, 0x79, 0x4a, 0xa0, 0xd8, 0x9d,\n  0xc6, 0x7e, 0x37, 0x83, 0x2b, 0x76, 0x53, 0x8e, 0x62, 0x4c, 0x64, 0x88, 0x44, 0x8b, 0xfb, 0xa2,\n  0x17, 0x9a, 0x59, 0xf5, 0x87, 0xb3, 0x4f, 0x13, 0x61, 0x45, 0x6d, 0x8d, 0x09, 0x81, 0x7d, 0x32,\n  0xbd, 0x8f, 0x40, 0xeb, 0x86, 0xb7, 0x7b, 0x0b, 0xf0, 0x95, 0x21, 0x22, 0x5c, 0x6b, 0x4e, 0x82,\n  0x54, 0xd6, 0x65, 0x93, 0xce, 0x60, 0xb2, 0x1c, 0x73, 0x56, 0xc0, 0x14, 0xa7, 0x8c, 0xf1, 0xdc,\n  0x12, 0x75, 0xca, 0x1f, 0x3b, 0xbe, 0xe4, 0xd1, 0x42, 0x3d, 0xd4, 0x30, 0xa3, 0x3c, 0xb6, 0x26,\n  0x6f, 0xbf, 0x0e, 0xda, 0x46, 0x69, 0x07, 0x57, 0x27, 0xf2, 0x1d, 0x9b, 0xbc, 0x94, 0x43, 0x03,\n  0xf8, 0x11, 0xc7, 0xf6, 0x90, 0xef, 0x3e, 0xe7, 0x06, 0xc3, 0xd5, 0x2f, 0xc8, 0x66, 0x1e, 0xd7,\n  0x08, 0xe8, 0xea, 0xde, 0x80, 0x52, 0xee, 0xf7, 0x84, 0xaa, 0x72, 0xac, 0x35, 0x4d, 0x6a, 0x2a,\n  0x96, 0x1a, 0xd2, 0x71, 0x5a, 0x15, 0x49, 0x74, 0x4b, 0x9f, 0xd0, 0x5e, 0x04, 0x18, 0xa4, 0xec,\n  0xc2, 0xe0, 0x41, 0x6e, 0x0f, 0x51, 0xcb, 0xcc, 0x24, 0x91, 0xaf, 0x50, 0xa1, 0xf4, 0x70, 0x39,\n  0x99, 0x7c, 0x3a, 0x85, 0x23, 0xb8, 0xb4, 0x7a, 0xfc, 0x02, 0x36, 0x5b, 0x25, 0x55, 0x97, 0x31,\n  0x2d, 0x5d, 0xfa, 0x98, 0xe3, 0x8a, 0x92, 0xae, 0x05, 0xdf, 0x29, 0x10, 0x67, 0x6c, 0xba, 0xc9,\n  0xd3, 0x00, 0xe6, 0xcf, 0xe1, 0x9e, 0xa8, 0x2c, 0x63, 0x16, 0x01, 0x3f, 0x58, 0xe2, 0x89, 0xa9,\n  0x0d, 0x38, 0x34, 0x1b, 0xab, 0x33, 0xff, 0xb0, 0xbb, 0x48, 0x0c, 0x5f, 0xb9, 0xb1, 0xcd, 0x2e,\n  0xc5, 0xf3, 0xdb, 0x47, 0xe5, 0xa5, 0x9c, 0x77, 0x0a, 0xa6, 0x20, 0x68, 0xfe, 0x7f, 0xc1, 0xad\n];\n\nvar s = [1, 2, 3, 5];\n\n/**\n * Rotate a word left by given number of bits.\n *\n * Bits that are shifted out on the left are put back in on the right\n * hand side.\n *\n * @param word The word to shift left.\n * @param bits The number of bits to shift by.\n * @return The rotated word.\n */\nvar rol = function(word, bits) {\n  return ((word << bits) & 0xffff) | ((word & 0xffff) >> (16 - bits));\n};\n\n/**\n * Rotate a word right by given number of bits.\n *\n * Bits that are shifted out on the right are put back in on the left\n * hand side.\n *\n * @param word The word to shift right.\n * @param bits The number of bits to shift by.\n * @return The rotated word.\n */\nvar ror = function(word, bits) {\n  return ((word & 0xffff) >> bits) | ((word << (16 - bits)) & 0xffff);\n};\n\n/* RC2 API */\nmodule.exports = forge.rc2 = forge.rc2 || {};\n\n/**\n * Perform RC2 key expansion as per RFC #2268, section 2.\n *\n * @param key variable-length user key (between 1 and 128 bytes)\n * @param effKeyBits number of effective key bits (default: 128)\n * @return the expanded RC2 key (ByteBuffer of 128 bytes)\n */\nforge.rc2.expandKey = function(key, effKeyBits) {\n  if(typeof key === 'string') {\n    key = forge.util.createBuffer(key);\n  }\n  effKeyBits = effKeyBits || 128;\n\n  /* introduce variables that match the names used in RFC #2268 */\n  var L = key;\n  var T = key.length();\n  var T1 = effKeyBits;\n  var T8 = Math.ceil(T1 / 8);\n  var TM = 0xff >> (T1 & 0x07);\n  var i;\n\n  for(i = T; i < 128; i++) {\n    L.putByte(piTable[(L.at(i - 1) + L.at(i - T)) & 0xff]);\n  }\n\n  L.setAt(128 - T8, piTable[L.at(128 - T8) & TM]);\n\n  for(i = 127 - T8; i >= 0; i--) {\n    L.setAt(i, piTable[L.at(i + 1) ^ L.at(i + T8)]);\n  }\n\n  return L;\n};\n\n/**\n * Creates a RC2 cipher object.\n *\n * @param key the symmetric key to use (as base for key generation).\n * @param bits the number of effective key bits.\n * @param encrypt false for decryption, true for encryption.\n *\n * @return the cipher.\n */\nvar createCipher = function(key, bits, encrypt) {\n  var _finish = false, _input = null, _output = null, _iv = null;\n  var mixRound, mashRound;\n  var i, j, K = [];\n\n  /* Expand key and fill into K[] Array */\n  key = forge.rc2.expandKey(key, bits);\n  for(i = 0; i < 64; i++) {\n    K.push(key.getInt16Le());\n  }\n\n  if(encrypt) {\n    /**\n     * Perform one mixing round \"in place\".\n     *\n     * @param R Array of four words to perform mixing on.\n     */\n    mixRound = function(R) {\n      for(i = 0; i < 4; i++) {\n        R[i] += K[j] + (R[(i + 3) % 4] & R[(i + 2) % 4]) +\n          ((~R[(i + 3) % 4]) & R[(i + 1) % 4]);\n        R[i] = rol(R[i], s[i]);\n        j++;\n      }\n    };\n\n    /**\n     * Perform one mashing round \"in place\".\n     *\n     * @param R Array of four words to perform mashing on.\n     */\n    mashRound = function(R) {\n      for(i = 0; i < 4; i++) {\n        R[i] += K[R[(i + 3) % 4] & 63];\n      }\n    };\n  } else {\n    /**\n     * Perform one r-mixing round \"in place\".\n     *\n     * @param R Array of four words to perform mixing on.\n     */\n    mixRound = function(R) {\n      for(i = 3; i >= 0; i--) {\n        R[i] = ror(R[i], s[i]);\n        R[i] -= K[j] + (R[(i + 3) % 4] & R[(i + 2) % 4]) +\n          ((~R[(i + 3) % 4]) & R[(i + 1) % 4]);\n        j--;\n      }\n    };\n\n    /**\n     * Perform one r-mashing round \"in place\".\n     *\n     * @param R Array of four words to perform mashing on.\n     */\n    mashRound = function(R) {\n      for(i = 3; i >= 0; i--) {\n        R[i] -= K[R[(i + 3) % 4] & 63];\n      }\n    };\n  }\n\n  /**\n   * Run the specified cipher execution plan.\n   *\n   * This function takes four words from the input buffer, applies the IV on\n   * it (if requested) and runs the provided execution plan.\n   *\n   * The plan must be put together in form of a array of arrays.  Where the\n   * outer one is simply a list of steps to perform and the inner one needs\n   * to have two elements: the first one telling how many rounds to perform,\n   * the second one telling what to do (i.e. the function to call).\n   *\n   * @param {Array} plan The plan to execute.\n   */\n  var runPlan = function(plan) {\n    var R = [];\n\n    /* Get data from input buffer and fill the four words into R */\n    for(i = 0; i < 4; i++) {\n      var val = _input.getInt16Le();\n\n      if(_iv !== null) {\n        if(encrypt) {\n          /* We're encrypting, apply the IV first. */\n          val ^= _iv.getInt16Le();\n        } else {\n          /* We're decryption, keep cipher text for next block. */\n          _iv.putInt16Le(val);\n        }\n      }\n\n      R.push(val & 0xffff);\n    }\n\n    /* Reset global \"j\" variable as per spec. */\n    j = encrypt ? 0 : 63;\n\n    /* Run execution plan. */\n    for(var ptr = 0; ptr < plan.length; ptr++) {\n      for(var ctr = 0; ctr < plan[ptr][0]; ctr++) {\n        plan[ptr][1](R);\n      }\n    }\n\n    /* Write back result to output buffer. */\n    for(i = 0; i < 4; i++) {\n      if(_iv !== null) {\n        if(encrypt) {\n          /* We're encrypting in CBC-mode, feed back encrypted bytes into\n             IV buffer to carry it forward to next block. */\n          _iv.putInt16Le(R[i]);\n        } else {\n          R[i] ^= _iv.getInt16Le();\n        }\n      }\n\n      _output.putInt16Le(R[i]);\n    }\n  };\n\n  /* Create cipher object */\n  var cipher = null;\n  cipher = {\n    /**\n     * Starts or restarts the encryption or decryption process, whichever\n     * was previously configured.\n     *\n     * To use the cipher in CBC mode, iv may be given either as a string\n     * of bytes, or as a byte buffer.  For ECB mode, give null as iv.\n     *\n     * @param iv the initialization vector to use, null for ECB mode.\n     * @param output the output the buffer to write to, null to create one.\n     */\n    start: function(iv, output) {\n      if(iv) {\n        /* CBC mode */\n        if(typeof iv === 'string') {\n          iv = forge.util.createBuffer(iv);\n        }\n      }\n\n      _finish = false;\n      _input = forge.util.createBuffer();\n      _output = output || new forge.util.createBuffer();\n      _iv = iv;\n\n      cipher.output = _output;\n    },\n\n    /**\n     * Updates the next block.\n     *\n     * @param input the buffer to read from.\n     */\n    update: function(input) {\n      if(!_finish) {\n        // not finishing, so fill the input buffer with more input\n        _input.putBuffer(input);\n      }\n\n      while(_input.length() >= 8) {\n        runPlan([\n            [ 5, mixRound ],\n            [ 1, mashRound ],\n            [ 6, mixRound ],\n            [ 1, mashRound ],\n            [ 5, mixRound ]\n          ]);\n      }\n    },\n\n    /**\n     * Finishes encrypting or decrypting.\n     *\n     * @param pad a padding function to use, null for PKCS#7 padding,\n     *           signature(blockSize, buffer, decrypt).\n     *\n     * @return true if successful, false on error.\n     */\n    finish: function(pad) {\n      var rval = true;\n\n      if(encrypt) {\n        if(pad) {\n          rval = pad(8, _input, !encrypt);\n        } else {\n          // add PKCS#7 padding to block (each pad byte is the\n          // value of the number of pad bytes)\n          var padding = (_input.length() === 8) ? 8 : (8 - _input.length());\n          _input.fillWithByte(padding, padding);\n        }\n      }\n\n      if(rval) {\n        // do final update\n        _finish = true;\n        cipher.update();\n      }\n\n      if(!encrypt) {\n        // check for error: input data not a multiple of block size\n        rval = (_input.length() === 0);\n        if(rval) {\n          if(pad) {\n            rval = pad(8, _output, !encrypt);\n          } else {\n            // ensure padding byte count is valid\n            var len = _output.length();\n            var count = _output.at(len - 1);\n\n            if(count > len) {\n              rval = false;\n            } else {\n              // trim off padding bytes\n              _output.truncate(count);\n            }\n          }\n        }\n      }\n\n      return rval;\n    }\n  };\n\n  return cipher;\n};\n\n/**\n * Creates an RC2 cipher object to encrypt data in ECB or CBC mode using the\n * given symmetric key. The output will be stored in the 'output' member\n * of the returned cipher.\n *\n * The key and iv may be given as a string of bytes or a byte buffer.\n * The cipher is initialized to use 128 effective key bits.\n *\n * @param key the symmetric key to use.\n * @param iv the initialization vector to use.\n * @param output the buffer to write to, null to create one.\n *\n * @return the cipher.\n */\nforge.rc2.startEncrypting = function(key, iv, output) {\n  var cipher = forge.rc2.createEncryptionCipher(key, 128);\n  cipher.start(iv, output);\n  return cipher;\n};\n\n/**\n * Creates an RC2 cipher object to encrypt data in ECB or CBC mode using the\n * given symmetric key.\n *\n * The key may be given as a string of bytes or a byte buffer.\n *\n * To start encrypting call start() on the cipher with an iv and optional\n * output buffer.\n *\n * @param key the symmetric key to use.\n *\n * @return the cipher.\n */\nforge.rc2.createEncryptionCipher = function(key, bits) {\n  return createCipher(key, bits, true);\n};\n\n/**\n * Creates an RC2 cipher object to decrypt data in ECB or CBC mode using the\n * given symmetric key. The output will be stored in the 'output' member\n * of the returned cipher.\n *\n * The key and iv may be given as a string of bytes or a byte buffer.\n * The cipher is initialized to use 128 effective key bits.\n *\n * @param key the symmetric key to use.\n * @param iv the initialization vector to use.\n * @param output the buffer to write to, null to create one.\n *\n * @return the cipher.\n */\nforge.rc2.startDecrypting = function(key, iv, output) {\n  var cipher = forge.rc2.createDecryptionCipher(key, 128);\n  cipher.start(iv, output);\n  return cipher;\n};\n\n/**\n * Creates an RC2 cipher object to decrypt data in ECB or CBC mode using the\n * given symmetric key.\n *\n * The key may be given as a string of bytes or a byte buffer.\n *\n * To start decrypting call start() on the cipher with an iv and optional\n * output buffer.\n *\n * @param key the symmetric key to use.\n *\n * @return the cipher.\n */\nforge.rc2.createDecryptionCipher = function(key, bits) {\n  return createCipher(key, bits, false);\n};\n"],"names":["forge","require$$0","require$$1","piTable","s","rol","word","bits","ror","rc2","expandKey","key","effKeyBits","util","createBuffer","L","T","length","T1","T8","Math","ceil","TM","i","putByte","at","setAt","createCipher","encrypt","_finish","_input","_output","_iv","mixRound","mashRound","j","K","push","getInt16Le","R","runPlan","plan","val","putInt16Le","ptr","ctr","cipher","start","iv","output","update","input","putBuffer","finish","pad","rval","padding","fillWithByte","len","count","truncate","startEncrypting","createEncryptionCipher","startDecrypting","createDecryptionCipher"],"mappings":";;;;;;;;;;;;;;;;;;AAUA,EAAA,IAAIA,KAAK,GAAGC,YAAA,EAAkB;AAC9BC,EAAAA,WAAA,EAAiB;AAEjB,EAAA,IAAIC,OAAO,GAAG,CACZ,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAC9F,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAC9F,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAC9F,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAC9F,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAC9F,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAC9F,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAC9F,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAC9F,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAC9F,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAC9F,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAC9F,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAC9F,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAC9F,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAC9F,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAC9F,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAA,CAC3F;EAED,IAAIC,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;;AAEpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA,IAAIC,GAAG,GAAG,UAASC,IAAI,EAAEC,IAAI,EAAE;AAC7B,IAAA,OAASD,IAAI,IAAIC,IAAI,GAAI,MAAM,GAAK,CAACD,IAAI,GAAG,MAAM,KAAM,EAAE,GAAGC,IAAM;EACrE,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA,IAAIC,GAAG,GAAG,UAASF,IAAI,EAAEC,IAAI,EAAE;AAC7B,IAAA,OAAQ,CAACD,IAAI,GAAG,MAAM,KAAKC,IAAI,GAAMD,IAAI,IAAK,EAAE,GAAGC,IAAK,GAAI,MAAO;EACrE,CAAC;;AAED;EACAE,GAAc,GAAGT,KAAK,CAACS,GAAG,GAAGT,KAAK,CAACS,GAAG,IAAI,EAAE;;AAE5C;AACA;AACA;AACA;AACA;AACA;AACA;EACAT,KAAK,CAACS,GAAG,CAACC,SAAS,GAAG,UAASC,GAAG,EAAEC,UAAU,EAAE;AAC9C,IAAA,IAAG,OAAOD,GAAG,KAAK,QAAQ,EAAE;MAC1BA,GAAG,GAAGX,KAAK,CAACa,IAAI,CAACC,YAAY,CAACH,GAAG,CAAC;AACtC,IAAA;IACEC,UAAU,GAAGA,UAAU,IAAI,GAAG;;AAEhC;IACE,IAAIG,CAAC,GAAGJ,GAAG;AACX,IAAA,IAAIK,CAAC,GAAGL,GAAG,CAACM,MAAM,EAAE;IACpB,IAAIC,EAAE,GAAGN,UAAU;IACnB,IAAIO,EAAE,GAAGC,IAAI,CAACC,IAAI,CAACH,EAAE,GAAG,CAAC,CAAC;AAC1B,IAAA,IAAII,EAAE,GAAG,IAAI,KAAKJ,EAAE,GAAG,IAAI,CAAC;AAC5B,IAAA,IAAIK,CAAC;IAEL,KAAIA,CAAC,GAAGP,CAAC,EAAEO,CAAC,GAAG,GAAG,EAAEA,CAAC,EAAE,EAAE;MACvBR,CAAC,CAACS,OAAO,CAACrB,OAAO,CAAEY,CAAC,CAACU,EAAE,CAACF,CAAC,GAAG,CAAC,CAAC,GAAGR,CAAC,CAACU,EAAE,CAACF,CAAC,GAAGP,CAAC,CAAC,GAAI,IAAI,CAAC,CAAC;AAC1D,IAAA;IAEED,CAAC,CAACW,KAAK,CAAC,GAAG,GAAGP,EAAE,EAAEhB,OAAO,CAACY,CAAC,CAACU,EAAE,CAAC,GAAG,GAAGN,EAAE,CAAC,GAAGG,EAAE,CAAC,CAAC;AAE/C,IAAA,KAAIC,CAAC,GAAG,GAAG,GAAGJ,EAAE,EAAEI,CAAC,IAAI,CAAC,EAAEA,CAAC,EAAE,EAAE;MAC7BR,CAAC,CAACW,KAAK,CAACH,CAAC,EAAEpB,OAAO,CAACY,CAAC,CAACU,EAAE,CAACF,CAAC,GAAG,CAAC,CAAC,GAAGR,CAAC,CAACU,EAAE,CAACF,CAAC,GAAGJ,EAAE,CAAC,CAAC,CAAC;AACnD,IAAA;AAEE,IAAA,OAAOJ,CAAC;EACV,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACA,IAAIY,YAAY,GAAG,UAAShB,GAAG,EAAEJ,IAAI,EAAEqB,OAAO,EAAE;IAC9C,IAAIC,OAAO,GAAG,KAAK;AAAEC,MAAAA,MAAM,GAAG,IAAI;AAAEC,MAAAA,OAAO,GAAG,IAAI;AAAEC,MAAAA,GAAG,GAAG,IAAI;IAC9D,IAAIC,QAAQ,EAAEC,SAAS;AACvB,IAAA,IAAIX,CAAC;MAAEY,CAAC;AAAEC,MAAAA,CAAC,GAAG,EAAE;;AAElB;IACEzB,GAAG,GAAGX,KAAK,CAACS,GAAG,CAACC,SAAS,CAACC,GAAG,EAAEJ,IAAI,CAAC;IACpC,KAAIgB,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAG,EAAE,EAAEA,CAAC,EAAE,EAAE;MACtBa,CAAC,CAACC,IAAI,CAAC1B,GAAG,CAAC2B,UAAU,EAAE,CAAC;AAC5B,IAAA;AAEE,IAAA,IAAGV,OAAO,EAAE;AACd;AACA;AACA;AACA;AACA;AACIK,MAAAA,QAAQ,GAAG,UAASM,CAAC,EAAE;QACrB,KAAIhB,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAG,CAAC,EAAEA,CAAC,EAAE,EAAE;UACrBgB,CAAC,CAAChB,CAAC,CAAC,IAAIa,CAAC,CAACD,CAAC,CAAC,IAAII,CAAC,CAAC,CAAChB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,GAAGgB,CAAC,CAAC,CAAChB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,IAC5C,CAACgB,CAAC,CAAC,CAAChB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,GAAIgB,CAAC,CAAC,CAAChB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;AACtCgB,UAAAA,CAAC,CAAChB,CAAC,CAAC,GAAGlB,GAAG,CAACkC,CAAC,CAAChB,CAAC,CAAC,EAAEnB,CAAC,CAACmB,CAAC,CAAC,CAAC;AACtBY,UAAAA,CAAC,EAAE;AACX,QAAA;MACA,CAAK;;AAEL;AACA;AACA;AACA;AACA;AACID,MAAAA,SAAS,GAAG,UAASK,CAAC,EAAE;QACtB,KAAIhB,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAG,CAAC,EAAEA,CAAC,EAAE,EAAE;AACrBgB,UAAAA,CAAC,CAAChB,CAAC,CAAC,IAAIa,CAAC,CAACG,CAAC,CAAC,CAAChB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,CAAC;AACtC,QAAA;MACA,CAAK;AACL,IAAA,CAAG,MAAM;AACT;AACA;AACA;AACA;AACA;AACIU,MAAAA,QAAQ,GAAG,UAASM,CAAC,EAAE;QACrB,KAAIhB,CAAC,GAAG,CAAC,EAAEA,CAAC,IAAI,CAAC,EAAEA,CAAC,EAAE,EAAE;AACtBgB,UAAAA,CAAC,CAAChB,CAAC,CAAC,GAAGf,GAAG,CAAC+B,CAAC,CAAChB,CAAC,CAAC,EAAEnB,CAAC,CAACmB,CAAC,CAAC,CAAC;UACtBgB,CAAC,CAAChB,CAAC,CAAC,IAAIa,CAAC,CAACD,CAAC,CAAC,IAAII,CAAC,CAAC,CAAChB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,GAAGgB,CAAC,CAAC,CAAChB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,IAC5C,CAACgB,CAAC,CAAC,CAAChB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,GAAIgB,CAAC,CAAC,CAAChB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;AACtCY,UAAAA,CAAC,EAAE;AACX,QAAA;MACA,CAAK;;AAEL;AACA;AACA;AACA;AACA;AACID,MAAAA,SAAS,GAAG,UAASK,CAAC,EAAE;QACtB,KAAIhB,CAAC,GAAG,CAAC,EAAEA,CAAC,IAAI,CAAC,EAAEA,CAAC,EAAE,EAAE;AACtBgB,UAAAA,CAAC,CAAChB,CAAC,CAAC,IAAIa,CAAC,CAACG,CAAC,CAAC,CAAChB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,CAAC;AACtC,QAAA;MACA,CAAK;AACL,IAAA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACE,IAAA,IAAIiB,OAAO,GAAG,UAASC,IAAI,EAAE;MAC3B,IAAIF,CAAC,GAAG,EAAE;;AAEd;MACI,KAAIhB,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAG,CAAC,EAAEA,CAAC,EAAE,EAAE;AACrB,QAAA,IAAImB,GAAG,GAAGZ,MAAM,CAACQ,UAAU,EAAE;QAE7B,IAAGN,GAAG,KAAK,IAAI,EAAE;AACf,UAAA,IAAGJ,OAAO,EAAE;AACpB;AACUc,YAAAA,GAAG,IAAIV,GAAG,CAACM,UAAU,EAAE;AACjC,UAAA,CAAS,MAAM;AACf;AACUN,YAAAA,GAAG,CAACW,UAAU,CAACD,GAAG,CAAC;AAC7B,UAAA;AACA,QAAA;AAEMH,QAAAA,CAAC,CAACF,IAAI,CAACK,GAAG,GAAG,MAAM,CAAC;AAC1B,MAAA;;AAEA;AACIP,MAAAA,CAAC,GAAGP,OAAO,GAAG,CAAC,GAAG,EAAE;;AAExB;AACI,MAAA,KAAI,IAAIgB,GAAG,GAAG,CAAC,EAAEA,GAAG,GAAGH,IAAI,CAACxB,MAAM,EAAE2B,GAAG,EAAE,EAAE;AACzC,QAAA,KAAI,IAAIC,GAAG,GAAG,CAAC,EAAEA,GAAG,GAAGJ,IAAI,CAACG,GAAG,CAAC,CAAC,CAAC,CAAC,EAAEC,GAAG,EAAE,EAAE;UAC1CJ,IAAI,CAACG,GAAG,CAAC,CAAC,CAAC,CAAC,CAACL,CAAC,CAAC;AACvB,QAAA;AACA,MAAA;;AAEA;MACI,KAAIhB,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAG,CAAC,EAAEA,CAAC,EAAE,EAAE;QACrB,IAAGS,GAAG,KAAK,IAAI,EAAE;AACf,UAAA,IAAGJ,OAAO,EAAE;AACpB;AACA;AACUI,YAAAA,GAAG,CAACW,UAAU,CAACJ,CAAC,CAAChB,CAAC,CAAC,CAAC;AAC9B,UAAA,CAAS,MAAM;YACLgB,CAAC,CAAChB,CAAC,CAAC,IAAIS,GAAG,CAACM,UAAU,EAAE;AAClC,UAAA;AACA,QAAA;AAEMP,QAAAA,OAAO,CAACY,UAAU,CAACJ,CAAC,CAAChB,CAAC,CAAC,CAAC;AAC9B,MAAA;IACA,CAAG;;AAEH;IACE,IAAIuB,MAAM,GAAG,IAAI;AACjBA,IAAAA,MAAM,GAAG;AACX;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACIC,MAAAA,KAAK,EAAE,UAASC,EAAE,EAAEC,MAAM,EAAE;AAC1B,QAAA,IAAGD,EAAE,EAAE;AACb;AACQ,UAAA,IAAG,OAAOA,EAAE,KAAK,QAAQ,EAAE;YACzBA,EAAE,GAAGhD,KAAK,CAACa,IAAI,CAACC,YAAY,CAACkC,EAAE,CAAC;AAC1C,UAAA;AACA,QAAA;AAEMnB,QAAAA,OAAO,GAAG,KAAK;AACfC,QAAAA,MAAM,GAAG9B,KAAK,CAACa,IAAI,CAACC,YAAY,EAAE;QAClCiB,OAAO,GAAGkB,MAAM,IAAI,IAAIjD,KAAK,CAACa,IAAI,CAACC,YAAY,EAAE;AACjDkB,QAAAA,GAAG,GAAGgB,EAAE;QAERF,MAAM,CAACG,MAAM,GAAGlB,OAAO;MAC7B,CAAK;AAEL;AACA;AACA;AACA;AACA;AACImB,MAAAA,MAAM,EAAE,UAASC,KAAK,EAAE;QACtB,IAAG,CAACtB,OAAO,EAAE;AACnB;AACQC,UAAAA,MAAM,CAACsB,SAAS,CAACD,KAAK,CAAC;AAC/B,QAAA;AAEM,QAAA,OAAMrB,MAAM,CAACb,MAAM,EAAE,IAAI,CAAC,EAAE;AAC1BuB,UAAAA,OAAO,CAAC,CACJ,CAAE,CAAC,EAAEP,QAAQ,CAAE,EACf,CAAE,CAAC,EAAEC,SAAS,CAAE,EAChB,CAAE,CAAC,EAAED,QAAQ,CAAE,EACf,CAAE,CAAC,EAAEC,SAAS,CAAE,EAChB,CAAE,CAAC,EAAED,QAAQ,CAAA,CACd,CAAC;AACZ,QAAA;MACA,CAAK;AAEL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACIoB,MAAAA,MAAM,EAAE,UAASC,GAAG,EAAE;QACpB,IAAIC,IAAI,GAAG,IAAI;AAEf,QAAA,IAAG3B,OAAO,EAAE;AACV,UAAA,IAAG0B,GAAG,EAAE;YACNC,IAAI,GAAGD,GAAG,CAAC,CAAC,EAAExB,MAAM,EAAE,CAACF,OAAO,CAAC;AACzC,UAAA,CAAS,MAAM;AACf;AACA;AACU,YAAA,IAAI4B,OAAO,GAAI1B,MAAM,CAACb,MAAM,EAAE,KAAK,CAAC,GAAI,CAAC,GAAI,CAAC,GAAGa,MAAM,CAACb,MAAM,EAAG;AACjEa,YAAAA,MAAM,CAAC2B,YAAY,CAACD,OAAO,EAAEA,OAAO,CAAC;AAC/C,UAAA;AACA,QAAA;AAEM,QAAA,IAAGD,IAAI,EAAE;AACf;AACQ1B,UAAAA,OAAO,GAAG,IAAI;UACdiB,MAAM,CAACI,MAAM,EAAE;AACvB,QAAA;QAEM,IAAG,CAACtB,OAAO,EAAE;AACnB;AACQ2B,UAAAA,IAAI,GAAIzB,MAAM,CAACb,MAAM,EAAE,KAAK,CAAE;AAC9B,UAAA,IAAGsC,IAAI,EAAE;AACP,YAAA,IAAGD,GAAG,EAAE;cACNC,IAAI,GAAGD,GAAG,CAAC,CAAC,EAAEvB,OAAO,EAAE,CAACH,OAAO,CAAC;AAC5C,YAAA,CAAW,MAAM;AACjB;AACY,cAAA,IAAI8B,GAAG,GAAG3B,OAAO,CAACd,MAAM,EAAE;cAC1B,IAAI0C,KAAK,GAAG5B,OAAO,CAACN,EAAE,CAACiC,GAAG,GAAG,CAAC,CAAC;cAE/B,IAAGC,KAAK,GAAGD,GAAG,EAAE;AACdH,gBAAAA,IAAI,GAAG,KAAK;AAC1B,cAAA,CAAa,MAAM;AACnB;AACcxB,gBAAAA,OAAO,CAAC6B,QAAQ,CAACD,KAAK,CAAC;AACrC,cAAA;AACA,YAAA;AACA,UAAA;AACA,QAAA;AAEM,QAAA,OAAOJ,IAAI;AACjB,MAAA;KACG;AAED,IAAA,OAAOT,MAAM;EACf,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACA9C,KAAK,CAACS,GAAG,CAACoD,eAAe,GAAG,UAASlD,GAAG,EAAEqC,EAAE,EAAEC,MAAM,EAAE;IACpD,IAAIH,MAAM,GAAG9C,KAAK,CAACS,GAAG,CAACqD,sBAAsB,CAACnD,GAAG,EAAE,GAAG,CAAC;AACvDmC,IAAAA,MAAM,CAACC,KAAK,CAACC,EAAE,EAAEC,MAAM,CAAC;AACxB,IAAA,OAAOH,MAAM;EACf,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACA9C,KAAK,CAACS,GAAG,CAACqD,sBAAsB,GAAG,UAASnD,GAAG,EAAEJ,IAAI,EAAE;AACrD,IAAA,OAAOoB,YAAY,CAAChB,GAAG,EAAEJ,IAAI,EAAE,IAAI,CAAC;EACtC,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACAP,KAAK,CAACS,GAAG,CAACsD,eAAe,GAAG,UAASpD,GAAG,EAAEqC,EAAE,EAAEC,MAAM,EAAE;IACpD,IAAIH,MAAM,GAAG9C,KAAK,CAACS,GAAG,CAACuD,sBAAsB,CAACrD,GAAG,EAAE,GAAG,CAAC;AACvDmC,IAAAA,MAAM,CAACC,KAAK,CAACC,EAAE,EAAEC,MAAM,CAAC;AACxB,IAAA,OAAOH,MAAM;EACf,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACA9C,KAAK,CAACS,GAAG,CAACuD,sBAAsB,GAAG,UAASrD,GAAG,EAAEJ,IAAI,EAAE;AACrD,IAAA,OAAOoB,YAAY,CAAChB,GAAG,EAAEJ,IAAI,EAAE,KAAK,CAAC;EACvC,CAAC;;;;;;","x_google_ignoreList":[0]}