@flickfyi/flkr 0.0.140 → 0.0.146

package/node_modules/validator/es/lib/isPassportNumber.js

@@ -0,0 +1,145 @@
+import assertString from './util/assertString';
+
+/**
+ * Reference:
+ * https://en.wikipedia.org/ -- Wikipedia
+ * https://docs.microsoft.com/en-us/microsoft-365/compliance/eu-passport-number -- EU Passport Number
+ * https://countrycode.org/ -- Country Codes
+ */
+var passportRegexByCountryCode = {
+  AM: /^[A-Z]{2}\d{7}$/,
+  // ARMENIA
+  AR: /^[A-Z]{3}\d{6}$/,
+  // ARGENTINA
+  AT: /^[A-Z]\d{7}$/,
+  // AUSTRIA
+  AU: /^[A-Z]\d{7}$/,
+  // AUSTRALIA
+  AZ: /^[A-Z]{1}\d{8}$/,
+  // AZERBAIJAN
+  BE: /^[A-Z]{2}\d{6}$/,
+  // BELGIUM
+  BG: /^\d{9}$/,
+  // BULGARIA
+  BR: /^[A-Z]{2}\d{6}$/,
+  // BRAZIL
+  BY: /^[A-Z]{2}\d{7}$/,
+  // BELARUS
+  CA: /^[A-Z]{2}\d{6}$|^[A-Z]\d{6}[A-Z]{2}$/,
+  // CANADA
+  CH: /^[A-Z]\d{7}$/,
+  // SWITZERLAND
+  CN: /^G\d{8}$|^E(?![IO])[A-Z0-9]\d{7}$/,
+  // CHINA [G=Ordinary, E=Electronic] followed by 8-digits, or E followed by any UPPERCASE letter (except I and O) followed by 7 digits
+  CY: /^[A-Z](\d{6}|\d{8})$/,
+  // CYPRUS
+  CZ: /^\d{8}$/,
+  // CZECH REPUBLIC
+  DE: /^[CFGHJKLMNPRTVWXYZ0-9]{9}$/,
+  // GERMANY
+  DK: /^\d{9}$/,
+  // DENMARK
+  DZ: /^\d{9}$/,
+  // ALGERIA
+  EE: /^([A-Z]\d{7}|[A-Z]{2}\d{7})$/,
+  // ESTONIA (K followed by 7-digits), e-passports have 2 UPPERCASE followed by 7 digits
+  ES: /^[A-Z0-9]{2}([A-Z0-9]?)\d{6}$/,
+  // SPAIN
+  FI: /^[A-Z]{2}\d{7}$/,
+  // FINLAND
+  FR: /^\d{2}[A-Z]{2}\d{5}$/,
+  // FRANCE
+  GB: /^\d{9}$/,
+  // UNITED KINGDOM
+  GR: /^[A-Z]{2}\d{7}$/,
+  // GREECE
+  HR: /^\d{9}$/,
+  // CROATIA
+  HU: /^[A-Z]{2}(\d{6}|\d{7})$/,
+  // HUNGARY
+  IE: /^[A-Z0-9]{2}\d{7}$/,
+  // IRELAND
+  IN: /^[A-Z]{1}-?\d{7}$/,
+  // INDIA
+  ID: /^[A-C]\d{7}$/,
+  // INDONESIA
+  IR: /^[A-Z]\d{8}$/,
+  // IRAN
+  IS: /^(A)\d{7}$/,
+  // ICELAND
+  IT: /^[A-Z0-9]{2}\d{7}$/,
+  // ITALY
+  JM: /^[Aa]\d{7}$/,
+  // JAMAICA
+  JP: /^[A-Z]{2}\d{7}$/,
+  // JAPAN
+  KR: /^[MS]\d{8}$/,
+  // SOUTH KOREA, REPUBLIC OF KOREA, [S=PS Passports, M=PM Passports]
+  KZ: /^[a-zA-Z]\d{7}$/,
+  // KAZAKHSTAN
+  LI: /^[a-zA-Z]\d{5}$/,
+  // LIECHTENSTEIN
+  LT: /^[A-Z0-9]{8}$/,
+  // LITHUANIA
+  LU: /^[A-Z0-9]{8}$/,
+  // LUXEMBURG
+  LV: /^[A-Z0-9]{2}\d{7}$/,
+  // LATVIA
+  LY: /^[A-Z0-9]{8}$/,
+  // LIBYA
+  MT: /^\d{7}$/,
+  // MALTA
+  MZ: /^([A-Z]{2}\d{7})|(\d{2}[A-Z]{2}\d{5})$/,
+  // MOZAMBIQUE
+  MY: /^[AHK]\d{8}$/,
+  // MALAYSIA
+  MX: /^[A-Z]\d{8}$/,
+  // MEXICO
+  NL: /^[A-Z]{2}[A-Z0-9]{6}\d$/,
+  // NETHERLANDS
+  NZ: /^([Ll]([Aa]|[Dd]|[Ff]|[Hh])|[Ee]([Aa]|[Pp])|[Nn])\d{6}$/,
+  // NEW ZEALAND
+  PH: /^([A-Z](\d{6}|\d{7}[A-Z]))|([A-Z]{2}(\d{6}|\d{7}))$/,
+  // PHILIPPINES
+  PK: /^[A-Z]{2}\d{7}$/,
+  // PAKISTAN
+  PL: /^[A-Z]{2}\d{7}$/,
+  // POLAND
+  PT: /^[A-Z]\d{6}$/,
+  // PORTUGAL
+  RO: /^\d{8,9}$/,
+  // ROMANIA
+  RU: /^\d{9}$/,
+  // RUSSIAN FEDERATION
+  SE: /^\d{8}$/,
+  // SWEDEN
+  SL: /^(P)[A-Z]\d{7}$/,
+  // SLOVENIA
+  SK: /^[0-9A-Z]\d{7}$/,
+  // SLOVAKIA
+  TH: /^[A-Z]{1,2}\d{6,7}$/,
+  // THAILAND
+  TR: /^[A-Z]\d{8}$/,
+  // TURKEY
+  UA: /^[A-Z]{2}\d{6}$/,
+  // UKRAINE
+  US: /^\d{9}$|^[A-Z]\d{8}$/,
+  // UNITED STATES
+  ZA: /^[TAMD]\d{8}$/ // SOUTH AFRICA
+};
+export var locales = Object.keys(passportRegexByCountryCode);
+
+/**
+ * Check if str is a valid passport number
+ * relative to provided ISO Country Code.
+ *
+ * @param {string} str
+ * @param {string} countryCode
+ * @return {boolean}
+ */
+export default function isPassportNumber(str, countryCode) {
+  assertString(str);
+  /** Remove All Whitespaces, Convert to UPPERCASE */
+  var normalizedStr = str.replace(/\s/g, '').toUpperCase();
+  return countryCode.toUpperCase() in passportRegexByCountryCode && passportRegexByCountryCode[countryCode].test(normalizedStr);
+}

