{"version":3,"file":"3469.chunk.7d7fe.js","mappings":"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","sources":["webpack://@rocket.chat/livechat/./node_modules/linkify-it/lib/re.js","webpack://@rocket.chat/livechat/./node_modules/linkify-it/index.js","webpack://@rocket.chat/livechat/./node_modules/map-age-cleaner/dist/index.js"],"sourcesContent":["'use strict';\n\n\nmodule.exports = function (opts) {\n  var re = {};\n\n  // Use direct extract instead of `regenerate` to reduse browserified size\n  re.src_Any = require('uc.micro/properties/Any/regex').source;\n  re.src_Cc  = require('uc.micro/categories/Cc/regex').source;\n  re.src_Z   = require('uc.micro/categories/Z/regex').source;\n  re.src_P   = require('uc.micro/categories/P/regex').source;\n\n  // \\p{\\Z\\P\\Cc\\CF} (white spaces + control + format + punctuation)\n  re.src_ZPCc = [ re.src_Z, re.src_P, re.src_Cc ].join('|');\n\n  // \\p{\\Z\\Cc} (white spaces + control)\n  re.src_ZCc = [ re.src_Z, re.src_Cc ].join('|');\n\n  // Experimental. List of chars, completely prohibited in links\n  // because can separate it from other part of text\n  var text_separators = '[><\\uff5c]';\n\n  // All possible word characters (everything without punctuation, spaces & controls)\n  // Defined via punctuation & spaces to save space\n  // Should be something like \\p{\\L\\N\\S\\M} (\\w but without `_`)\n  re.src_pseudo_letter       = '(?:(?!' + text_separators + '|' + re.src_ZPCc + ')' + re.src_Any + ')';\n  // The same as abothe but without [0-9]\n  // var src_pseudo_letter_non_d = '(?:(?![0-9]|' + src_ZPCc + ')' + src_Any + ')';\n\n  ////////////////////////////////////////////////////////////////////////////////\n\n  re.src_ip4 =\n\n    '(?:(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)';\n\n  // Prohibit any of \"@/[]()\" in user/pass to avoid wrong domain fetch.\n  re.src_auth    = '(?:(?:(?!' + re.src_ZCc + '|[@/\\\\[\\\\]()]).)+@)?';\n\n  re.src_port =\n\n    '(?::(?:6(?:[0-4]\\\\d{3}|5(?:[0-4]\\\\d{2}|5(?:[0-2]\\\\d|3[0-5])))|[1-5]?\\\\d{1,4}))?';\n\n  re.src_host_terminator =\n\n    '(?=$|' + text_separators + '|' + re.src_ZPCc + ')(?!-|_|:\\\\d|\\\\.-|\\\\.(?!$|' + re.src_ZPCc + '))';\n\n  re.src_path =\n\n    '(?:' +\n      '[/?#]' +\n        '(?:' +\n          '(?!' + re.src_ZCc + '|' + text_separators + '|[()[\\\\]{}.,\"\\'?!\\\\-;]).|' +\n          '\\\\[(?:(?!' + re.src_ZCc + '|\\\\]).)*\\\\]|' +\n          '\\\\((?:(?!' + re.src_ZCc + '|[)]).)*\\\\)|' +\n          '\\\\{(?:(?!' + re.src_ZCc + '|[}]).)*\\\\}|' +\n          '\\\\\"(?:(?!' + re.src_ZCc + '|[\"]).)+\\\\\"|' +\n          \"\\\\'(?:(?!\" + re.src_ZCc + \"|[']).)+\\\\'|\" +\n          \"\\\\'(?=\" + re.src_pseudo_letter + '|[-]).|' +  // allow `I'm_king` if no pair found\n          '\\\\.{2,}[a-zA-Z0-9%/&]|' + // google has many dots in \"google search\" links (#66, #81).\n                                     // github has ... in commit range links,\n                                     // Restrict to\n                                     // - english\n                                     // - percent-encoded\n                                     // - parts of file path\n                                     // - params separator\n                                     // until more examples found.\n          '\\\\.(?!' + re.src_ZCc + '|[.]).|' +\n          (opts && opts['---'] ?\n            '\\\\-(?!--(?:[^-]|$))(?:-*)|' // `---` => long dash, terminate\n            :\n            '\\\\-+|'\n          ) +\n          ',(?!' + re.src_ZCc + ').|' +       // allow `,,,` in paths\n          ';(?!' + re.src_ZCc + ').|' +       // allow `;` if not followed by space-like char\n          '\\\\!+(?!' + re.src_ZCc + '|[!]).|' +  // allow `!!!` in paths, but not at the end\n          '\\\\?(?!' + re.src_ZCc + '|[?]).' +\n        ')+' +\n      '|\\\\/' +\n    ')?';\n\n  // Allow anything in markdown spec, forbid quote (\") at the first position\n  // because emails enclosed in quotes are far more common\n  re.src_email_name =\n\n    '[\\\\-;:&=\\\\+\\\\$,\\\\.a-zA-Z0-9_][\\\\-;:&=\\\\+\\\\$,\\\\\"\\\\.a-zA-Z0-9_]*';\n\n  re.src_xn =\n\n    'xn--[a-z0-9\\\\-]{1,59}';\n\n  // More to read about domain names\n  // http://serverfault.com/questions/638260/\n\n  re.src_domain_root =\n\n    // Allow letters & digits (http://test1)\n    '(?:' +\n      re.src_xn +\n      '|' +\n      re.src_pseudo_letter + '{1,63}' +\n    ')';\n\n  re.src_domain =\n\n    '(?:' +\n      re.src_xn +\n      '|' +\n      '(?:' + re.src_pseudo_letter + ')' +\n      '|' +\n      '(?:' + re.src_pseudo_letter + '(?:-|' + re.src_pseudo_letter + '){0,61}' + re.src_pseudo_letter + ')' +\n    ')';\n\n  re.src_host =\n\n    '(?:' +\n    // Don't need IP check, because digits are already allowed in normal domain names\n    //   src_ip4 +\n    // '|' +\n      '(?:(?:(?:' + re.src_domain + ')\\\\.)*' + re.src_domain/*_root*/ + ')' +\n    ')';\n\n  re.tpl_host_fuzzy =\n\n    '(?:' +\n      re.src_ip4 +\n    '|' +\n      '(?:(?:(?:' + re.src_domain + ')\\\\.)+(?:%TLDS%))' +\n    ')';\n\n  re.tpl_host_no_ip_fuzzy =\n\n    '(?:(?:(?:' + re.src_domain + ')\\\\.)+(?:%TLDS%))';\n\n  re.src_host_strict =\n\n    re.src_host + re.src_host_terminator;\n\n  re.tpl_host_fuzzy_strict =\n\n    re.tpl_host_fuzzy + re.src_host_terminator;\n\n  re.src_host_port_strict =\n\n    re.src_host + re.src_port + re.src_host_terminator;\n\n  re.tpl_host_port_fuzzy_strict =\n\n    re.tpl_host_fuzzy + re.src_port + re.src_host_terminator;\n\n  re.tpl_host_port_no_ip_fuzzy_strict =\n\n    re.tpl_host_no_ip_fuzzy + re.src_port + re.src_host_terminator;\n\n\n  ////////////////////////////////////////////////////////////////////////////////\n  // Main rules\n\n  // Rude test fuzzy links by host, for quick deny\n  re.tpl_host_fuzzy_test =\n\n    'localhost|www\\\\.|\\\\.\\\\d{1,3}\\\\.|(?:\\\\.(?:%TLDS%)(?:' + re.src_ZPCc + '|>|$))';\n\n  re.tpl_email_fuzzy =\n\n      '(^|' + text_separators + '|\"|\\\\(|' + re.src_ZCc + ')' +\n      '(' + re.src_email_name + '@' + re.tpl_host_fuzzy_strict + ')';\n\n  re.tpl_link_fuzzy =\n      // Fuzzy link can't be prepended with .:/\\- and non punctuation.\n      // but can start with > (markdown blockquote)\n      '(^|(?![.:/\\\\-_@])(?:[$+<=>^`|\\uff5c]|' + re.src_ZPCc + '))' +\n      '((?![$+<=>^`|\\uff5c])' + re.tpl_host_port_fuzzy_strict + re.src_path + ')';\n\n  re.tpl_link_no_ip_fuzzy =\n      // Fuzzy link can't be prepended with .:/\\- and non punctuation.\n      // but can start with > (markdown blockquote)\n      '(^|(?![.:/\\\\-_@])(?:[$+<=>^`|\\uff5c]|' + re.src_ZPCc + '))' +\n      '((?![$+<=>^`|\\uff5c])' + re.tpl_host_port_no_ip_fuzzy_strict + re.src_path + ')';\n\n  return re;\n};\n","'use strict';\n\n\n////////////////////////////////////////////////////////////////////////////////\n// Helpers\n\n// Merge objects\n//\nfunction assign(obj /*from1, from2, from3, ...*/) {\n  var sources = Array.prototype.slice.call(arguments, 1);\n\n  sources.forEach(function (source) {\n    if (!source) { return; }\n\n    Object.keys(source).forEach(function (key) {\n      obj[key] = source[key];\n    });\n  });\n\n  return obj;\n}\n\nfunction _class(obj) { return Object.prototype.toString.call(obj); }\nfunction isString(obj) { return _class(obj) === '[object String]'; }\nfunction isObject(obj) { return _class(obj) === '[object Object]'; }\nfunction isRegExp(obj) { return _class(obj) === '[object RegExp]'; }\nfunction isFunction(obj) { return _class(obj) === '[object Function]'; }\n\n\nfunction escapeRE(str) { return str.replace(/[.?*+^$[\\]\\\\(){}|-]/g, '\\\\$&'); }\n\n////////////////////////////////////////////////////////////////////////////////\n\n\nvar defaultOptions = {\n  fuzzyLink: true,\n  fuzzyEmail: true,\n  fuzzyIP: false\n};\n\n\nfunction isOptionsObj(obj) {\n  return Object.keys(obj || {}).reduce(function (acc, k) {\n    return acc || defaultOptions.hasOwnProperty(k);\n  }, false);\n}\n\n\nvar defaultSchemas = {\n  'http:': {\n    validate: function (text, pos, self) {\n      var tail = text.slice(pos);\n\n      if (!self.re.http) {\n        // compile lazily, because \"host\"-containing variables can change on tlds update.\n        self.re.http =  new RegExp(\n          '^\\\\/\\\\/' + self.re.src_auth + self.re.src_host_port_strict + self.re.src_path, 'i'\n        );\n      }\n      if (self.re.http.test(tail)) {\n        return tail.match(self.re.http)[0].length;\n      }\n      return 0;\n    }\n  },\n  'https:':  'http:',\n  'ftp:':    'http:',\n  '//':      {\n    validate: function (text, pos, self) {\n      var tail = text.slice(pos);\n\n      if (!self.re.no_http) {\n      // compile lazily, because \"host\"-containing variables can change on tlds update.\n        self.re.no_http =  new RegExp(\n          '^' +\n          self.re.src_auth +\n          // Don't allow single-level domains, because of false positives like '//test'\n          // with code comments\n          '(?:localhost|(?:(?:' + self.re.src_domain + ')\\\\.)+' + self.re.src_domain_root + ')' +\n          self.re.src_port +\n          self.re.src_host_terminator +\n          self.re.src_path,\n\n          'i'\n        );\n      }\n\n      if (self.re.no_http.test(tail)) {\n        // should not be `://` & `///`, that protects from errors in protocol name\n        if (pos >= 3 && text[pos - 3] === ':') { return 0; }\n        if (pos >= 3 && text[pos - 3] === '/') { return 0; }\n        return tail.match(self.re.no_http)[0].length;\n      }\n      return 0;\n    }\n  },\n  'mailto:': {\n    validate: function (text, pos, self) {\n      var tail = text.slice(pos);\n\n      if (!self.re.mailto) {\n        self.re.mailto =  new RegExp(\n          '^' + self.re.src_email_name + '@' + self.re.src_host_strict, 'i'\n        );\n      }\n      if (self.re.mailto.test(tail)) {\n        return tail.match(self.re.mailto)[0].length;\n      }\n      return 0;\n    }\n  }\n};\n\n/*eslint-disable max-len*/\n\n// RE pattern for 2-character tlds (autogenerated by ./support/tlds_2char_gen.js)\nvar tlds_2ch_src_re = 'a[cdefgilmnoqrstuwxz]|b[abdefghijmnorstvwyz]|c[acdfghiklmnoruvwxyz]|d[ejkmoz]|e[cegrstu]|f[ijkmor]|g[abdefghilmnpqrstuwy]|h[kmnrtu]|i[delmnoqrst]|j[emop]|k[eghimnprwyz]|l[abcikrstuvy]|m[acdeghklmnopqrstuvwxyz]|n[acefgilopruz]|om|p[aefghklmnrstwy]|qa|r[eosuw]|s[abcdeghijklmnortuvxyz]|t[cdfghjklmnortvwz]|u[agksyz]|v[aceginu]|w[fs]|y[et]|z[amw]';\n\n// DON'T try to make PRs with changes. Extend TLDs with LinkifyIt.tlds() instead\nvar tlds_default = 'biz|com|edu|gov|net|org|pro|web|xxx|aero|asia|coop|info|museum|name|shop|рф'.split('|');\n\n/*eslint-enable max-len*/\n\n////////////////////////////////////////////////////////////////////////////////\n\nfunction resetScanCache(self) {\n  self.__index__ = -1;\n  self.__text_cache__   = '';\n}\n\nfunction createValidator(re) {\n  return function (text, pos) {\n    var tail = text.slice(pos);\n\n    if (re.test(tail)) {\n      return tail.match(re)[0].length;\n    }\n    return 0;\n  };\n}\n\nfunction createNormalizer() {\n  return function (match, self) {\n    self.normalize(match);\n  };\n}\n\n// Schemas compiler. Build regexps.\n//\nfunction compile(self) {\n\n  // Load & clone RE patterns.\n  var re = self.re = require('./lib/re')(self.__opts__);\n\n  // Define dynamic patterns\n  var tlds = self.__tlds__.slice();\n\n  self.onCompile();\n\n  if (!self.__tlds_replaced__) {\n    tlds.push(tlds_2ch_src_re);\n  }\n  tlds.push(re.src_xn);\n\n  re.src_tlds = tlds.join('|');\n\n  function untpl(tpl) { return tpl.replace('%TLDS%', re.src_tlds); }\n\n  re.email_fuzzy      = RegExp(untpl(re.tpl_email_fuzzy), 'i');\n  re.link_fuzzy       = RegExp(untpl(re.tpl_link_fuzzy), 'i');\n  re.link_no_ip_fuzzy = RegExp(untpl(re.tpl_link_no_ip_fuzzy), 'i');\n  re.host_fuzzy_test  = RegExp(untpl(re.tpl_host_fuzzy_test), 'i');\n\n  //\n  // Compile each schema\n  //\n\n  var aliases = [];\n\n  self.__compiled__ = {}; // Reset compiled data\n\n  function schemaError(name, val) {\n    throw new Error('(LinkifyIt) Invalid schema \"' + name + '\": ' + val);\n  }\n\n  Object.keys(self.__schemas__).forEach(function (name) {\n    var val = self.__schemas__[name];\n\n    // skip disabled methods\n    if (val === null) { return; }\n\n    var compiled = { validate: null, link: null };\n\n    self.__compiled__[name] = compiled;\n\n    if (isObject(val)) {\n      if (isRegExp(val.validate)) {\n        compiled.validate = createValidator(val.validate);\n      } else if (isFunction(val.validate)) {\n        compiled.validate = val.validate;\n      } else {\n        schemaError(name, val);\n      }\n\n      if (isFunction(val.normalize)) {\n        compiled.normalize = val.normalize;\n      } else if (!val.normalize) {\n        compiled.normalize = createNormalizer();\n      } else {\n        schemaError(name, val);\n      }\n\n      return;\n    }\n\n    if (isString(val)) {\n      aliases.push(name);\n      return;\n    }\n\n    schemaError(name, val);\n  });\n\n  //\n  // Compile postponed aliases\n  //\n\n  aliases.forEach(function (alias) {\n    if (!self.__compiled__[self.__schemas__[alias]]) {\n      // Silently fail on missed schemas to avoid errons on disable.\n      // schemaError(alias, self.__schemas__[alias]);\n      return;\n    }\n\n    self.__compiled__[alias].validate =\n      self.__compiled__[self.__schemas__[alias]].validate;\n    self.__compiled__[alias].normalize =\n      self.__compiled__[self.__schemas__[alias]].normalize;\n  });\n\n  //\n  // Fake record for guessed links\n  //\n  self.__compiled__[''] = { validate: null, normalize: createNormalizer() };\n\n  //\n  // Build schema condition\n  //\n  var slist = Object.keys(self.__compiled__)\n                      .filter(function (name) {\n                        // Filter disabled & fake schemas\n                        return name.length > 0 && self.__compiled__[name];\n                      })\n                      .map(escapeRE)\n                      .join('|');\n  // (?!_) cause 1.5x slowdown\n  self.re.schema_test   = RegExp('(^|(?!_)(?:[><\\uff5c]|' + re.src_ZPCc + '))(' + slist + ')', 'i');\n  self.re.schema_search = RegExp('(^|(?!_)(?:[><\\uff5c]|' + re.src_ZPCc + '))(' + slist + ')', 'ig');\n\n  self.re.pretest = RegExp(\n    '(' + self.re.schema_test.source + ')|(' + self.re.host_fuzzy_test.source + ')|@',\n    'i'\n  );\n\n  //\n  // Cleanup\n  //\n\n  resetScanCache(self);\n}\n\n/**\n * class Match\n *\n * Match result. Single element of array, returned by [[LinkifyIt#match]]\n **/\nfunction Match(self, shift) {\n  var start = self.__index__,\n      end   = self.__last_index__,\n      text  = self.__text_cache__.slice(start, end);\n\n  /**\n   * Match#schema -> String\n   *\n   * Prefix (protocol) for matched string.\n   **/\n  this.schema    = self.__schema__.toLowerCase();\n  /**\n   * Match#index -> Number\n   *\n   * First position of matched string.\n   **/\n  this.index     = start + shift;\n  /**\n   * Match#lastIndex -> Number\n   *\n   * Next position after matched string.\n   **/\n  this.lastIndex = end + shift;\n  /**\n   * Match#raw -> String\n   *\n   * Matched string.\n   **/\n  this.raw       = text;\n  /**\n   * Match#text -> String\n   *\n   * Notmalized text of matched string.\n   **/\n  this.text      = text;\n  /**\n   * Match#url -> String\n   *\n   * Normalized url of matched string.\n   **/\n  this.url       = text;\n}\n\nfunction createMatch(self, shift) {\n  var match = new Match(self, shift);\n\n  self.__compiled__[match.schema].normalize(match, self);\n\n  return match;\n}\n\n\n/**\n * class LinkifyIt\n **/\n\n/**\n * new LinkifyIt(schemas, options)\n * - schemas (Object): Optional. Additional schemas to validate (prefix/validator)\n * - options (Object): { fuzzyLink|fuzzyEmail|fuzzyIP: true|false }\n *\n * Creates new linkifier instance with optional additional schemas.\n * Can be called without `new` keyword for convenience.\n *\n * By default understands:\n *\n * - `http(s)://...` , `ftp://...`, `mailto:...` & `//...` links\n * - \"fuzzy\" links and emails (example.com, foo@bar.com).\n *\n * `schemas` is an object, where each key/value describes protocol/rule:\n *\n * - __key__ - link prefix (usually, protocol name with `:` at the end, `skype:`\n *   for example). `linkify-it` makes shure that prefix is not preceeded with\n *   alphanumeric char and symbols. Only whitespaces and punctuation allowed.\n * - __value__ - rule to check tail after link prefix\n *   - _String_ - just alias to existing rule\n *   - _Object_\n *     - _validate_ - validator function (should return matched length on success),\n *       or `RegExp`.\n *     - _normalize_ - optional function to normalize text & url of matched result\n *       (for example, for @twitter mentions).\n *\n * `options`:\n *\n * - __fuzzyLink__ - recognige URL-s without `http(s):` prefix. Default `true`.\n * - __fuzzyIP__ - allow IPs in fuzzy links above. Can conflict with some texts\n *   like version numbers. Default `false`.\n * - __fuzzyEmail__ - recognize emails without `mailto:` prefix.\n *\n **/\nfunction LinkifyIt(schemas, options) {\n  if (!(this instanceof LinkifyIt)) {\n    return new LinkifyIt(schemas, options);\n  }\n\n  if (!options) {\n    if (isOptionsObj(schemas)) {\n      options = schemas;\n      schemas = {};\n    }\n  }\n\n  this.__opts__           = assign({}, defaultOptions, options);\n\n  // Cache last tested result. Used to skip repeating steps on next `match` call.\n  this.__index__          = -1;\n  this.__last_index__     = -1; // Next scan position\n  this.__schema__         = '';\n  this.__text_cache__     = '';\n\n  this.__schemas__        = assign({}, defaultSchemas, schemas);\n  this.__compiled__       = {};\n\n  this.__tlds__           = tlds_default;\n  this.__tlds_replaced__  = false;\n\n  this.re = {};\n\n  compile(this);\n}\n\n\n/** chainable\n * LinkifyIt#add(schema, definition)\n * - schema (String): rule name (fixed pattern prefix)\n * - definition (String|RegExp|Object): schema definition\n *\n * Add new rule definition. See constructor description for details.\n **/\nLinkifyIt.prototype.add = function add(schema, definition) {\n  this.__schemas__[schema] = definition;\n  compile(this);\n  return this;\n};\n\n\n/** chainable\n * LinkifyIt#set(options)\n * - options (Object): { fuzzyLink|fuzzyEmail|fuzzyIP: true|false }\n *\n * Set recognition options for links without schema.\n **/\nLinkifyIt.prototype.set = function set(options) {\n  this.__opts__ = assign(this.__opts__, options);\n  return this;\n};\n\n\n/**\n * LinkifyIt#test(text) -> Boolean\n *\n * Searches linkifiable pattern and returns `true` on success or `false` on fail.\n **/\nLinkifyIt.prototype.test = function test(text) {\n  // Reset scan cache\n  this.__text_cache__ = text;\n  this.__index__      = -1;\n\n  if (!text.length) { return false; }\n\n  var m, ml, me, len, shift, next, re, tld_pos, at_pos;\n\n  // try to scan for link with schema - that's the most simple rule\n  if (this.re.schema_test.test(text)) {\n    re = this.re.schema_search;\n    re.lastIndex = 0;\n    while ((m = re.exec(text)) !== null) {\n      len = this.testSchemaAt(text, m[2], re.lastIndex);\n      if (len) {\n        this.__schema__     = m[2];\n        this.__index__      = m.index + m[1].length;\n        this.__last_index__ = m.index + m[0].length + len;\n        break;\n      }\n    }\n  }\n\n  if (this.__opts__.fuzzyLink && this.__compiled__['http:']) {\n    // guess schemaless links\n    tld_pos = text.search(this.re.host_fuzzy_test);\n    if (tld_pos >= 0) {\n      // if tld is located after found link - no need to check fuzzy pattern\n      if (this.__index__ < 0 || tld_pos < this.__index__) {\n        if ((ml = text.match(this.__opts__.fuzzyIP ? this.re.link_fuzzy : this.re.link_no_ip_fuzzy)) !== null) {\n\n          shift = ml.index + ml[1].length;\n\n          if (this.__index__ < 0 || shift < this.__index__) {\n            this.__schema__     = '';\n            this.__index__      = shift;\n            this.__last_index__ = ml.index + ml[0].length;\n          }\n        }\n      }\n    }\n  }\n\n  if (this.__opts__.fuzzyEmail && this.__compiled__['mailto:']) {\n    // guess schemaless emails\n    at_pos = text.indexOf('@');\n    if (at_pos >= 0) {\n      // We can't skip this check, because this cases are possible:\n      // 192.168.1.1@gmail.com, my.in@example.com\n      if ((me = text.match(this.re.email_fuzzy)) !== null) {\n\n        shift = me.index + me[1].length;\n        next  = me.index + me[0].length;\n\n        if (this.__index__ < 0 || shift < this.__index__ ||\n            (shift === this.__index__ && next > this.__last_index__)) {\n          this.__schema__     = 'mailto:';\n          this.__index__      = shift;\n          this.__last_index__ = next;\n        }\n      }\n    }\n  }\n\n  return this.__index__ >= 0;\n};\n\n\n/**\n * LinkifyIt#pretest(text) -> Boolean\n *\n * Very quick check, that can give false positives. Returns true if link MAY BE\n * can exists. Can be used for speed optimization, when you need to check that\n * link NOT exists.\n **/\nLinkifyIt.prototype.pretest = function pretest(text) {\n  return this.re.pretest.test(text);\n};\n\n\n/**\n * LinkifyIt#testSchemaAt(text, name, position) -> Number\n * - text (String): text to scan\n * - name (String): rule (schema) name\n * - position (Number): text offset to check from\n *\n * Similar to [[LinkifyIt#test]] but checks only specific protocol tail exactly\n * at given position. Returns length of found pattern (0 on fail).\n **/\nLinkifyIt.prototype.testSchemaAt = function testSchemaAt(text, schema, pos) {\n  // If not supported schema check requested - terminate\n  if (!this.__compiled__[schema.toLowerCase()]) {\n    return 0;\n  }\n  return this.__compiled__[schema.toLowerCase()].validate(text, pos, this);\n};\n\n\n/**\n * LinkifyIt#match(text) -> Array|null\n *\n * Returns array of found link descriptions or `null` on fail. We strongly\n * recommend to use [[LinkifyIt#test]] first, for best speed.\n *\n * ##### Result match description\n *\n * - __schema__ - link schema, can be empty for fuzzy links, or `//` for\n *   protocol-neutral  links.\n * - __index__ - offset of matched text\n * - __lastIndex__ - index of next char after mathch end\n * - __raw__ - matched text\n * - __text__ - normalized text\n * - __url__ - link, generated from matched text\n **/\nLinkifyIt.prototype.match = function match(text) {\n  var shift = 0, result = [];\n\n  // Try to take previous element from cache, if .test() called before\n  if (this.__index__ >= 0 && this.__text_cache__ === text) {\n    result.push(createMatch(this, shift));\n    shift = this.__last_index__;\n  }\n\n  // Cut head if cache was used\n  var tail = shift ? text.slice(shift) : text;\n\n  // Scan string until end reached\n  while (this.test(tail)) {\n    result.push(createMatch(this, shift));\n\n    tail = tail.slice(this.__last_index__);\n    shift += this.__last_index__;\n  }\n\n  if (result.length) {\n    return result;\n  }\n\n  return null;\n};\n\n\n/** chainable\n * LinkifyIt#tlds(list [, keepOld]) -> this\n * - list (Array): list of tlds\n * - keepOld (Boolean): merge with current list if `true` (`false` by default)\n *\n * Load (or merge) new tlds list. Those are user for fuzzy links (without prefix)\n * to avoid false positives. By default this algorythm used:\n *\n * - hostname with any 2-letter root zones are ok.\n * - biz|com|edu|gov|net|org|pro|web|xxx|aero|asia|coop|info|museum|name|shop|рф\n *   are ok.\n * - encoded (`xn--...`) root zones are ok.\n *\n * If list is replaced, then exact match for 2-chars root zones will be checked.\n **/\nLinkifyIt.prototype.tlds = function tlds(list, keepOld) {\n  list = Array.isArray(list) ? list : [ list ];\n\n  if (!keepOld) {\n    this.__tlds__ = list.slice();\n    this.__tlds_replaced__ = true;\n    compile(this);\n    return this;\n  }\n\n  this.__tlds__ = this.__tlds__.concat(list)\n                                  .sort()\n                                  .filter(function (el, idx, arr) {\n                                    return el !== arr[idx - 1];\n                                  })\n                                  .reverse();\n\n  compile(this);\n  return this;\n};\n\n/**\n * LinkifyIt#normalize(match)\n *\n * Default normalizer (if schema does not define it's own).\n **/\nLinkifyIt.prototype.normalize = function normalize(match) {\n\n  // Do minimal possible changes by default. Need to collect feedback prior\n  // to move forward https://github.com/markdown-it/linkify-it/issues/1\n\n  if (!match.schema) { match.url = 'http://' + match.url; }\n\n  if (match.schema === 'mailto:' && !/^mailto:/i.test(match.url)) {\n    match.url = 'mailto:' + match.url;\n  }\n};\n\n\n/**\n * LinkifyIt#onCompile()\n *\n * Override to modify basic RegExp-s.\n **/\nLinkifyIt.prototype.onCompile = function onCompile() {\n};\n\n\nmodule.exports = LinkifyIt;\n","\"use strict\";\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst p_defer_1 = __importDefault(require(\"p-defer\"));\nfunction mapAgeCleaner(map, property = 'maxAge') {\n    let processingKey;\n    let processingTimer;\n    let processingDeferred;\n    const cleanup = () => __awaiter(this, void 0, void 0, function* () {\n        if (processingKey !== undefined) {\n            // If we are already processing an item, we can safely exit\n            return;\n        }\n        const setupTimer = (item) => __awaiter(this, void 0, void 0, function* () {\n            processingDeferred = p_defer_1.default();\n            const delay = item[1][property] - Date.now();\n            if (delay <= 0) {\n                // Remove the item immediately if the delay is equal to or below 0\n                map.delete(item[0]);\n                processingDeferred.resolve();\n                return;\n            }\n            // Keep track of the current processed key\n            processingKey = item[0];\n            processingTimer = setTimeout(() => {\n                // Remove the item when the timeout fires\n                map.delete(item[0]);\n                if (processingDeferred) {\n                    processingDeferred.resolve();\n                }\n            }, delay);\n            // tslint:disable-next-line:strict-type-predicates\n            if (typeof processingTimer.unref === 'function') {\n                // Don't hold up the process from exiting\n                processingTimer.unref();\n            }\n            return processingDeferred.promise;\n        });\n        try {\n            for (const entry of map) {\n                yield setupTimer(entry);\n            }\n        }\n        catch (_a) {\n            // Do nothing if an error occurs, this means the timer was cleaned up and we should stop processing\n        }\n        processingKey = undefined;\n    });\n    const reset = () => {\n        processingKey = undefined;\n        if (processingTimer !== undefined) {\n            clearTimeout(processingTimer);\n            processingTimer = undefined;\n        }\n        if (processingDeferred !== undefined) { // tslint:disable-line:early-exit\n            processingDeferred.reject(undefined);\n            processingDeferred = undefined;\n        }\n    };\n    const originalSet = map.set.bind(map);\n    map.set = (key, value) => {\n        if (map.has(key)) {\n            // If the key already exist, remove it so we can add it back at the end of the map.\n            map.delete(key);\n        }\n        // Call the original `map.set`\n        const result = originalSet(key, value);\n        // If we are already processing a key and the key added is the current processed key, stop processing it\n        if (processingKey && processingKey === key) {\n            reset();\n        }\n        // Always run the cleanup method in case it wasn't started yet\n        cleanup(); // tslint:disable-line:no-floating-promises\n        return result;\n    };\n    cleanup(); // tslint:disable-line:no-floating-promises\n    return map;\n}\nexports.default = mapAgeCleaner;\n// Add support for CJS\nmodule.exports = mapAgeCleaner;\nmodule.exports.default = mapAgeCleaner;\n"],"names":["module","exports","opts","re","src_Any","require","src_Cc","src_Z","src_P","src_ZPCc","join","src_ZCc","src_pseudo_letter","src_ip4","src_auth","src_port","src_host_terminator","src_path","src_email_name","src_xn","src_domain_root","src_domain","src_host","tpl_host_fuzzy","tpl_host_no_ip_fuzzy","src_host_strict","tpl_host_fuzzy_strict","src_host_port_strict","tpl_host_port_fuzzy_strict","tpl_host_port_no_ip_fuzzy_strict","tpl_host_fuzzy_test","tpl_email_fuzzy","tpl_link_fuzzy","tpl_link_no_ip_fuzzy","assign","obj","Array","prototype","slice","call","arguments","forEach","source","Object","keys","key","_class","toString","isFunction","escapeRE","str","replace","defaultOptions","fuzzyLink","fuzzyEmail","fuzzyIP","defaultSchemas","validate","text","pos","self","tail","http","RegExp","test","match","length","no_http","mailto","tlds_default","split","compile","__opts__","tlds","__tlds__","untpl","tpl","src_tlds","onCompile","__tlds_replaced__","push","email_fuzzy","link_fuzzy","link_no_ip_fuzzy","host_fuzzy_test","aliases","schemaError","name","val","Error","__compiled__","__schemas__","compiled","link","createValidator","normalize","isString","alias","slist","filter","map","schema_test","schema_search","pretest","__index__","__text_cache__","resetScanCache","Match","shift","start","end","__last_index__","this","schema","__schema__","toLowerCase","index","lastIndex","raw","url","createMatch","LinkifyIt","schemas","options","reduce","acc","k","hasOwnProperty","add","definition","set","m","ml","me","len","next","tld_pos","exec","testSchemaAt","search","indexOf","result","list","keepOld","isArray","concat","sort","el","idx","arr","reverse","_typeof","o","Symbol","iterator","constructor","_createForOfIteratorHelper","r","e","t","a","_arrayLikeToArray","from","_unsupportedIterableToArray","_n","F","s","n","done","value","f","TypeError","u","return","_regeneratorRuntime","defineProperty","i","c","asyncIterator","toStringTag","define","enumerable","configurable","writable","wrap","Generator","create","Context","makeInvokeMethod","tryCatch","type","arg","h","l","y","GeneratorFunction","GeneratorFunctionPrototype","p","d","getPrototypeOf","v","values","g","defineIteratorMethods","_invoke","AsyncIterator","invoke","resolve","__await","then","callInvokeWithMethodAndArg","method","delegate","maybeInvokeDelegate","sent","_sent","dispatchException","abrupt","resultName","nextLoc","pushTryEntry","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","resetTryEntry","completion","reset","isNaN","displayName","isGeneratorFunction","mark","setPrototypeOf","__proto__","awrap","async","Promise","pop","prev","charAt","stop","rval","handle","complete","finish","catch","delegateYield","__awaiter","thisArg","_arguments","P","generator","reject","fulfilled","step","rejected","apply","__importDefault","mod","__esModule","p_defer_1","mapAgeCleaner","processingKey","processingTimer","processingDeferred","_this","property","undefined","cleanup","_callee2","setupTimer","_iterator","_step","entry","_this2","_context2","item","_callee","delay","_context","default","Date","now","delete","setTimeout","unref","promise","t0","t1","originalSet","bind","has","clearTimeout"],"sourceRoot":""}