{"version":3,"sources":["webpack:///./node_modules/linkify-it/lib/re.js","webpack:///./node_modules/linkify-it/index.js"],"names":["src_Any","exports","source","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","sources","Array","prototype","slice","call","arguments","forEach","Object","keys","key","_class","toString","isString","isObject","isRegExp","isFunction","escapeRE","str","replace","defaultOptions","fuzzyLink","fuzzyEmail","fuzzyIP","isOptionsObj","reduce","acc","k","hasOwnProperty","defaultSchemas","validate","text","pos","self","tail","re","http","RegExp","test","match","length","no_http","mailto","tlds_2ch_src_re","tlds_default","split","resetScanCache","__index__","__text_cache__","createValidator","createNormalizer","normalize","compile","tlds","__tlds__","untpl","tpl","src_tlds","__tlds_replaced__","push","email_fuzzy","link_fuzzy","link_no_ip_fuzzy","host_fuzzy_test","aliases","schemaError","name","val","Error","__compiled__","__schemas__","compiled","link","alias","slist","filter","map","schema_test","schema_search","pretest","Match","shift","start","end","__last_index__","this","schema","__schema__","toLowerCase","index","lastIndex","raw","url","createMatch","LinkifyIt","schemas","options","__opts__","add","definition","set","m","ml","me","len","next","tld_pos","at_pos","exec","testSchemaAt","search","indexOf","result","list","keepOld","isArray","concat","sort","el","idx","arr","reverse","module"],"mappings":"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","file":"js/chunk-cab507be.1b791ed5.js","sourcesContent":["'use strict';\n\n// Use direct extract instead of `regenerate` to reduse browserified size\nvar src_Any = exports.src_Any = require('uc.micro/properties/Any/regex').source;\nvar src_Cc  = exports.src_Cc = require('uc.micro/categories/Cc/regex').source;\nvar src_Z   = exports.src_Z  = require('uc.micro/categories/Z/regex').source;\nvar src_P   = exports.src_P  = require('uc.micro/categories/P/regex').source;\n\n// \\p{\\Z\\P\\Cc\\CF} (white spaces + control + format + punctuation)\nvar src_ZPCc = exports.src_ZPCc = [ src_Z, src_P, src_Cc ].join('|');\n\n// \\p{\\Z\\Cc} (white spaces + control)\nvar src_ZCc = exports.src_ZCc = [ src_Z, src_Cc ].join('|');\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 `_`)\nvar src_pseudo_letter       = '(?:(?!>|<|' + src_ZPCc + ')' + 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\nvar src_ip4 = exports.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 [@/] in user/pass to avoid wrong domain fetch.\nexports.src_auth    = '(?:(?:(?!' + src_ZCc + '|[@/]).)+@)?';\n\nvar src_port = exports.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\nvar src_host_terminator = exports.src_host_terminator =\n\n  '(?=$|>|<|' + src_ZPCc + ')(?!-|_|:\\\\d|\\\\.-|\\\\.(?!$|' + src_ZPCc + '))';\n\nvar src_path = exports.src_path =\n\n  '(?:' +\n    '[/?#]' +\n      '(?:' +\n        '(?!' + src_ZCc + '|[()[\\\\]{}.,\"\\'?!\\\\-<>]).|' +\n        '\\\\[(?:(?!' + src_ZCc + '|\\\\]).)*\\\\]|' +\n        '\\\\((?:(?!' + src_ZCc + '|[)]).)*\\\\)|' +\n        '\\\\{(?:(?!' + src_ZCc + '|[}]).)*\\\\}|' +\n        '\\\\\"(?:(?!' + src_ZCc + '|[\"]).)+\\\\\"|' +\n        \"\\\\'(?:(?!\" + src_ZCc + \"|[']).)+\\\\'|\" +\n        \"\\\\'(?=\" + src_pseudo_letter + ').|' +  // allow `I'm_king` if no pair found\n        '\\\\.{2,3}[a-zA-Z0-9%/]|' + // github has ... in commit range links. Restrict to\n                                   // - english\n                                   // - percent-encoded\n                                   // - parts of file path\n                                   // until more examples found.\n        '\\\\.(?!' + src_ZCc + '|[.]).|' +\n        '\\\\-(?!--(?:[^-]|$))(?:-*)|' +  // `---` => long dash, terminate\n        '\\\\,(?!' + src_ZCc + ').|' +      // allow `,,,` in paths\n        '\\\\!(?!' + src_ZCc + '|[!]).|' +\n        '\\\\?(?!' + src_ZCc + '|[?]).' +\n      ')+' +\n    '|\\\\/' +\n  ')?';\n\nvar src_email_name = exports.src_email_name =\n\n  '[\\\\-;:&=\\\\+\\\\$,\\\\\"\\\\.a-zA-Z0-9_]+';\n\nvar src_xn = exports.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\nvar src_domain_root = exports.src_domain_root =\n\n  // Allow letters & digits (http://test1)\n  '(?:' +\n    src_xn +\n    '|' +\n    src_pseudo_letter + '{1,63}' +\n  ')';\n\nvar src_domain = exports.src_domain =\n\n  '(?:' +\n    src_xn +\n    '|' +\n    '(?:' + src_pseudo_letter + ')' +\n    '|' +\n    // don't allow `--` in domain names, because:\n    // - that can conflict with markdown &mdash; / &ndash;\n    // - nobody use those anyway\n    '(?:' + src_pseudo_letter + '(?:-(?!-)|' + src_pseudo_letter + '){0,61}' + src_pseudo_letter + ')' +\n  ')';\n\nvar src_host = exports.src_host =\n\n  '(?:' +\n  // Don't need IP check, because digits are already allowed in normal domain names\n  //   src_ip4 +\n  // '|' +\n    '(?:(?:(?:' + src_domain + ')\\\\.)*' + src_domain_root + ')' +\n  ')';\n\nvar tpl_host_fuzzy = exports.tpl_host_fuzzy =\n\n  '(?:' +\n    src_ip4 +\n  '|' +\n    '(?:(?:(?:' + src_domain + ')\\\\.)+(?:%TLDS%))' +\n  ')';\n\nvar tpl_host_no_ip_fuzzy = exports.tpl_host_no_ip_fuzzy =\n\n  '(?:(?:(?:' + src_domain + ')\\\\.)+(?:%TLDS%))';\n\nexports.src_host_strict =\n\n  src_host + src_host_terminator;\n\nvar tpl_host_fuzzy_strict = exports.tpl_host_fuzzy_strict =\n\n  tpl_host_fuzzy + src_host_terminator;\n\nexports.src_host_port_strict =\n\n  src_host + src_port + src_host_terminator;\n\nvar tpl_host_port_fuzzy_strict = exports.tpl_host_port_fuzzy_strict =\n\n  tpl_host_fuzzy + src_port + src_host_terminator;\n\nvar tpl_host_port_no_ip_fuzzy_strict = exports.tpl_host_port_no_ip_fuzzy_strict =\n\n  tpl_host_no_ip_fuzzy + src_port + src_host_terminator;\n\n\n////////////////////////////////////////////////////////////////////////////////\n// Main rules\n\n// Rude test fuzzy links by host, for quick deny\nexports.tpl_host_fuzzy_test =\n\n  'localhost|www\\\\.|\\\\.\\\\d{1,3}\\\\.|(?:\\\\.(?:%TLDS%)(?:' + src_ZPCc + '|>|$))';\n\nexports.tpl_email_fuzzy =\n\n    '(^|<|>|\\\\(|' + src_ZCc + ')(' + src_email_name + '@' + tpl_host_fuzzy_strict + ')';\n\nexports.tpl_link_fuzzy =\n    // Fuzzy link can't be prepended with .:/\\- and non punctuation.\n    // but can start with > (markdown blockquote)\n    '(^|(?![.:/\\\\-_@])(?:[$+<=>^`|]|' + src_ZPCc + '))' +\n    '((?![$+<=>^`|])' + tpl_host_port_fuzzy_strict + src_path + ')';\n\nexports.tpl_link_no_ip_fuzzy =\n    // Fuzzy link can't be prepended with .:/\\- and non punctuation.\n    // but can start with > (markdown blockquote)\n    '(^|(?![.:/\\\\-_@])(?:[$+<=>^`|]|' + src_ZPCc + '))' +\n    '((?![$+<=>^`|])' + tpl_host_port_no_ip_fuzzy_strict + src_path + ')';\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 = assign({}, require('./lib/re'));\n\n  // Define dynamic patterns\n  var tlds = self.__tlds__.slice();\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('(^|(?!_)(?:[><]|' + re.src_ZPCc + '))(' + slist + ')', 'i');\n  self.re.schema_search = RegExp('(^|(?!_)(?:[><]|' + re.src_ZPCc + '))(' + slist + ')', 'ig');\n\n  self.re.pretest       = RegExp(\n                            '(' + self.re.schema_test.source + ')|' +\n                            '(' + self.re.host_fuzzy_test.source + ')|' +\n                            '@',\n                            'i');\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\nmodule.exports = LinkifyIt;\n"],"sourceRoot":""}