@zohocorporation/vault-cli 1.1.2

package/out/old/PasswordGenerator.js

@@ -0,0 +1,718 @@
+//$Id$
+import chalk from 'chalk';
+//ignorei18n_start
+/*
+export const PasswordGenerator = {
+  alphaLower: null,
+  alphaUpper: null,
+  numeric: null,
+  spclChar: null
+};
+
+PasswordGenerator.init = function (notReqChars) {
+  let aLower = "abcdefghijklmnopqrstuvwxyz";
+  let aUpper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+  let num = "0123456789";
+  let sChar = "!#$%&()*+,-.:;<=>?@[]^_{|}~";
+
+  for (var i = 0; i < notReqChars.length; i++) {
+    if (aLower.indexOf(notReqChars[i]) >= 0) {
+      aLower = aLower.replace(notReqChars[i], "");
+    }
+    if (aUpper.indexOf(notReqChars[i]) >= 0) {
+      aUpper = aUpper.replace(notReqChars[i], "");
+    }
+    if (num.indexOf(notReqChars[i]) >= 0) {
+      num = num.replace(notReqChars[i], "");
+    }
+    if (sChar.indexOf(notReqChars[i]) >= 0) {
+      sChar = sChar.replace(notReqChars[i], "");
+    }
+  }
+
+  PasswordGenerator.alphaLower = aLower.split("");
+  PasswordGenerator.alphaUpper = aUpper.split("");
+  PasswordGenerator.numeric = num.split("");
+  PasswordGenerator.spclChar = sChar.split("");
+};
+
+/**
+ * To get the password length. It returns a random password length between minLen and maxLen.
+ *
+ * @param   minLen    minimum required length of the password
+ * @param   maxLen    maximum required length of the password
+ * @return            the calculated length which should be >= minLen and <= maxLen.
+ *
+PasswordGenerator.getPasswordLength = function (minLen, maxLen) {
+  let passLen = getRandomNumber(maxLen);
+  while (passLen < minLen) {
+    passLen += maxLen - minLen;
+  }
+  return passLen;
+};
+
+/**
+ * To generate the password as per the rule defined in specified password rule ID (prId). The rule will be obtained from the server and then
+ * the password will be generated at client browser.
+ *
+ * @param   prId    Password Rule ID
+ * @return          Generated password
+ *
+PasswordGenerator.generate = function (el) {
+  let generatedPasswd;
+  let policyid = el
+    .parent()
+    .closest("form")
+    .find("select[name='policyid']")
+    .val();
+  if (typeof policyid === "undefined") {
+    $.ajax({
+      url: "/tools/passwdPolicies.do",
+      type: "POST",
+      data: { opParam: "GetDefaultPasswordPolicy", zvrcsr: getCSRFCookie() },
+      async: false,
+      cache: false,
+      success: function (data) {
+        var opResult = data;
+        if (opResult.opStatus == "success") {
+          var passwdRule = opResult.opMsg;
+          var isPasswdOK = false;
+          var notReqChar = passwdRule.NOTREQCHARS
+            ? passwdRule.NOTREQCHARS.split("")
+            : "";
+          PasswordGenerator.init(notReqChar);
+          //while(!isPasswdOK) {
+          generatedPasswd = PasswordGenerator.generatePassword(
+            passwdRule.MINLENGTH,
+            passwdRule.MAXLENGTH,
+            passwdRule.REQMIXEDCASE,
+            passwdRule.REQSPCLCHAR,
+            passwdRule.NUMOFSPCLCHAR,
+            passwdRule.BEGINWITHLETTER,
+            passwdRule.REQNUMERALS
+          );
+          //isPasswdOK = PasswordGenerator.isPasswdNotReqChar(notReqChar, generatedPasswd);
+          //}
+        } else {
+          alert(opResult.opMsg);
+          generatedPasswd = null;
+        }
+      }
+    });
+  } else {
+    var policyObj = policies[policyid];
+    var notReqChar = policyObj.NOTREQCHARS
+      ? policyObj.NOTREQCHARS.split("")
+      : "";
+    PasswordGenerator.init(notReqChar);
+    generatedPasswd = PasswordGenerator.generatePassword(
+      policyObj.MINLENGTH,
+      policyObj.MAXLENGTH,
+      policyObj.REQMIXEDCASE,
+      policyObj.REQSPCLCHAR,
+      policyObj.NUMOFSPCLCHAR,
+      policyObj.BEGINWITHLETTER,
+      policyObj.REQNUMERALS
+    );
+  }
+  return generatedPasswd;
+};
+
+PasswordGenerator.isPasswdNotReqChar = function (notReqChar, passwd) {
+  for (let i = 0; i < notReqChar.length; i++) {
+    if (passwd.indexOf(notReqChar[i]) >= 0) {
+      return false;
+    }
+  }
+  return true;
+};
+
+/**
+ * To generate the password: Same like PMP.
+ *
+ * @param    minLen             minimum required length of the password
+ * @param    maxLen             maximum required length of the password
+ * @param    reqMixedCase       boolean value to specify whether the password should contain mixed case characters or not
+ * @param    reqSpclChar        boolean value to specify whether the password should contain special characters or not
+ * @param    spclCharCount      if applicable, minimum number of special characters to be included in the password
+ * @param    startWithLetter    boolean value to specify whether the password should start with a letter or not
+ * @param    reqNumerals        boolean value to specify whether the password should contain numerals or not
+ * @return                      the generated passowrd
+ *
+
+PasswordGenerator.generatePassword = function (
+  minLen,
+  maxLen,
+  reqMixedCase,
+  reqSpclChar,
+  spclCharCount,
+  startWithLetter,
+  reqNumerals
+) {
+  let passMinLength = 0;
+  if (reqMixedCase) {
+    passMinLength = 2;
+  } else if (startWithLetter) {
+    passMinLength = 1;
+  }
+  if (reqNumerals) {
+    passMinLength++;
+  }
+  if (reqSpclChar) {
+    passMinLength = passMinLength + spclCharCount;
+  }
+  if (minLen < passMinLength) {
+    minLen = passMinLength;
+  }
+  if (maxLen < passMinLength) {
+    minLen = maxLen;
+  }
+  const passLen = PasswordGenerator.getPasswordLength(minLen, maxLen);
+  let password = "";
+  let iCount = 0;
+
+  let types = reqSpclChar && spclCharCount > 0 ? 3 : 2;
+  let spclCharsAdded = 0;
+  let toggleCase = false;
+  let mixedCount = 0;
+  // Generate the password
+  for (let i = 0; i < passLen; i++) {
+    var arrayId = 0;
+    if (i === 0 && startWithLetter) {
+      arrayId = 0;
+    } else if (reqNumerals) {
+      reqNumerals = false;
+      arrayId = 1;
+    } else if (reqMixedCase && mixedCount === 0) {
+      arrayId = 0;
+      mixedCount++;
+    } else if (reqSpclChar && spclCharCount > 0) {
+      if (spclCharsAdded < spclCharCount) {
+        if (passLen - i === spclCharCount - spclCharsAdded) {
+          arrayId = 2;
+        } else {
+          arrayId = getArrayIdRandomly(types);
+        }
+      } else {
+        types = 2;
+      }
+    } else {
+      arrayId = getArrayIdRandomly(types);
+    }
+
+    switch (arrayId) {
+      case 0: {
+        const alphaLowerIdx = getRandomNumber(
+          PasswordGenerator.alphaLower.length
+        );
+        const alphaUpperIdx = getRandomNumber(
+          PasswordGenerator.alphaUpper.length
+        );
+        let character;
+        if (reqMixedCase) {
+          // This depends on the no. of chars included in the password !
+          if (i === 0) {
+            password += PasswordGenerator.alphaLower[alphaLowerIdx];
+          } else {
+            let charCase = getRandomNumber(2);
+            if (iCount === 0) {
+              charCase = 0;
+            } else {
+              if (toggleCase === false) {
+                charCase = 1;
+                toggleCase = true;
+              }
+            }
+            if (charCase === 0) {
+              character = PasswordGenerator.alphaUpper[alphaUpperIdx];
+              if (
+                password.length > 1 &&
+                checkCurrentAndPreviousCharacter(
+                  character,
+                  password.charAt(password.length - 1)
+                )
+              ) {
+                if (alphaUpperIdx - 3 >= 0) {
+                  character = PasswordGenerator.alphaUpper[alphaUpperIdx - 3];
+                } else if (
+                  alphaLowerIdx + 3 <
+                  PasswordGenerator.alphaUpper.length
+                ) {
+                  character = PasswordGenerator.alphaUpper[alphaUpperIdx + 3];
+                }
+              }
+              password += character;
+              iCount++;
+            } else {
+              character = PasswordGenerator.alphaLower[alphaLowerIdx];
+              if (
+                password.length > 1 &&
+                checkCurrentAndPreviousCharacter(
+                  character,
+                  password.charAt(password.length - 1)
+                )
+              ) {
+                if (alphaLowerIdx - 3 >= 0) {
+                  character = PasswordGenerator.alphaLower[alphaLowerIdx - 3];
+                } else if (
+                  alphaLowerIdx + 3 <
+                  PasswordGenerator.alphaLower.length
+                ) {
+                  character = PasswordGenerator.alphaLower[alphaLowerIdx + 3];
+                }
+              }
+              password += character;
+            }
+          }
+        } else {
+          character = PasswordGenerator.alphaLower[alphaLowerIdx];
+          if (
+            password.length > 1 &&
+            checkCurrentAndPreviousCharacter(
+              character,
+              password.charAt(password.length - 1)
+            )
+          ) {
+            if (alphaLowerIdx - 3 >= 0) {
+              character = PasswordGenerator.alphaLower[alphaLowerIdx - 3];
+            } else if (
+              alphaLowerIdx + 3 <
+              PasswordGenerator.alphaLower.length
+            ) {
+              character = PasswordGenerator.alphaLower[alphaLowerIdx + 3];
+            }
+          }
+          password += character;
+        }
+        break;
+      }
+      case 1: {
+        let numIdx = getRandomNumber(PasswordGenerator.numeric.length);
+        let number = PasswordGenerator.numeric[numIdx];
+        //this condition is checked to prevent password from having having continous or repitition number such as 66 or 123.
+        if (
+          password.length > 1 &&
+          checkCurrentAndPreviousCharacter(
+            number,
+            password.charAt(password.length - 1)
+          )
+        ) {
+          if (numIdx - 3 >= 0) {
+            number = PasswordGenerator.numeric[numIdx - 3];
+          } else if (numIdx + 3 < PasswordGenerator.numeric.length) {
+            number = PasswordGenerator.numeric[numIdx + 3];
+          }
+        }
+        password += number;
+        break;
+      }
+      case 2: {
+        var spclCharIdx = getRandomNumber(PasswordGenerator.spclChar.length);
+        var special = PasswordGenerator.spclChar[spclCharIdx];
+        if (
+          password.length > 1 &&
+          checkCurrentAndPreviousCharacter(
+            special,
+            password.charAt(password.length - 1)
+          )
+        ) {
+          if (spclCharIdx - 3 >= 0) {
+            special = PasswordGenerator.spclChar[spclCharIdx - 3];
+          } else if (spclCharIdx + 3 < PasswordGenerator.spclChar.length) {
+            special = PasswordGenerator.spclChar[spclCharIdx + 3];
+          }
+        }
+        password += special;
+        spclCharsAdded++;
+        break;
+      }
+    }
+  }
+  return password;
+};
+//check wether current character and previous character are same or consecutive eg.rr or 123
+function checkCurrentAndPreviousCharacter(currentChar, previousChar) {
+  const specialChar = [
+    "!",
+    "@",
+    "#",
+    "$",
+    "%",
+    "^",
+    "&",
+    "*",
+    "(",
+    ")",
+    "-",
+    "="
+  ];
+  try {
+    let prevType;
+    let curType;
+    if (
+      PasswordGenerator.alphaUpper.indexOf(previousChar) > -1 ||
+      PasswordGenerator.alphaLower.indexOf(previousChar) > -1
+    ) {
+      prevType = "char";
+    }
+    if (
+      PasswordGenerator.alphaUpper.indexOf(currentChar) > -1 ||
+      PasswordGenerator.alphaLower.indexOf(currentChar) > -1
+    ) {
+      curType = "char";
+    }
+    if (PasswordGenerator.numeric.indexOf(previousChar) > -1) {
+      prevType = "int";
+    }
+    if (PasswordGenerator.numeric.indexOf(currentChar) > -1) {
+      curType = "int";
+    }
+    if (PasswordGenerator.spclChar.indexOf(previousChar) > -1) {
+      prevType = "special";
+    }
+    if (PasswordGenerator.spclChar.indexOf(currentChar) > -1) {
+      curType = "special";
+    }
+    if (prevType !== undefined && curType !== undefined) {
+      if (prevType === curType) {
+        switch (prevType) {
+          case "char":
+            if (
+              previousChar.toLowerCase() === currentChar.toLowerCase() ||
+              previousChar.toLowerCase().charCodeAt(0) + 1 ===
+                currentChar.toLowerCase().charCodeAt(0) ||
+              previousChar.toLowerCase().charCodeAt(0) ===
+                currentChar.toLowerCase().charCodeAt(0) + 1
+            ) {
+              return true;
+            }
+            break;
+          case "int":
+            if (
+              previousChar === currentChar ||
+              previousChar.charCodeAt(0) + 1 === currentChar.charCodeAt(0) ||
+              previousChar.charCodeAt(0) === currentChar.charCodeAt(0) + 1
+            ) {
+              return true;
+            }
+            break;
+          case "special":
+            if (
+              previousChar === currentChar ||
+              (specialChar.indexOf(previousChar) > -1 &&
+                specialChar.indexOf(currentChar) > -1 &&
+                specialChar.indexOf(previousChar) + 1 ===
+                  specialChar.indexOf(currentChar)) ||
+              (specialChar.indexOf(previousChar) > -1 &&
+                specialChar.indexOf(currentChar) > -1 &&
+                specialChar.indexOf(previousChar) ===
+                  specialChar.indexOf(currentChar) + 1)
+            ) {
+              return true;
+            }
+            break;
+        }
+      }
+    }
+  } catch (er) {}
+  return false;
+}
+/*   Generic functions related to Password Policy   */
+/**
+ * To get a random number in JavaScript. It expects a +ve number as parameter and returns any random number between 0 and the limit value.
+ * If the generated random number equals to the limit then it returns (generated_value - 1) as it should be lesser than the limit.
+ *
+ * @param limit     A +ve number specifying the limit under which the random number to be generated.
+ *
+function getRandomNumber(limit) {
+  var rand = Math.floor(Math.random() * limit);
+  return rand < limit ? rand : rand - 1;
+}
+
+/**
+ * To get the random array ID. This ID will help in randomly choosing the array to use.
+ *
+ * @param type  Types of arrays can be used. Expected value: 2 or 3.
+ *              If 3, the special char array will also be included otherwise only alpha and numeric array will be included
+ *
+function getArrayIdRandomly(type) {
+  // We do not need to check the validity of special char array as
+  // 1. if it is to be used, it will not be empty
+  // 2. if it is NOT to be used then the random number will generate only 0 or 1 (type will be 2)
+  // Thus the random array ID will be verified only for alpha and numeric arrays, i.e., only for random ID 0 or 1.
+  var aryId = getRandomNumber(type);
+  if (aryId === 0) {
+    if (PasswordGenerator.alphaLower.length === 0) {
+      // Alpha array is empty, check and get either for numeric or special char randomly
+      if (PasswordGenerator.numeric.length === 0) {
+        // Numeric array is also empty so, only special char array which must not be empty in this case, can be used
+        return 2; // Special char array
+      } else {
+        return 1; // Numeric array
+      }
+    }
+    return aryId;
+  } else if (aryId === 1) {
+    if (PasswordGenerator.numeric.length === 0) {
+      // Numeric array is empty, check and get either for alpha or special char randomly
+      if (PasswordGenerator.alphaLower.length === 0) {
+        // Alpha array is also empty so, only special char array which must not be empty in this case, can be used
+        return 2; // Special char array
+      } else {
+        return 0; // Alpha array
+      }
+    }
+  }
+  // aryId can be 2 only if special char needed and hence the array will not empty.
+  return aryId;
+}
+*/
+// var crypto = require('crypto')
+import * as crypto from "crypto";
+import { I18N } from '../js/I18n/index.js';
+let i18nText = new I18N();
+export class PasswordOptions {
+    constructor(len, specialCharacterCount, includeUpperCase, includeLowerCase, excludeCharacter, includeNumbers, startWithLetter) {
+        this.len = len;
+        this.noOfSpl = specialCharacterCount;
+        this.needLower = includeLowerCase;
+        this.needUpper = includeUpperCase;
+        this.needNum = includeNumbers;
+        this.needSpl = specialCharacterCount == 0 ? false : true;
+        this.firstLower = startWithLetter === undefined ? ((includeLowerCase || includeUpperCase) ? true : false) : startWithLetter;
+        this.excludeChars = excludeCharacter;
+    }
+}
+PasswordOptions.LENGTH = "len";
+PasswordOptions.REQ_LOWER = "needLower";
+PasswordOptions.REQ_UPPER = "needUpper";
+PasswordOptions.REQ_NUM = "needNum";
+PasswordOptions.REQ_SPL = "needSpl";
+PasswordOptions.NO_OF_SPL = "noOfSpl";
+PasswordOptions.START_WITH_LETTER = "firstLower";
+PasswordOptions.EXCLUDE_CHARS = "excludeChars";
+class _PasswordGenerator {
+    constructor() {
+        this.CHARSET_TYPE = {
+            LOWER: 0,
+            UPPER: 1,
+            NUM: 2,
+            SPL: 3
+        };
+        this.CHARSET = {
+            [this.CHARSET_TYPE.LOWER]: "abcdefghijklmnopqrstuvwxyz",
+            [this.CHARSET_TYPE.UPPER]: "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
+            [this.CHARSET_TYPE.NUM]: "0123456789",
+            [this.CHARSET_TYPE.SPL]: "~!@#$%^&*()-_+=|\\{}[];:'\",.<>/?"
+        };
+    }
+    /**
+     * @param {PasswordOptions} options
+     * @returns {string}
+     */
+    generatePassword(options) {
+        let uniqueexcludeString = [...new Set(options.excludeChars)].join('');
+        let len = '';
+        len = options.needLower ? len + this.CHARSET[0] : len;
+        len = options.needUpper ? len + this.CHARSET[1] : len;
+        len = options.needNum ? len + this.CHARSET[2] : len;
+        function check(char) {
+            return !(uniqueexcludeString.includes(char));
+        }
+        if (len.split('').filter(check).length === 0) {
+            console.log(chalk.red.bold(i18nText.getI18nMsg("vault.generator.excludeChar")));
+            process.exit(1);
+        }
+        return this.correct(this.shuffleF(this.processTemplate(this.getTemplate(options), options), options.firstLower), options).join("");
+    }
+    /**
+     *
+     * @param {PasswordOptions} options
+     * @returns {number[]}
+     */
+    getTemplate(options) {
+        const excludeChars = Array.from(options.excludeChars).sort().join("");
+        const isAllowed = x => !excludeChars.includes(this.CHARSET[x]);
+        const allowNum = isAllowed(this.CHARSET_TYPE.NUM);
+        const allowSpl = isAllowed(this.CHARSET_TYPE.SPL);
+        const allowLower = isAllowed(this.CHARSET_TYPE.LOWER);
+        const allowUpper = isAllowed(this.CHARSET_TYPE.UPPER);
+        const numLen = allowNum && options.needNum ? Math.ceil(0.30 * options.len) : 0;
+        const splLen = allowSpl && options.needSpl ? (options.noOfSpl || Math.ceil(0.10 * options.len)) : 0;
+        const charLen = (options.needLower || options.needUpper) ? (options.len - numLen - splLen) : 0;
+        const lowLen = allowLower && options.needLower ?
+            (allowUpper && options.needUpper ? Math.ceil(charLen / 2) : charLen) : 0;
+        const upLen = (allowUpper && options.needUpper) ? charLen - lowLen : 0;
+        const remLen = options.len - (numLen + splLen + lowLen + upLen);
+        if (remLen && !numLen && (!splLen || options.noOfSpl || !allowSpl)) {
+            throw new Error();
+        }
+        const numRemLen = remLen && allowNum && options.needNum ?
+            (options.noOfSpl || !allowSpl || !options.needSpl ? remLen : Math.ceil(0.75 * remLen)) : 0;
+        const spqlRemLen = remLen - numRemLen;
+        return this.getFilledArray(lowLen, upLen, numLen + numRemLen, splLen + spqlRemLen);
+    }
+    getFilledArray(lower = 0, upper = 0, num = 0, spl = 0) {
+        const f = (len, x) => Array.from({ length: len }).fill(x);
+        return f(lower, this.CHARSET_TYPE.LOWER)
+            .concat(f(upper, this.CHARSET_TYPE.UPPER))
+            .concat(f(num, this.CHARSET_TYPE.NUM))
+            .concat(f(spl, this.CHARSET_TYPE.SPL));
+    }
+    /**
+     * @param {number[]} a
+     * @param {PasswordOptions} options
+     * @returns {string[]}
+     */
+    processTemplate(a = [], options) {
+        const charSet = this.getExcludedCharSet(options.excludeChars);
+        const getRandomChar = x => charSet[x][getRandomNumber(charSet[x].length)];
+        return a.map(x => getRandomChar(x));
+    }
+    /**
+     *
+     * @param {string[]} password
+     * @param {PasswordOptions} options
+     * @returns {string[]}
+     */
+    correct(password = [], options) {
+        const getAsciiCode = (x = "") => x.charCodeAt(0) || 0;
+        const isSameOrConsecutive = (ch1 = "", ch2 = "") => Math.abs(getAsciiCode(ch1) - getAsciiCode(ch2)) <= 1;
+        const getCharFromCode = (ch = "", inc = 0) => String.fromCharCode(ch.charCodeAt(0) + inc);
+        const getPreviousChar = (ch = "") => getCharFromCode(ch, -1);
+        const getNextChar = (ch = "") => getCharFromCode(ch, 1);
+        const getRandomChar = (charSet = "") => charSet[getRandomNumber(charSet.length)];
+        const ans = [];
+        const getLastAnsChar = () => ans[ans.length - 1] || "";
+        //@ts-ignore
+        const charSets = Object.values(this.getExcludedCharSet(options.excludeChars));
+        const getCharSetOf = (ch = "") => charSets.find(x => x.includes(ch));
+        const getReplacement = (ch = "") => {
+            const previousChar = getPreviousChar(ch);
+            const nextChar = getNextChar(ch);
+            const originalCharSet = getCharSetOf(ch);
+            const correctedcCharSet = this.replaceEach(originalCharSet, previousChar + ch + nextChar);
+            const choosenCharSet = correctedcCharSet.length ? correctedcCharSet : originalCharSet;
+            return getRandomChar(choosenCharSet);
+        };
+        const addAnsChar = (ch = "") => {
+            const previousChar = getLastAnsChar();
+            const correctedCh = isSameOrConsecutive(previousChar, ch) ? getReplacement(previousChar) : ch;
+            ans.push(correctedCh);
+        };
+        password.forEach(ch => addAnsChar(ch));
+        return ans;
+    }
+    getExcludedCharSet(excludeChars = "") {
+        //@ts-ignore
+        return Object.fromEntries(Object.entries(this.CHARSET)
+            .map(x => [x[0], this.replaceEach(x[1], excludeChars)]));
+    }
+    replaceEach(s = "", toBeRemoved = "") {
+        const removeSet = new Set(toBeRemoved);
+        const removeFilter = ch => !removeSet.has(ch);
+        return Array.from(s).filter(removeFilter).join("");
+    }
+    shuffleF(a = [], excludeStart = false) {
+        return excludeStart ? [a[0]].concat(this.shuffle(a.slice(1))) : this.shuffle(a);
+    }
+    //shuffles by Fisher-Yates shuffle algorithm https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle
+    shuffle(a = []) {
+        const swap = (i, j) => { const temp = a[i]; a[i] = a[j]; a[j] = temp; };
+        a.forEach((x, i) => swap(i, getRandomNumberMaxExc(i, a.length)));
+        return a;
+    }
+}
+function getRandomNumber(limit) {
+    return crypto.randomFillSync(new Uint32Array(1))[0] % limit;
+}
+function getRandomNumberInRange(min, max) {
+    return crypto.randomFillSync(new Uint32Array(1))[0] % (max - min + 1) + min;
+}
+function getRandomNumberMaxExc(min, max) {
+    return crypto.randomFillSync(new Uint32Array(1))[0] % (max - min) + min;
+}
+export const PasswordGenerator = {
+    x: new _PasswordGenerator(),
+    /**
+     * @param {PasswordOptions} options
+     * @returns {string}
+     * @throws exception on invalid constraints => ex:length 100, no lower case , no upper case , no number, 5 spl char
+     */
+    generatePassword(options) {
+        return this.x.generatePassword(options);
+    },
+    /**
+     * @param {PasswordOptions} options
+     * @returns {boolean}
+     */
+    isOk(options) {
+        try {
+            this.generatePassword(options);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+};
+export function getComplexityOf(password = "") {
+    const MAX_LENGTH = 12;
+    function getComplexity(password = "") {
+        const complexity = Math.min(getLengthComplexity(password), getCharSetComplexity(password));
+        return complexity >= 100 ? 100 : complexity;
+    }
+    function getCharSetComplexity(password) {
+        return getPercent(getCharSetLengthFloor(Math.pow(getCharSetBase(password), new Set(password).size)), MAX_LENGTH);
+    }
+    function getCharSetLengthFloor(complexity) {
+        const MAX_BASE = 20 + 20 + 15 + 10;
+        let i = 3;
+        while (Math.pow(MAX_BASE, i) <= complexity) {
+            i++;
+        }
+        return i - 1;
+    }
+    function getCharSetBase(password) {
+        const a = [[/[a-z]/, 20], [/[A-Z]/, 20], [/[0-9]/, 10], [/[-~!@#$%^&*()_+=|\\{}[\];:'",.<>/?]/, 15]];
+        //@ts-ignore
+        return a.filter(x => x[0].test(password)).reduce((prev, x) => prev + x[1], 0);
+    }
+    function getLengthComplexity(password) {
+        return getPercent(getFactNValFloor(combinations(Array.from(password))) - 3, MAX_LENGTH - 3);
+    }
+    function getFactNValFloor(limit) {
+        let i = 1;
+        while (factorial(i) <= limit) {
+            i++;
+        }
+        return i - 1;
+    }
+    function combinations(elements) {
+        return factorial(elements.length) /
+            Array.from(getCountMap(elements).values()).map(factorial).reduce((x, y) => x * y, 1);
+    }
+    function getCountMap(a) {
+        const countMap = new Map();
+        a.forEach(x => countMap.set(x, (countMap.get(x) || 0) + 1));
+        return countMap;
+    }
+    function factorial(n) {
+        let ans = 1;
+        for (let i = 2; i <= n; i++) {
+            ans *= i;
+        }
+        return ans;
+    }
+    function getPercent(part, total) {
+        return roundOf(((part < 0 ? 0 : part) / total) * 100, 100);
+    }
+    function roundOf(val, limit) {
+        return val >= limit ? limit : val;
+    }
+    function average(...a) {
+        return a.reduce((x, y) => x + y, 0) / a.length;
+    }
+    return getComplexity(password);
+}
+//# sourceMappingURL=PasswordGenerator.js.map