package/node_modules/validator/es/lib/isPort.js

@@ -0,0 +1,8 @@
+import isInt from './isInt';
+export default function isPort(str) {
+  return isInt(str, {
+    allow_leading_zeroes: false,
+    min: 0,
+    max: 65535
+  });
+}

package/node_modules/validator/es/lib/isPostalCode.js

@@ -0,0 +1,100 @@
+import assertString from './util/assertString';
+
+// common patterns
+var threeDigit = /^\d{3}$/;
+var fourDigit = /^\d{4}$/;
+var fiveDigit = /^\d{5}$/;
+var sixDigit = /^\d{6}$/;
+var patterns = {
+  AD: /^AD\d{3}$/,
+  AT: fourDigit,
+  AU: fourDigit,
+  AZ: /^AZ\d{4}$/,
+  BA: /^([7-8]\d{4}$)/,
+  BD: /^([1-8][0-9]{3}|9[0-4][0-9]{2})$/,
+  BE: fourDigit,
+  BG: fourDigit,
+  BR: /^\d{5}-?\d{3}$/,
+  BY: /^2[1-4]\d{4}$/,
+  CA: /^[ABCEGHJKLMNPRSTVXY]\d[ABCEGHJ-NPRSTV-Z][\s\-]?\d[ABCEGHJ-NPRSTV-Z]\d$/i,
+  CH: fourDigit,
+  CN: /^(0[1-7]|1[012356]|2[0-7]|3[0-6]|4[0-7]|5[1-7]|6[1-7]|7[1-5]|8[1345]|9[09])\d{4}$/,
+  CO: /^(05|08|11|13|15|17|18|19|20|23|25|27|41|44|47|50|52|54|63|66|68|70|73|76|81|85|86|88|91|94|95|97|99)(\d{4})$/,
+  CZ: /^\d{3}\s?\d{2}$/,
+  DE: fiveDigit,
+  DK: fourDigit,
+  DO: fiveDigit,
+  DZ: fiveDigit,
+  EE: fiveDigit,
+  ES: /^(5[0-2]{1}|[0-4]{1}\d{1})\d{3}$/,
+  FI: fiveDigit,
+  FR: /^(?:(?:0[1-9]|[1-8]\d|9[0-5])\d{3}|97[1-46]\d{2})$/,
+  GB: /^(gir\s?0aa|[a-z]{1,2}\d[\da-z]?\s?(\d[a-z]{2})?)$/i,
+  GR: /^\d{3}\s?\d{2}$/,
+  HR: /^([1-5]\d{4}$)/,
+  HT: /^HT\d{4}$/,
+  HU: fourDigit,
+  ID: fiveDigit,
+  IE: /^(?!.*(?:o))[A-Za-z]\d[\dw]\s\w{4}$/i,
+  IL: /^(\d{5}|\d{7})$/,
+  IN: /^((?!10|29|35|54|55|65|66|86|87|88|89)[1-9][0-9]{5})$/,
+  IR: /^(?!(\d)\1{3})[13-9]{4}[1346-9][013-9]{5}$/,
+  IS: threeDigit,
+  IT: fiveDigit,
+  JP: /^\d{3}\-\d{4}$/,
+  KE: fiveDigit,
+  KR: /^(\d{5}|\d{6})$/,
+  LI: /^(948[5-9]|949[0-7])$/,
+  LT: /^LT\-\d{5}$/,
+  LU: fourDigit,
+  LV: /^LV\-\d{4}$/,
+  LK: fiveDigit,
+  MC: /^980\d{2}$/,
+  MG: threeDigit,
+  MX: fiveDigit,
+  MT: /^[A-Za-z]{3}\s{0,1}\d{4}$/,
+  MY: fiveDigit,
+  NL: /^[1-9]\d{3}\s?(?!sa|sd|ss)[a-z]{2}$/i,
+  NO: fourDigit,
+  NP: /^(10|21|22|32|33|34|44|45|56|57)\d{3}$|^(977)$/i,
+  NZ: fourDigit,
+  // https://www.pakpost.gov.pk/postcodes.php
+  PK: fiveDigit,
+  PL: /^\d{2}\-\d{3}$/,
+  PR: /^00[679]\d{2}([ -]\d{4})?$/,
+  PT: /^\d{4}\-\d{3}?$/,
+  RO: sixDigit,
+  RU: sixDigit,
+  SA: fiveDigit,
+  SE: /^[1-9]\d{2}\s?\d{2}$/,
+  SG: sixDigit,
+  SI: fourDigit,
+  SK: /^\d{3}\s?\d{2}$/,
+  TH: fiveDigit,
+  TN: fourDigit,
+  TW: /^\d{3}(\d{2,3})?$/,
+  UA: fiveDigit,
+  US: /^\d{5}(-\d{4})?$/,
+  ZA: fourDigit,
+  ZM: fiveDigit
+};
+export var locales = Object.keys(patterns);
+export default function isPostalCode(str, locale) {
+  assertString(str);
+  if (locale in patterns) {
+    return patterns[locale].test(str);
+  } else if (locale === 'any') {
+    for (var key in patterns) {
+      // https://github.com/gotwarlost/istanbul/blob/master/ignoring-code-for-coverage.md#ignoring-code-for-coverage-purposes
+      // istanbul ignore else
+      if (patterns.hasOwnProperty(key)) {
+        var pattern = patterns[key];
+        if (pattern.test(str)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  throw new Error("Invalid locale '".concat(locale, "'"));
+}

package/node_modules/validator/es/lib/isRFC3339.js

@@ -0,0 +1,21 @@
+import assertString from './util/assertString';
+
+/* Based on https://tools.ietf.org/html/rfc3339#section-5.6 */
+
+var dateFullYear = /[0-9]{4}/;
+var dateMonth = /(0[1-9]|1[0-2])/;
+var dateMDay = /([12]\d|0[1-9]|3[01])/;
+var timeHour = /([01][0-9]|2[0-3])/;
+var timeMinute = /[0-5][0-9]/;
+var timeSecond = /([0-5][0-9]|60)/;
+var timeSecFrac = /(\.[0-9]+)?/;
+var timeNumOffset = new RegExp("[-+]".concat(timeHour.source, ":").concat(timeMinute.source));
+var timeOffset = new RegExp("([zZ]|".concat(timeNumOffset.source, ")"));
+var partialTime = new RegExp("".concat(timeHour.source, ":").concat(timeMinute.source, ":").concat(timeSecond.source).concat(timeSecFrac.source));
+var fullDate = new RegExp("".concat(dateFullYear.source, "-").concat(dateMonth.source, "-").concat(dateMDay.source));
+var fullTime = new RegExp("".concat(partialTime.source).concat(timeOffset.source));
+var rfc3339 = new RegExp("^".concat(fullDate.source, "[ tT]").concat(fullTime.source, "$"));
+export default function isRFC3339(str) {
+  assertString(str);
+  return rfc3339.test(str);
+}

package/node_modules/validator/es/lib/isRgbColor.js

@@ -0,0 +1,34 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+/* eslint-disable prefer-rest-params */
+import assertString from './util/assertString';
+var rgbColor = /^rgb\((([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5]),){2}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\)$/;
+var rgbaColor = /^rgba\((([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5]),){3}(0?\.\d\d?|1(\.0)?|0(\.0)?)\)$/;
+var rgbColorPercent = /^rgb\((([0-9]%|[1-9][0-9]%|100%),){2}([0-9]%|[1-9][0-9]%|100%)\)$/;
+var rgbaColorPercent = /^rgba\((([0-9]%|[1-9][0-9]%|100%),){3}(0?\.\d\d?|1(\.0)?|0(\.0)?)\)$/;
+var startsWithRgb = /^rgba?/;
+export default function isRgbColor(str, options) {
+  assertString(str);
+  // default options to true for percent and false for spaces
+  var allowSpaces = false;
+  var includePercentValues = true;
+  if (_typeof(options) !== 'object') {
+    if (arguments.length >= 2) {
+      includePercentValues = arguments[1];
+    }
+  } else {
+    allowSpaces = options.allowSpaces !== undefined ? options.allowSpaces : allowSpaces;
+    includePercentValues = options.includePercentValues !== undefined ? options.includePercentValues : includePercentValues;
+  }
+  if (allowSpaces) {
+    // make sure it starts with continuous rgba? without spaces before stripping
+    if (!startsWithRgb.test(str)) {
+      return false;
+    }
+    // strip all whitespace
+    str = str.replace(/\s/g, '');
+  }
+  if (!includePercentValues) {
+    return rgbColor.test(str) || rgbaColor.test(str);
+  }
+  return rgbColor.test(str) || rgbaColor.test(str) || rgbColorPercent.test(str) || rgbaColorPercent.test(str);
+}

package/node_modules/validator/es/lib/isSemVer.js

@@ -0,0 +1,14 @@
+import assertString from './util/assertString';
+import multilineRegexp from './util/multilineRegex';
+
+/**
+ * Regular Expression to match
+ * semantic versioning (SemVer)
+ * built from multi-line, multi-parts regexp
+ * Reference: https://semver.org/
+ */
+var semanticVersioningRegex = multilineRegexp(['^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)', '(?:-((?:0|[1-9]\\d*|\\d*[a-z-][0-9a-z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-z-][0-9a-z-]*))*))', '?(?:\\+([0-9a-z-]+(?:\\.[0-9a-z-]+)*))?$'], 'i');
+export default function isSemVer(str) {
+  assertString(str);
+  return semanticVersioningRegex.test(str);
+}

package/node_modules/validator/es/lib/isSlug.js

@@ -0,0 +1,6 @@
+import assertString from './util/assertString';
+var charsetRegex = /^[a-z0-9](?!.*[-_]{2,})(?:[a-z0-9_-]*[a-z0-9])?$/;
+export default function isSlug(str) {
+  assertString(str);
+  return charsetRegex.test(str);
+}

package/node_modules/validator/es/lib/isStrongPassword.js

@@ -0,0 +1,90 @@
+import merge from './util/merge';
+import assertString from './util/assertString';
+var upperCaseRegex = /^[A-Z]$/;
+var lowerCaseRegex = /^[a-z]$/;
+var numberRegex = /^[0-9]$/;
+var symbolRegex = /^[-#!$@£%^&*()_+|~=`{}\[\]:";'<>?,.\/\\ ]$/;
+var defaultOptions = {
+  minLength: 8,
+  minLowercase: 1,
+  minUppercase: 1,
+  minNumbers: 1,
+  minSymbols: 1,
+  returnScore: false,
+  pointsPerUnique: 1,
+  pointsPerRepeat: 0.5,
+  pointsForContainingLower: 10,
+  pointsForContainingUpper: 10,
+  pointsForContainingNumber: 10,
+  pointsForContainingSymbol: 10
+};
+
+/* Counts number of occurrences of each char in a string
+ * could be moved to util/ ?
+*/
+function countChars(str) {
+  var result = {};
+  Array.from(str).forEach(function (_char) {
+    var curVal = result[_char];
+    if (curVal) {
+      result[_char] += 1;
+    } else {
+      result[_char] = 1;
+    }
+  });
+  return result;
+}
+
+/* Return information about a password */
+function analyzePassword(password) {
+  var charMap = countChars(password);
+  var analysis = {
+    length: password.length,
+    uniqueChars: Object.keys(charMap).length,
+    uppercaseCount: 0,
+    lowercaseCount: 0,
+    numberCount: 0,
+    symbolCount: 0
+  };
+  Object.keys(charMap).forEach(function (_char2) {
+    /* istanbul ignore else */
+    if (upperCaseRegex.test(_char2)) {
+      analysis.uppercaseCount += charMap[_char2];
+    } else if (lowerCaseRegex.test(_char2)) {
+      analysis.lowercaseCount += charMap[_char2];
+    } else if (numberRegex.test(_char2)) {
+      analysis.numberCount += charMap[_char2];
+    } else if (symbolRegex.test(_char2)) {
+      analysis.symbolCount += charMap[_char2];
+    }
+  });
+  return analysis;
+}
+function scorePassword(analysis, scoringOptions) {
+  var points = 0;
+  points += analysis.uniqueChars * scoringOptions.pointsPerUnique;
+  points += (analysis.length - analysis.uniqueChars) * scoringOptions.pointsPerRepeat;
+  if (analysis.lowercaseCount > 0) {
+    points += scoringOptions.pointsForContainingLower;
+  }
+  if (analysis.uppercaseCount > 0) {
+    points += scoringOptions.pointsForContainingUpper;
+  }
+  if (analysis.numberCount > 0) {
+    points += scoringOptions.pointsForContainingNumber;
+  }
+  if (analysis.symbolCount > 0) {
+    points += scoringOptions.pointsForContainingSymbol;
+  }
+  return points;
+}
+export default function isStrongPassword(str) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  assertString(str);
+  var analysis = analyzePassword(str);
+  options = merge(options || {}, defaultOptions);
+  if (options.returnScore) {
+    return scorePassword(analysis, options);
+  }
+  return analysis.length >= options.minLength && analysis.lowercaseCount >= options.minLowercase && analysis.uppercaseCount >= options.minUppercase && analysis.numberCount >= options.minNumbers && analysis.symbolCount >= options.minSymbols;
+}

package/node_modules/validator/es/lib/isSurrogatePair.js

@@ -0,0 +1,6 @@
+import assertString from './util/assertString';
+var surrogatePair = /[\uD800-\uDBFF][\uDC00-\uDFFF]/;
+export default function isSurrogatePair(str) {
+  assertString(str);
+  return surrogatePair.test(str);
+}