@vc-shell/framework 2.0.0-alpha.9 → 2.0.0-pr221.637b802

package/dist/chunks/vendor-linkify-it-LzoUhj6C.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vendor-linkify-it-LzoUhj6C.js","sources":["../../../node_modules/linkify-it/lib/re.mjs","../../../node_modules/linkify-it/index.mjs"],"sourcesContent":["import { Any, Cc, Z, P } from 'uc.micro'\n\nexport default function (opts) {\n  const re = {}\n  opts = opts || {}\n\n  re.src_Any = Any.source\n  re.src_Cc = Cc.source\n  re.src_Z = Z.source\n  re.src_P = P.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  const 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  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 + ')' +\n    '(?!' + (opts['---'] ? '-(?!--)|' : '-|') + '_|:\\\\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\n          // allow `I'm_king` if no pair found\n          \"\\\\'(?=\" + re.src_pseudo_letter + '|[-])|' +\n\n          // 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          '\\\\.{2,}[a-zA-Z0-9%/&]|' +\n\n          '\\\\.(?!' + re.src_ZCc + '|[.]|$)|' +\n          (opts['---']\n            ? '\\\\-(?!--(?:[^-]|$))(?:-*)|' // `---` => long dash, terminate\n            : '\\\\-+|'\n          ) +\n          // allow `,,,` in paths\n          ',(?!' + re.src_ZCc + '|$)|' +\n\n          // allow `;` if not followed by space-like char\n          ';(?!' + re.src_ZCc + '|$)|' +\n\n          // allow `!!!` in paths, but not at the end\n          '\\\\!+(?!' + re.src_ZCc + '|[!]|$)|' +\n\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  // Main rules\n  //\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","import reFactory from './lib/re.mjs'\n\n//\n// Helpers\n//\n\n// Merge objects\n//\nfunction assign (obj /* from1, from2, from3, ... */) {\n  const 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\nfunction escapeRE (str) { return str.replace(/[.?*+^$[\\]\\\\(){}|-]/g, '\\\\$&') }\n\n//\n\nconst defaultOptions = {\n  fuzzyLink: true,\n  fuzzyEmail: true,\n  fuzzyIP: false\n}\n\nfunction isOptionsObj (obj) {\n  return Object.keys(obj || {}).reduce(function (acc, k) {\n    /* eslint-disable-next-line no-prototype-builtins */\n    return acc || defaultOptions.hasOwnProperty(k)\n  }, false)\n}\n\nconst defaultSchemas = {\n  'http:': {\n    validate: function (text, pos, self) {\n      const 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      const 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      const 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// RE pattern for 2-character tlds (autogenerated by ./support/tlds_2char_gen.js)\n/* eslint-disable-next-line max-len */\nconst 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\nconst tlds_default = 'biz|com|edu|gov|net|org|pro|web|xxx|aero|asia|coop|info|museum|name|shop|рф'.split('|')\n\nfunction resetScanCache (self) {\n  self.__index__ = -1\n  self.__text_cache__ = ''\n}\n\nfunction createValidator (re) {\n  return function (text, pos) {\n    const 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  // Load & clone RE patterns.\n  const re = self.re = reFactory(self.__opts__)\n\n  // Define dynamic patterns\n  const 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  const 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    const val = self.__schemas__[name]\n\n    // skip disabled methods\n    if (val === null) { return }\n\n    const 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  const 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  self.re.schema_at_start = RegExp('^' + self.re.schema_search.source, 'i')\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  const start = self.__index__\n  const end = self.__last_index__\n  const 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  const match = new Match(self, shift)\n\n  self.__compiled__[match.schema].normalize(match, self)\n\n  return match\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/** 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/** 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 * 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  let 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          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        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 * 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 * 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 * 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  const result = []\n  let shift = 0\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  let 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 * LinkifyIt#matchAtStart(text) -> Match|null\n *\n * Returns fully-formed (not fuzzy) link if it starts at the beginning\n * of the string, and null otherwise.\n **/\nLinkifyIt.prototype.matchAtStart = function matchAtStart (text) {\n  // Reset scan cache\n  this.__text_cache__ = text\n  this.__index__ = -1\n\n  if (!text.length) return null\n\n  const m = this.re.schema_at_start.exec(text)\n  if (!m) return null\n\n  const len = this.testSchemaAt(text, m[2], m[0].length)\n  if (!len) return null\n\n  this.__schema__ = m[2]\n  this.__index__ = m.index + m[1].length\n  this.__last_index__ = m.index + m[0].length + len\n\n  return createMatch(this, 0)\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  // 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 * LinkifyIt#onCompile()\n *\n * Override to modify basic RegExp-s.\n **/\nLinkifyIt.prototype.onCompile = function onCompile () {\n}\n\nexport default LinkifyIt\n"],"names":["reFactory","opts","re","Any","Cc","Z","P","text_separators","assign","obj","source","key","_class","isString","isObject","isRegExp","isFunction","escapeRE","str","defaultOptions","isOptionsObj","acc","k","defaultSchemas","text","pos","self","tail","tlds_2ch_src_re","tlds_default","resetScanCache","createValidator","createNormalizer","match","compile","tlds","untpl","tpl","aliases","schemaError","name","val","compiled","alias","slist","Match","shift","start","end","createMatch","LinkifyIt","schemas","options","schema","definition","m","ml","me","len","next","tld_pos","at_pos","result","list","keepOld","el","idx","arr"],"mappings":"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","x_google_ignoreList":[0,1]}

package/dist/chunks/vendor-linkifyjs-dCH9UYes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vendor-linkifyjs-dCH9UYes.js","sources":["../../../node_modules/linkifyjs/dist/linkify.mjs"],"sourcesContent":["// THIS FILE IS AUTOMATICALLY GENERATED DO NOT EDIT DIRECTLY\n// See update-tlds.js for encoding/decoding format\n// https://data.iana.org/TLD/tlds-alpha-by-domain.txt\nconst encodedTlds = 'aaa1rp3bb0ott3vie4c1le2ogado5udhabi7c0ademy5centure6ountant0s9o1tor4d0s1ult4e0g1ro2tna4f0l1rica5g0akhan5ency5i0g1rbus3force5tel5kdn3l0ibaba4pay4lfinanz6state5y2sace3tom5m0azon4ericanexpress7family11x2fam3ica3sterdam8nalytics7droid5quan4z2o0l2partments8p0le4q0uarelle8r0ab1mco4chi3my2pa2t0e3s0da2ia2sociates9t0hleta5torney7u0ction5di0ble3o3spost5thor3o0s4w0s2x0a2z0ure5ba0by2idu3namex4d1k2r0celona5laycard4s5efoot5gains6seball5ketball8uhaus5yern5b0c1t1va3cg1n2d1e0ats2uty4er2rlin4st0buy5t2f1g1h0arti5i0ble3d1ke2ng0o3o1z2j1lack0friday9ockbuster8g1omberg7ue3m0s1w2n0pparibas9o0ats3ehringer8fa2m1nd2o0k0ing5sch2tik2on4t1utique6x2r0adesco6idgestone9oadway5ker3ther5ussels7s1t1uild0ers6siness6y1zz3v1w1y1z0h3ca0b1fe2l0l1vinklein9m0era3p2non3petown5ital0one8r0avan4ds2e0er0s4s2sa1e1h1ino4t0ering5holic7ba1n1re3c1d1enter4o1rn3f0a1d2g1h0anel2nel4rity4se2t2eap3intai5ristmas6ome4urch5i0priani6rcle4sco3tadel4i0c2y3k1l0aims4eaning6ick2nic1que6othing5ud3ub0med6m1n1o0ach3des3ffee4llege4ogne5m0mbank4unity6pany2re3uter5sec4ndos3struction8ulting7tact3ractors9oking4l1p2rsica5untry4pon0s4rses6pa2r0edit0card4union9icket5own3s1uise0s6u0isinella9v1w1x1y0mru3ou3z2dad1nce3ta1e1ing3sun4y2clk3ds2e0al0er2s3gree4livery5l1oitte5ta3mocrat6ntal2ist5si0gn4v2hl2iamonds6et2gital5rect0ory7scount3ver5h2y2j1k1m1np2o0cs1tor4g1mains5t1wnload7rive4tv2ubai3nlop4pont4rban5vag2r2z2earth3t2c0o2deka3u0cation8e1g1mail3erck5nergy4gineer0ing9terprises10pson4quipment8r0icsson6ni3s0q1tate5t1u0rovision8s2vents5xchange6pert3osed4ress5traspace10fage2il1rwinds6th3mily4n0s2rm0ers5shion4t3edex3edback6rrari3ero6i0delity5o2lm2nal1nce1ial7re0stone6mdale6sh0ing5t0ness6j1k1lickr3ghts4r2orist4wers5y2m1o0o0d1tball6rd1ex2sale4um3undation8x2r0ee1senius7l1ogans4ntier7tr2ujitsu5n0d2rniture7tbol5yi3ga0l0lery3o1up4me0s3p1rden4y2b0iz3d0n2e0a1nt0ing5orge5f1g0ee3h1i0ft0s3ves2ing5l0ass3e1obal2o4m0ail3bh2o1x2n1odaddy5ld0point6f2o0dyear5g0le4p1t1v2p1q1r0ainger5phics5tis4een3ipe3ocery4up4s1t1u0cci3ge2ide2tars5ru3w1y2hair2mburg5ngout5us3bo2dfc0bank7ealth0care8lp1sinki6re1mes5iphop4samitsu7tachi5v2k0t2m1n1ockey4ldings5iday5medepot5goods5s0ense7nda3rse3spital5t0ing5t0els3mail5use3w2r1sbc3t1u0ghes5yatt3undai7ibm2cbc2e1u2d1e0ee3fm2kano4l1m0amat4db2mo0bilien9n0c1dustries8finiti5o2g1k1stitute6urance4e4t0ernational10uit4vestments10o1piranga7q1r0ish4s0maili5t0anbul7t0au2v3jaguar4va3cb2e0ep2tzt3welry6io2ll2m0p2nj2o0bs1urg4t1y2p0morgan6rs3uegos4niper7kaufen5ddi3e0rryhotels6properties14fh2g1h1i0a1ds2m1ndle4tchen5wi3m1n1oeln3matsu5sher5p0mg2n2r0d1ed3uokgroup8w1y0oto4z2la0caixa5mborghini8er3nd0rover6xess5salle5t0ino3robe5w0yer5b1c1ds2ease3clerc5frak4gal2o2xus4gbt3i0dl2fe0insurance9style7ghting6ke2lly3mited4o2ncoln4k2ve1ing5k1lc1p2oan0s3cker3us3l1ndon4tte1o3ve3pl0financial11r1s1t0d0a3u0ndbeck6xe1ury5v1y2ma0drid4if1son4keup4n0agement7go3p1rket0ing3s4riott5shalls7ttel5ba2c0kinsey7d1e0d0ia3et2lbourne7me1orial6n0u2rckmsd7g1h1iami3crosoft7l1ni1t2t0subishi9k1l0b1s2m0a2n1o0bi0le4da2e1i1m1nash3ey2ster5rmon3tgage6scow4to0rcycles9v0ie4p1q1r1s0d2t0n1r2u0seum3ic4v1w1x1y1z2na0b1goya4me2vy3ba2c1e0c1t0bank4flix4work5ustar5w0s2xt0direct7us4f0l2g0o2hk2i0co2ke1on3nja3ssan1y5l1o0kia3rton4w0ruz3tv4p1r0a1w2tt2u1yc2z2obi1server7ffice5kinawa6layan0group9lo3m0ega4ne1g1l0ine5oo2pen3racle3nge4g0anic5igins6saka4tsuka4t2vh3pa0ge2nasonic7ris2s1tners4s1y3y2ccw3e0t2f0izer5g1h0armacy6d1ilips5one2to0graphy6s4ysio5ics1tet2ures6d1n0g1k2oneer5zza4k1l0ace2y0station9umbing5s3m1n0c2ohl2ker3litie5rn2st3r0axi3ess3ime3o0d0uctions8f1gressive8mo2perties3y5tection8u0dential9s1t1ub2w0c2y2qa1pon3uebec3st5racing4dio4e0ad1lestate6tor2y4cipes5d0stone5umbrella9hab3ise0n3t2liance6n0t0als5pair3ort3ublican8st0aurant8view0s5xroth6ich0ardli6oh3l1o1p2o0cks3deo3gers4om3s0vp3u0gby3hr2n2w0e2yukyu6sa0arland6fe0ty4kura4le1on3msclub4ung5ndvik0coromant12ofi4p1rl2s1ve2xo3b0i1s2c0b1haeffler7midt4olarships8ol3ule3warz5ience5ot3d1e0arch3t2cure1ity6ek2lect4ner3rvices6ven3w1x0y3fr2g1h0angrila6rp3ell3ia1ksha5oes2p0ping5uji3w3i0lk2na1gles5te3j1k0i0n2y0pe4l0ing4m0art3ile4n0cf3o0ccer3ial4ftbank4ware6hu2lar2utions7ng1y2y2pa0ce3ort2t3r0l2s1t0ada2ples4r1tebank4farm7c0group6ockholm6rage3e3ream4udio2y3yle4u0cks3pplies3y2ort5rf1gery5zuki5v1watch4iss4x1y0dney4stems6z2tab1ipei4lk2obao4rget4tamotors6r2too4x0i3c0i2d0k2eam2ch0nology8l1masek5nnis4va3f1g1h0d1eater2re6iaa2ckets5enda4ps2res2ol4j0maxx4x2k0maxx5l1m0all4n1o0day3kyo3ols3p1ray3shiba5tal3urs3wn2yota3s3r0ade1ing4ining5vel0ers0insurance16ust3v2t1ube2i1nes3shu4v0s2w1z2ua1bank3s2g1k1nicom3versity8o2ol2ps2s1y1z2va0cations7na1guard7c1e0gas3ntures6risign5mögensberater2ung14sicherung10t2g1i0ajes4deo3g1king4llas4n1p1rgin4sa1ion4va1o3laanderen9n1odka3lvo3te1ing3o2yage5u2wales2mart4ter4ng0gou5tch0es6eather0channel12bcam3er2site5d0ding5ibo2r3f1hoswho6ien2ki2lliamhill9n0dows4e1ners6me2olterskluwer11odside6rk0s2ld3w2s1tc1f3xbox3erox4ihuan4n2xx2yz3yachts4hoo3maxun5ndex5e1odobashi7ga2kohama6u0tube6t1un3za0ppos4ra3ero3ip2m1one3uerich6w2';\n// Internationalized domain names containing non-ASCII\nconst encodedUtlds = 'ελ1υ2бг1ел3дети4ею2католик6ом3мкд2он1сква6онлайн5рг3рус2ф2сайт3рб3укр3қаз3հայ3ישראל5קום3ابوظبي5رامكو5لاردن4بحرين5جزائر5سعودية6عليان5مغرب5مارات5یران5بارت2زار4يتك3ھارت5تونس4سودان3رية5شبكة4عراق2ب2مان4فلسطين6قطر3كاثوليك6وم3مصر2ليسيا5وريتانيا7قع4همراه5پاکستان7ڀارت4कॉम3नेट3भारत0म्3ोत5संगठन5বাংলা5ভারত2ৰত4ਭਾਰਤ4ભારત4ଭାରତ4இந்தியா6லங்கை6சிங்கப்பூர்11భారత్5ಭಾರತ4ഭാരതം5ලංකා4คอม3ไทย3ລາວ3გე2みんな3アマゾン4クラウド4グーグル4コム2ストア3セール3ファッション6ポイント4世界2中信1国1國1文网3亚马逊3企业2佛山2信息2健康2八卦2公司1益2台湾1灣2商城1店1标2嘉里0大酒店5在线2大拿2天主教3娱乐2家電2广东2微博2慈善2我爱你3手机2招聘2政务1府2新加坡2闻2时尚2書籍2机构2淡马锡3游戏2澳門2点看2移动2组织机构4网址1店1站1络2联通2谷歌2购物2通販2集团2電訊盈科4飞利浦3食品2餐厅2香格里拉3港2닷넷1컴2삼성2한국2';\n\n/**\n * Finite State Machine generation utilities\n */\n\n/**\n * @template T\n * @typedef {{ [group: string]: T[] }} Collections\n */\n\n/**\n * @typedef {{ [group: string]: true }} Flags\n */\n\n// Keys in scanner Collections instances\nconst numeric = 'numeric';\nconst ascii = 'ascii';\nconst alpha = 'alpha';\nconst asciinumeric = 'asciinumeric';\nconst alphanumeric = 'alphanumeric';\nconst domain = 'domain';\nconst emoji = 'emoji';\nconst scheme = 'scheme';\nconst slashscheme = 'slashscheme';\nconst whitespace = 'whitespace';\n\n/**\n * @template T\n * @param {string} name\n * @param {Collections<T>} groups to register in\n * @returns {T[]} Current list of tokens in the given collection\n */\nfunction registerGroup(name, groups) {\n  if (!(name in groups)) {\n    groups[name] = [];\n  }\n  return groups[name];\n}\n\n/**\n * @template T\n * @param {T} t token to add\n * @param {Collections<T>} groups\n * @param {Flags} flags\n */\nfunction addToGroups(t, flags, groups) {\n  if (flags[numeric]) {\n    flags[asciinumeric] = true;\n    flags[alphanumeric] = true;\n  }\n  if (flags[ascii]) {\n    flags[asciinumeric] = true;\n    flags[alpha] = true;\n  }\n  if (flags[asciinumeric]) {\n    flags[alphanumeric] = true;\n  }\n  if (flags[alpha]) {\n    flags[alphanumeric] = true;\n  }\n  if (flags[alphanumeric]) {\n    flags[domain] = true;\n  }\n  if (flags[emoji]) {\n    flags[domain] = true;\n  }\n  for (const k in flags) {\n    const group = registerGroup(k, groups);\n    if (group.indexOf(t) < 0) {\n      group.push(t);\n    }\n  }\n}\n\n/**\n * @template T\n * @param {T} t token to check\n * @param {Collections<T>} groups\n * @returns {Flags} group flags that contain this token\n */\nfunction flagsForToken(t, groups) {\n  const result = {};\n  for (const c in groups) {\n    if (groups[c].indexOf(t) >= 0) {\n      result[c] = true;\n    }\n  }\n  return result;\n}\n\n/**\n * @template T\n * @typedef {null | T } Transition\n */\n\n/**\n * Define a basic state machine state. j is the list of character transitions,\n * jr is the list of regex-match transitions, jd is the default state to\n * transition to t is the accepting token type, if any. If this is the terminal\n * state, then it does not emit a token.\n *\n * The template type T represents the type of the token this state accepts. This\n * should be a string (such as of the token exports in `text.js`) or a\n * MultiToken subclass (from `multi.js`)\n *\n * @template T\n * @param {T} [token] Token that this state emits\n */\nfunction State(token = null) {\n  // this.n = null; // DEBUG: State name\n  /** @type {{ [input: string]: State<T> }} j */\n  this.j = {}; // IMPLEMENTATION 1\n  // this.j = []; // IMPLEMENTATION 2\n  /** @type {[RegExp, State<T>][]} jr */\n  this.jr = [];\n  /** @type {?State<T>} jd */\n  this.jd = null;\n  /** @type {?T} t */\n  this.t = token;\n}\n\n/**\n * Scanner token groups\n * @type Collections<string>\n */\nState.groups = {};\nState.prototype = {\n  accepts() {\n    return !!this.t;\n  },\n  /**\n   * Follow an existing transition from the given input to the next state.\n   * Does not mutate.\n   * @param {string} input character or token type to transition on\n   * @returns {?State<T>} the next state, if any\n   */\n  go(input) {\n    const state = this;\n    const nextState = state.j[input];\n    if (nextState) {\n      return nextState;\n    }\n    for (let i = 0; i < state.jr.length; i++) {\n      const regex = state.jr[i][0];\n      const nextState = state.jr[i][1]; // note: might be empty to prevent default jump\n      if (nextState && regex.test(input)) {\n        return nextState;\n      }\n    }\n    // Nowhere left to jump! Return default, if any\n    return state.jd;\n  },\n  /**\n   * Whether the state has a transition for the given input. Set the second\n   * argument to true to only look for an exact match (and not a default or\n   * regular-expression-based transition)\n   * @param {string} input\n   * @param {boolean} exactOnly\n   */\n  has(input, exactOnly = false) {\n    return exactOnly ? input in this.j : !!this.go(input);\n  },\n  /**\n   * Short for \"transition all\"; create a transition from the array of items\n   * in the given list to the same final resulting state.\n   * @param {string | string[]} inputs Group of inputs to transition on\n   * @param {Transition<T> | State<T>} [next] Transition options\n   * @param {Flags} [flags] Collections flags to add token to\n   * @param {Collections<T>} [groups] Master list of token groups\n   */\n  ta(inputs, next, flags, groups) {\n    for (let i = 0; i < inputs.length; i++) {\n      this.tt(inputs[i], next, flags, groups);\n    }\n  },\n  /**\n   * Short for \"take regexp transition\"; defines a transition for this state\n   * when it encounters a token which matches the given regular expression\n   * @param {RegExp} regexp Regular expression transition (populate first)\n   * @param {T | State<T>} [next] Transition options\n   * @param {Flags} [flags] Collections flags to add token to\n   * @param {Collections<T>} [groups] Master list of token groups\n   * @returns {State<T>} taken after the given input\n   */\n  tr(regexp, next, flags, groups) {\n    groups = groups || State.groups;\n    let nextState;\n    if (next && next.j) {\n      nextState = next;\n    } else {\n      // Token with maybe token groups\n      nextState = new State(next);\n      if (flags && groups) {\n        addToGroups(next, flags, groups);\n      }\n    }\n    this.jr.push([regexp, nextState]);\n    return nextState;\n  },\n  /**\n   * Short for \"take transitions\", will take as many sequential transitions as\n   * the length of the given input and returns the\n   * resulting final state.\n   * @param {string | string[]} input\n   * @param {T | State<T>} [next] Transition options\n   * @param {Flags} [flags] Collections flags to add token to\n   * @param {Collections<T>} [groups] Master list of token groups\n   * @returns {State<T>} taken after the given input\n   */\n  ts(input, next, flags, groups) {\n    let state = this;\n    const len = input.length;\n    if (!len) {\n      return state;\n    }\n    for (let i = 0; i < len - 1; i++) {\n      state = state.tt(input[i]);\n    }\n    return state.tt(input[len - 1], next, flags, groups);\n  },\n  /**\n   * Short for \"take transition\", this is a method for building/working with\n   * state machines.\n   *\n   * If a state already exists for the given input, returns it.\n   *\n   * If a token is specified, that state will emit that token when reached by\n   * the linkify engine.\n   *\n   * If no state exists, it will be initialized with some default transitions\n   * that resemble existing default transitions.\n   *\n   * If a state is given for the second argument, that state will be\n   * transitioned to on the given input regardless of what that input\n   * previously did.\n   *\n   * Specify a token group flags to define groups that this token belongs to.\n   * The token will be added to corresponding entires in the given groups\n   * object.\n   *\n   * @param {string} input character, token type to transition on\n   * @param {T | State<T>} [next] Transition options\n   * @param {Flags} [flags] Collections flags to add token to\n   * @param {Collections<T>} [groups] Master list of groups\n   * @returns {State<T>} taken after the given input\n   */\n  tt(input, next, flags, groups) {\n    groups = groups || State.groups;\n    const state = this;\n\n    // Check if existing state given, just a basic transition\n    if (next && next.j) {\n      state.j[input] = next;\n      return next;\n    }\n    const t = next;\n\n    // Take the transition with the usual default mechanisms and use that as\n    // a template for creating the next state\n    let nextState,\n      templateState = state.go(input);\n    if (templateState) {\n      nextState = new State();\n      Object.assign(nextState.j, templateState.j);\n      nextState.jr.push.apply(nextState.jr, templateState.jr);\n      nextState.jd = templateState.jd;\n      nextState.t = templateState.t;\n    } else {\n      nextState = new State();\n    }\n    if (t) {\n      // Ensure newly token is in the same groups as the old token\n      if (groups) {\n        if (nextState.t && typeof nextState.t === 'string') {\n          const allFlags = Object.assign(flagsForToken(nextState.t, groups), flags);\n          addToGroups(t, allFlags, groups);\n        } else if (flags) {\n          addToGroups(t, flags, groups);\n        }\n      }\n      nextState.t = t; // overwrite anything that was previously there\n    }\n    state.j[input] = nextState;\n    return nextState;\n  }\n};\n\n// Helper functions to improve minification (not exported outside linkifyjs module)\n\n/**\n * @template T\n * @param {State<T>} state\n * @param {string | string[]} input\n * @param {Flags} [flags]\n * @param {Collections<T>} [groups]\n */\nconst ta = (state, input, next, flags, groups) => state.ta(input, next, flags, groups);\n\n/**\n * @template T\n * @param {State<T>} state\n * @param {RegExp} regexp\n * @param {T | State<T>} [next]\n * @param {Flags} [flags]\n * @param {Collections<T>} [groups]\n */\nconst tr = (state, regexp, next, flags, groups) => state.tr(regexp, next, flags, groups);\n\n/**\n * @template T\n * @param {State<T>} state\n * @param {string | string[]} input\n * @param {T | State<T>} [next]\n * @param {Flags} [flags]\n * @param {Collections<T>} [groups]\n */\nconst ts = (state, input, next, flags, groups) => state.ts(input, next, flags, groups);\n\n/**\n * @template T\n * @param {State<T>} state\n * @param {string} input\n * @param {T | State<T>} [next]\n * @param {Collections<T>} [groups]\n * @param {Flags} [flags]\n */\nconst tt = (state, input, next, flags, groups) => state.tt(input, next, flags, groups);\n\n/******************************************************************************\nText Tokens\nIdentifiers for token outputs from the regexp scanner\n******************************************************************************/\n\n// A valid web domain token\nconst WORD = 'WORD'; // only contains a-z\nconst UWORD = 'UWORD'; // contains letters other than a-z, used for IDN\nconst ASCIINUMERICAL = 'ASCIINUMERICAL'; // contains a-z, 0-9\nconst ALPHANUMERICAL = 'ALPHANUMERICAL'; // contains numbers and letters other than a-z, used for IDN\n\n// Special case of word\nconst LOCALHOST = 'LOCALHOST';\n\n// Valid top-level domain, special case of WORD (see tlds.js)\nconst TLD = 'TLD';\n\n// Valid IDN TLD, special case of UWORD (see tlds.js)\nconst UTLD = 'UTLD';\n\n// The scheme portion of a web URI protocol. Supported types include: `mailto`,\n// `file`, and user-defined custom protocols. Limited to schemes that contain\n// only letters\nconst SCHEME = 'SCHEME';\n\n// Similar to SCHEME, except makes distinction for schemes that must always be\n// followed by `://`, not just `:`. Supported types include `http`, `https`,\n// `ftp`, `ftps`\nconst SLASH_SCHEME = 'SLASH_SCHEME';\n\n// Any sequence of digits 0-9\nconst NUM = 'NUM';\n\n// Any number of consecutive whitespace characters that are not newline\nconst WS = 'WS';\n\n// New line (unix style)\nconst NL = 'NL'; // \\n\n\n// Opening/closing bracket classes\n// TODO: Rename OPEN -> LEFT and CLOSE -> RIGHT in v5 to fit with Unicode names\n// Also rename angle brackes to LESSTHAN and GREATER THAN\nconst OPENBRACE = 'OPENBRACE'; // {\nconst CLOSEBRACE = 'CLOSEBRACE'; // }\nconst OPENBRACKET = 'OPENBRACKET'; // [\nconst CLOSEBRACKET = 'CLOSEBRACKET'; // ]\nconst OPENPAREN = 'OPENPAREN'; // (\nconst CLOSEPAREN = 'CLOSEPAREN'; // )\nconst OPENANGLEBRACKET = 'OPENANGLEBRACKET'; // <\nconst CLOSEANGLEBRACKET = 'CLOSEANGLEBRACKET'; // >\nconst FULLWIDTHLEFTPAREN = 'FULLWIDTHLEFTPAREN'; // （\nconst FULLWIDTHRIGHTPAREN = 'FULLWIDTHRIGHTPAREN'; // ）\nconst LEFTCORNERBRACKET = 'LEFTCORNERBRACKET'; // 「\nconst RIGHTCORNERBRACKET = 'RIGHTCORNERBRACKET'; // 」\nconst LEFTWHITECORNERBRACKET = 'LEFTWHITECORNERBRACKET'; // 『\nconst RIGHTWHITECORNERBRACKET = 'RIGHTWHITECORNERBRACKET'; // 』\nconst FULLWIDTHLESSTHAN = 'FULLWIDTHLESSTHAN'; // ＜\nconst FULLWIDTHGREATERTHAN = 'FULLWIDTHGREATERTHAN'; // ＞\n\n// Various symbols\nconst AMPERSAND = 'AMPERSAND'; // &\nconst APOSTROPHE = 'APOSTROPHE'; // '\nconst ASTERISK = 'ASTERISK'; // *\nconst AT = 'AT'; // @\nconst BACKSLASH = 'BACKSLASH'; // \\\nconst BACKTICK = 'BACKTICK'; // `\nconst CARET = 'CARET'; // ^\nconst COLON = 'COLON'; // :\nconst COMMA = 'COMMA'; // ,\nconst DOLLAR = 'DOLLAR'; // $\nconst DOT = 'DOT'; // .\nconst EQUALS = 'EQUALS'; // =\nconst EXCLAMATION = 'EXCLAMATION'; // !\nconst HYPHEN = 'HYPHEN'; // -\nconst PERCENT = 'PERCENT'; // %\nconst PIPE = 'PIPE'; // |\nconst PLUS = 'PLUS'; // +\nconst POUND = 'POUND'; // #\nconst QUERY = 'QUERY'; // ?\nconst QUOTE = 'QUOTE'; // \"\nconst FULLWIDTHMIDDLEDOT = 'FULLWIDTHMIDDLEDOT'; // ・\n\nconst SEMI = 'SEMI'; // ;\nconst SLASH = 'SLASH'; // /\nconst TILDE = 'TILDE'; // ~\nconst UNDERSCORE = 'UNDERSCORE'; // _\n\n// Emoji symbol\nconst EMOJI$1 = 'EMOJI';\n\n// Default token - anything that is not one of the above\nconst SYM = 'SYM';\n\nvar tk = /*#__PURE__*/Object.freeze({\n\t__proto__: null,\n\tALPHANUMERICAL: ALPHANUMERICAL,\n\tAMPERSAND: AMPERSAND,\n\tAPOSTROPHE: APOSTROPHE,\n\tASCIINUMERICAL: ASCIINUMERICAL,\n\tASTERISK: ASTERISK,\n\tAT: AT,\n\tBACKSLASH: BACKSLASH,\n\tBACKTICK: BACKTICK,\n\tCARET: CARET,\n\tCLOSEANGLEBRACKET: CLOSEANGLEBRACKET,\n\tCLOSEBRACE: CLOSEBRACE,\n\tCLOSEBRACKET: CLOSEBRACKET,\n\tCLOSEPAREN: CLOSEPAREN,\n\tCOLON: COLON,\n\tCOMMA: COMMA,\n\tDOLLAR: DOLLAR,\n\tDOT: DOT,\n\tEMOJI: EMOJI$1,\n\tEQUALS: EQUALS,\n\tEXCLAMATION: EXCLAMATION,\n\tFULLWIDTHGREATERTHAN: FULLWIDTHGREATERTHAN,\n\tFULLWIDTHLEFTPAREN: FULLWIDTHLEFTPAREN,\n\tFULLWIDTHLESSTHAN: FULLWIDTHLESSTHAN,\n\tFULLWIDTHMIDDLEDOT: FULLWIDTHMIDDLEDOT,\n\tFULLWIDTHRIGHTPAREN: FULLWIDTHRIGHTPAREN,\n\tHYPHEN: HYPHEN,\n\tLEFTCORNERBRACKET: LEFTCORNERBRACKET,\n\tLEFTWHITECORNERBRACKET: LEFTWHITECORNERBRACKET,\n\tLOCALHOST: LOCALHOST,\n\tNL: NL,\n\tNUM: NUM,\n\tOPENANGLEBRACKET: OPENANGLEBRACKET,\n\tOPENBRACE: OPENBRACE,\n\tOPENBRACKET: OPENBRACKET,\n\tOPENPAREN: OPENPAREN,\n\tPERCENT: PERCENT,\n\tPIPE: PIPE,\n\tPLUS: PLUS,\n\tPOUND: POUND,\n\tQUERY: QUERY,\n\tQUOTE: QUOTE,\n\tRIGHTCORNERBRACKET: RIGHTCORNERBRACKET,\n\tRIGHTWHITECORNERBRACKET: RIGHTWHITECORNERBRACKET,\n\tSCHEME: SCHEME,\n\tSEMI: SEMI,\n\tSLASH: SLASH,\n\tSLASH_SCHEME: SLASH_SCHEME,\n\tSYM: SYM,\n\tTILDE: TILDE,\n\tTLD: TLD,\n\tUNDERSCORE: UNDERSCORE,\n\tUTLD: UTLD,\n\tUWORD: UWORD,\n\tWORD: WORD,\n\tWS: WS\n});\n\n// Note that these two Unicode ones expand into a really big one with Babel\nconst ASCII_LETTER = /[a-z]/;\nconst LETTER = /\\p{L}/u; // Any Unicode character with letter data type\nconst EMOJI = /\\p{Emoji}/u; // Any Unicode emoji character\nconst EMOJI_VARIATION$1 = /\\ufe0f/;\nconst DIGIT = /\\d/;\nconst SPACE = /\\s/;\n\nvar regexp = /*#__PURE__*/Object.freeze({\n\t__proto__: null,\n\tASCII_LETTER: ASCII_LETTER,\n\tDIGIT: DIGIT,\n\tEMOJI: EMOJI,\n\tEMOJI_VARIATION: EMOJI_VARIATION$1,\n\tLETTER: LETTER,\n\tSPACE: SPACE\n});\n\n/**\n\tThe scanner provides an interface that takes a string of text as input, and\n\toutputs an array of tokens instances that can be used for easy URL parsing.\n*/\n\nconst CR = '\\r'; // carriage-return character\nconst LF = '\\n'; // line-feed character\nconst EMOJI_VARIATION = '\\ufe0f'; // Variation selector, follows heart and others\nconst EMOJI_JOINER = '\\u200d'; // zero-width joiner\nconst OBJECT_REPLACEMENT = '\\ufffc'; // whitespace placeholder that sometimes appears in rich text editors\n\nlet tlds = null,\n  utlds = null; // don't change so only have to be computed once\n\n/**\n * Scanner output token:\n * - `t` is the token name (e.g., 'NUM', 'EMOJI', 'TLD')\n * - `v` is the value of the token (e.g., '123', '❤️', 'com')\n * - `s` is the start index of the token in the original string\n * - `e` is the end index of the token in the original string\n * @typedef {{t: string, v: string, s: number, e: number}} Token\n */\n\n/**\n * @template T\n * @typedef {{ [collection: string]: T[] }} Collections\n */\n\n/**\n * Initialize the scanner character-based state machine for the given start\n * state\n * @param {[string, boolean][]} customSchemes List of custom schemes, where each\n * item is a length-2 tuple with the first element set to the string scheme, and\n * the second element set to `true` if the `://` after the scheme is optional\n */\nfunction init$2(customSchemes = []) {\n  // Frequently used states (name argument removed during minification)\n  /** @type Collections<string> */\n  const groups = {}; // of tokens\n  State.groups = groups;\n  /** @type State<string> */\n  const Start = new State();\n  if (tlds == null) {\n    tlds = decodeTlds(encodedTlds);\n  }\n  if (utlds == null) {\n    utlds = decodeTlds(encodedUtlds);\n  }\n\n  // States for special URL symbols that accept immediately after start\n  tt(Start, \"'\", APOSTROPHE);\n  tt(Start, '{', OPENBRACE);\n  tt(Start, '}', CLOSEBRACE);\n  tt(Start, '[', OPENBRACKET);\n  tt(Start, ']', CLOSEBRACKET);\n  tt(Start, '(', OPENPAREN);\n  tt(Start, ')', CLOSEPAREN);\n  tt(Start, '<', OPENANGLEBRACKET);\n  tt(Start, '>', CLOSEANGLEBRACKET);\n  tt(Start, '（', FULLWIDTHLEFTPAREN);\n  tt(Start, '）', FULLWIDTHRIGHTPAREN);\n  tt(Start, '「', LEFTCORNERBRACKET);\n  tt(Start, '」', RIGHTCORNERBRACKET);\n  tt(Start, '『', LEFTWHITECORNERBRACKET);\n  tt(Start, '』', RIGHTWHITECORNERBRACKET);\n  tt(Start, '＜', FULLWIDTHLESSTHAN);\n  tt(Start, '＞', FULLWIDTHGREATERTHAN);\n  tt(Start, '&', AMPERSAND);\n  tt(Start, '*', ASTERISK);\n  tt(Start, '@', AT);\n  tt(Start, '`', BACKTICK);\n  tt(Start, '^', CARET);\n  tt(Start, ':', COLON);\n  tt(Start, ',', COMMA);\n  tt(Start, '$', DOLLAR);\n  tt(Start, '.', DOT);\n  tt(Start, '=', EQUALS);\n  tt(Start, '!', EXCLAMATION);\n  tt(Start, '-', HYPHEN);\n  tt(Start, '%', PERCENT);\n  tt(Start, '|', PIPE);\n  tt(Start, '+', PLUS);\n  tt(Start, '#', POUND);\n  tt(Start, '?', QUERY);\n  tt(Start, '\"', QUOTE);\n  tt(Start, '/', SLASH);\n  tt(Start, ';', SEMI);\n  tt(Start, '~', TILDE);\n  tt(Start, '_', UNDERSCORE);\n  tt(Start, '\\\\', BACKSLASH);\n  tt(Start, '・', FULLWIDTHMIDDLEDOT);\n  const Num = tr(Start, DIGIT, NUM, {\n    [numeric]: true\n  });\n  tr(Num, DIGIT, Num);\n  const Asciinumeric = tr(Num, ASCII_LETTER, ASCIINUMERICAL, {\n    [asciinumeric]: true\n  });\n  const Alphanumeric = tr(Num, LETTER, ALPHANUMERICAL, {\n    [alphanumeric]: true\n  });\n\n  // State which emits a word token\n  const Word = tr(Start, ASCII_LETTER, WORD, {\n    [ascii]: true\n  });\n  tr(Word, DIGIT, Asciinumeric);\n  tr(Word, ASCII_LETTER, Word);\n  tr(Asciinumeric, DIGIT, Asciinumeric);\n  tr(Asciinumeric, ASCII_LETTER, Asciinumeric);\n\n  // Same as previous, but specific to non-fsm.ascii alphabet words\n  const UWord = tr(Start, LETTER, UWORD, {\n    [alpha]: true\n  });\n  tr(UWord, ASCII_LETTER); // Non-accepting\n  tr(UWord, DIGIT, Alphanumeric);\n  tr(UWord, LETTER, UWord);\n  tr(Alphanumeric, DIGIT, Alphanumeric);\n  tr(Alphanumeric, ASCII_LETTER); // Non-accepting\n  tr(Alphanumeric, LETTER, Alphanumeric); // Non-accepting\n\n  // Whitespace jumps\n  // Tokens of only non-newline whitespace are arbitrarily long\n  // If any whitespace except newline, more whitespace!\n  const Nl = tt(Start, LF, NL, {\n    [whitespace]: true\n  });\n  const Cr = tt(Start, CR, WS, {\n    [whitespace]: true\n  });\n  const Ws = tr(Start, SPACE, WS, {\n    [whitespace]: true\n  });\n  tt(Start, OBJECT_REPLACEMENT, Ws);\n  tt(Cr, LF, Nl); // \\r\\n\n  tt(Cr, OBJECT_REPLACEMENT, Ws);\n  tr(Cr, SPACE, Ws);\n  tt(Ws, CR); // non-accepting state to avoid mixing whitespaces\n  tt(Ws, LF); // non-accepting state to avoid mixing whitespaces\n  tr(Ws, SPACE, Ws);\n  tt(Ws, OBJECT_REPLACEMENT, Ws);\n\n  // Emoji tokens. They are not grouped by the scanner except in cases where a\n  // zero-width joiner is present\n  const Emoji = tr(Start, EMOJI, EMOJI$1, {\n    [emoji]: true\n  });\n  tt(Emoji, '#'); // no transition, emoji regex seems to match #\n  tr(Emoji, EMOJI, Emoji);\n  tt(Emoji, EMOJI_VARIATION, Emoji);\n  // tt(Start, EMOJI_VARIATION, Emoji); // This one is sketchy\n\n  const EmojiJoiner = tt(Emoji, EMOJI_JOINER);\n  tt(EmojiJoiner, '#');\n  tr(EmojiJoiner, EMOJI, Emoji);\n  // tt(EmojiJoiner, EMOJI_VARIATION, Emoji); // also sketchy\n\n  // Generates states for top-level domains\n  // Note that this is most accurate when tlds are in alphabetical order\n  const wordjr = [[ASCII_LETTER, Word], [DIGIT, Asciinumeric]];\n  const uwordjr = [[ASCII_LETTER, null], [LETTER, UWord], [DIGIT, Alphanumeric]];\n  for (let i = 0; i < tlds.length; i++) {\n    fastts(Start, tlds[i], TLD, WORD, wordjr);\n  }\n  for (let i = 0; i < utlds.length; i++) {\n    fastts(Start, utlds[i], UTLD, UWORD, uwordjr);\n  }\n  addToGroups(TLD, {\n    tld: true,\n    ascii: true\n  }, groups);\n  addToGroups(UTLD, {\n    utld: true,\n    alpha: true\n  }, groups);\n\n  // Collect the states generated by different protocols. NOTE: If any new TLDs\n  // get added that are also protocols, set the token to be the same as the\n  // protocol to ensure parsing works as expected.\n  fastts(Start, 'file', SCHEME, WORD, wordjr);\n  fastts(Start, 'mailto', SCHEME, WORD, wordjr);\n  fastts(Start, 'http', SLASH_SCHEME, WORD, wordjr);\n  fastts(Start, 'https', SLASH_SCHEME, WORD, wordjr);\n  fastts(Start, 'ftp', SLASH_SCHEME, WORD, wordjr);\n  fastts(Start, 'ftps', SLASH_SCHEME, WORD, wordjr);\n  addToGroups(SCHEME, {\n    scheme: true,\n    ascii: true\n  }, groups);\n  addToGroups(SLASH_SCHEME, {\n    slashscheme: true,\n    ascii: true\n  }, groups);\n\n  // Register custom schemes. Assumes each scheme is asciinumeric with hyphens\n  customSchemes = customSchemes.sort((a, b) => a[0] > b[0] ? 1 : -1);\n  for (let i = 0; i < customSchemes.length; i++) {\n    const sch = customSchemes[i][0];\n    const optionalSlashSlash = customSchemes[i][1];\n    const flags = optionalSlashSlash ? {\n      [scheme]: true\n    } : {\n      [slashscheme]: true\n    };\n    if (sch.indexOf('-') >= 0) {\n      flags[domain] = true;\n    } else if (!ASCII_LETTER.test(sch)) {\n      flags[numeric] = true; // numbers only\n    } else if (DIGIT.test(sch)) {\n      flags[asciinumeric] = true;\n    } else {\n      flags[ascii] = true;\n    }\n    ts(Start, sch, sch, flags);\n  }\n\n  // Localhost token\n  ts(Start, 'localhost', LOCALHOST, {\n    ascii: true\n  });\n\n  // Set default transition for start state (some symbol)\n  Start.jd = new State(SYM);\n  return {\n    start: Start,\n    tokens: Object.assign({\n      groups\n    }, tk)\n  };\n}\n\n/**\n\tGiven a string, returns an array of TOKEN instances representing the\n\tcomposition of that string.\n\n\t@method run\n\t@param {State<string>} start scanner starting state\n\t@param {string} str input string to scan\n\t@return {Token[]} list of tokens, each with a type and value\n*/\nfunction run$1(start, str) {\n  // State machine is not case sensitive, so input is tokenized in lowercased\n  // form (still returns regular case). Uses selective `toLowerCase` because\n  // lowercasing the entire string causes the length and character position to\n  // vary in some non-English strings with V8-based runtimes.\n  const iterable = stringToArray(str.replace(/[A-Z]/g, c => c.toLowerCase()));\n  const charCount = iterable.length; // <= len if there are emojis, etc\n  const tokens = []; // return value\n\n  // cursor through the string itself, accounting for characters that have\n  // width with length 2 such as emojis\n  let cursor = 0;\n\n  // Cursor through the array-representation of the string\n  let charCursor = 0;\n\n  // Tokenize the string\n  while (charCursor < charCount) {\n    let state = start;\n    let nextState = null;\n    let tokenLength = 0;\n    let latestAccepting = null;\n    let sinceAccepts = -1;\n    let charsSinceAccepts = -1;\n    while (charCursor < charCount && (nextState = state.go(iterable[charCursor]))) {\n      state = nextState;\n\n      // Keep track of the latest accepting state\n      if (state.accepts()) {\n        sinceAccepts = 0;\n        charsSinceAccepts = 0;\n        latestAccepting = state;\n      } else if (sinceAccepts >= 0) {\n        sinceAccepts += iterable[charCursor].length;\n        charsSinceAccepts++;\n      }\n      tokenLength += iterable[charCursor].length;\n      cursor += iterable[charCursor].length;\n      charCursor++;\n    }\n\n    // Roll back to the latest accepting state\n    cursor -= sinceAccepts;\n    charCursor -= charsSinceAccepts;\n    tokenLength -= sinceAccepts;\n\n    // No more jumps, just make a new token from the last accepting one\n    tokens.push({\n      t: latestAccepting.t,\n      // token type/name\n      v: str.slice(cursor - tokenLength, cursor),\n      // string value\n      s: cursor - tokenLength,\n      // start index\n      e: cursor // end index (excluding)\n    });\n  }\n  return tokens;\n}\n\n/**\n * Convert a String to an Array of characters, taking into account that some\n * characters like emojis take up two string indexes.\n *\n * Adapted from core-js (MIT license)\n * https://github.com/zloirock/core-js/blob/2d69cf5f99ab3ea3463c395df81e5a15b68f49d9/packages/core-js/internals/string-multibyte.js\n *\n * @function stringToArray\n * @param {string} str\n * @returns {string[]}\n */\nfunction stringToArray(str) {\n  const result = [];\n  const len = str.length;\n  let index = 0;\n  while (index < len) {\n    let first = str.charCodeAt(index);\n    let second;\n    let char = first < 0xd800 || first > 0xdbff || index + 1 === len || (second = str.charCodeAt(index + 1)) < 0xdc00 || second > 0xdfff ? str[index] // single character\n    : str.slice(index, index + 2); // two-index characters\n    result.push(char);\n    index += char.length;\n  }\n  return result;\n}\n\n/**\n * Fast version of ts function for when transition defaults are well known\n * @param {State<string>} state\n * @param {string} input\n * @param {string} t\n * @param {string} defaultt\n * @param {[RegExp, State<string>][]} jr\n * @returns {State<string>}\n */\nfunction fastts(state, input, t, defaultt, jr) {\n  let next;\n  const len = input.length;\n  for (let i = 0; i < len - 1; i++) {\n    const char = input[i];\n    if (state.j[char]) {\n      next = state.j[char];\n    } else {\n      next = new State(defaultt);\n      next.jr = jr.slice();\n      state.j[char] = next;\n    }\n    state = next;\n  }\n  next = new State(t);\n  next.jr = jr.slice();\n  state.j[input[len - 1]] = next;\n  return next;\n}\n\n/**\n * Converts a string of Top-Level Domain names encoded in update-tlds.js back\n * into a list of strings.\n * @param {str} encoded encoded TLDs string\n * @returns {str[]} original TLDs list\n */\nfunction decodeTlds(encoded) {\n  const words = [];\n  const stack = [];\n  let i = 0;\n  let digits = '0123456789';\n  while (i < encoded.length) {\n    let popDigitCount = 0;\n    while (digits.indexOf(encoded[i + popDigitCount]) >= 0) {\n      popDigitCount++; // encountered some digits, have to pop to go one level up trie\n    }\n    if (popDigitCount > 0) {\n      words.push(stack.join('')); // whatever preceded the pop digits must be a word\n      for (let popCount = parseInt(encoded.substring(i, i + popDigitCount), 10); popCount > 0; popCount--) {\n        stack.pop();\n      }\n      i += popDigitCount;\n    } else {\n      stack.push(encoded[i]); // drop down a level into the trie\n      i++;\n    }\n  }\n  return words;\n}\n\n/**\n * An object where each key is a valid DOM Event Name such as `click` or `focus`\n * and each value is an event handler function.\n *\n * https://developer.mozilla.org/en-US/docs/Web/API/Element#events\n * @typedef {?{ [event: string]: Function }} EventListeners\n */\n\n/**\n * All formatted properties required to render a link, including `tagName`,\n * `attributes`, `content` and `eventListeners`.\n * @typedef {{ tagName: any, attributes: {[attr: string]: any}, content: string,\n * eventListeners: EventListeners }} IntermediateRepresentation\n */\n\n/**\n * Specify either an object described by the template type `O` or a function.\n *\n * The function takes a string value (usually the link's href attribute), the\n * link type (`'url'`, `'hashtag`', etc.) and an internal token representation\n * of the link. It should return an object of the template type `O`\n * @template O\n * @typedef {O | ((value: string, type: string, token: MultiToken) => O)} OptObj\n */\n\n/**\n * Specify either a function described by template type `F` or an object.\n *\n * Each key in the object should be a link type (`'url'`, `'hashtag`', etc.). Each\n * value should be a function with template type `F` that is called when the\n * corresponding link type is encountered.\n * @template F\n * @typedef {F | { [type: string]: F}} OptFn\n */\n\n/**\n * Specify either a value with template type `V`, a function that returns `V` or\n * an object where each value resolves to `V`.\n *\n * The function takes a string value (usually the link's href attribute), the\n * link type (`'url'`, `'hashtag`', etc.) and an internal token representation\n * of the link. It should return an object of the template type `V`\n *\n * For the object, each key should be a link type (`'url'`, `'hashtag`', etc.).\n * Each value should either have type `V` or a function that returns V. This\n * function similarly takes a string value and a token.\n *\n * Example valid types for `Opt<string>`:\n *\n * ```js\n * 'hello'\n * (value, type, token) => 'world'\n * { url: 'hello', email: (value, token) => 'world'}\n * ```\n * @template V\n * @typedef {V | ((value: string, type: string, token: MultiToken) => V) | { [type: string]: V | ((value: string, token: MultiToken) => V) }} Opt\n */\n\n/**\n * See available options: https://linkify.js.org/docs/options.html\n * @typedef {{\n * \tdefaultProtocol?: string,\n *  events?: OptObj<EventListeners>,\n * \tformat?: Opt<string>,\n * \tformatHref?: Opt<string>,\n * \tnl2br?: boolean,\n * \ttagName?: Opt<any>,\n * \ttarget?: Opt<string>,\n * \trel?: Opt<string>,\n * \tvalidate?: Opt<boolean>,\n * \ttruncate?: Opt<number>,\n * \tclassName?: Opt<string>,\n * \tattributes?: OptObj<({ [attr: string]: any })>,\n *  ignoreTags?: string[],\n * \trender?: OptFn<((ir: IntermediateRepresentation) => any)>\n * }} Opts\n */\n\n/**\n * @type Required<Opts>\n */\nconst defaults = {\n  defaultProtocol: 'http',\n  events: null,\n  format: noop,\n  formatHref: noop,\n  nl2br: false,\n  tagName: 'a',\n  target: null,\n  rel: null,\n  validate: true,\n  truncate: Infinity,\n  className: null,\n  attributes: null,\n  ignoreTags: [],\n  render: null\n};\n\n/**\n * Utility class for linkify interfaces to apply specified\n * {@link Opts formatting and rendering options}.\n *\n * @param {Opts | Options} [opts] Option value overrides.\n * @param {(ir: IntermediateRepresentation) => any} [defaultRender] (For\n *   internal use) default render function that determines how to generate an\n *   HTML element based on a link token's derived tagName, attributes and HTML.\n *   Similar to render option\n */\nfunction Options(opts, defaultRender = null) {\n  let o = Object.assign({}, defaults);\n  if (opts) {\n    o = Object.assign(o, opts instanceof Options ? opts.o : opts);\n  }\n\n  // Ensure all ignored tags are uppercase\n  const ignoredTags = o.ignoreTags;\n  const uppercaseIgnoredTags = [];\n  for (let i = 0; i < ignoredTags.length; i++) {\n    uppercaseIgnoredTags.push(ignoredTags[i].toUpperCase());\n  }\n  /** @protected */\n  this.o = o;\n  if (defaultRender) {\n    this.defaultRender = defaultRender;\n  }\n  this.ignoreTags = uppercaseIgnoredTags;\n}\nOptions.prototype = {\n  o: defaults,\n  /**\n   * @type string[]\n   */\n  ignoreTags: [],\n  /**\n   * @param {IntermediateRepresentation} ir\n   * @returns {any}\n   */\n  defaultRender(ir) {\n    return ir;\n  },\n  /**\n   * Returns true or false based on whether a token should be displayed as a\n   * link based on the user options.\n   * @param {MultiToken} token\n   * @returns {boolean}\n   */\n  check(token) {\n    return this.get('validate', token.toString(), token);\n  },\n  // Private methods\n\n  /**\n   * Resolve an option's value based on the value of the option and the given\n   * params. If operator and token are specified and the target option is\n   * callable, automatically calls the function with the given argument.\n   * @template {keyof Opts} K\n   * @param {K} key Name of option to use\n   * @param {string} [operator] will be passed to the target option if it's a\n   * function. If not specified, RAW function value gets returned\n   * @param {MultiToken} [token] The token from linkify.tokenize\n   * @returns {Opts[K] | any}\n   */\n  get(key, operator, token) {\n    const isCallable = operator != null;\n    let option = this.o[key];\n    if (!option) {\n      return option;\n    }\n    if (typeof option === 'object') {\n      option = token.t in option ? option[token.t] : defaults[key];\n      if (typeof option === 'function' && isCallable) {\n        option = option(operator, token);\n      }\n    } else if (typeof option === 'function' && isCallable) {\n      option = option(operator, token.t, token);\n    }\n    return option;\n  },\n  /**\n   * @template {keyof Opts} L\n   * @param {L} key Name of options object to use\n   * @param {string} [operator]\n   * @param {MultiToken} [token]\n   * @returns {Opts[L] | any}\n   */\n  getObj(key, operator, token) {\n    let obj = this.o[key];\n    if (typeof obj === 'function' && operator != null) {\n      obj = obj(operator, token.t, token);\n    }\n    return obj;\n  },\n  /**\n   * Convert the given token to a rendered element that may be added to the\n   * calling-interface's DOM\n   * @param {MultiToken} token Token to render to an HTML element\n   * @returns {any} Render result; e.g., HTML string, DOM element, React\n   *   Component, etc.\n   */\n  render(token) {\n    const ir = token.render(this); // intermediate representation\n    const renderFn = this.get('render', null, token) || this.defaultRender;\n    return renderFn(ir, token.t, token);\n  }\n};\nfunction noop(val) {\n  return val;\n}\n\nvar options = /*#__PURE__*/Object.freeze({\n\t__proto__: null,\n\tOptions: Options,\n\tdefaults: defaults\n});\n\n/******************************************************************************\n\tMulti-Tokens\n\tTokens composed of arrays of TextTokens\n******************************************************************************/\n\n/**\n * @param {string} value\n * @param {Token[]} tokens\n */\nfunction MultiToken(value, tokens) {\n  this.t = 'token';\n  this.v = value;\n  this.tk = tokens;\n}\n\n/**\n * Abstract class used for manufacturing tokens of text tokens. That is rather\n * than the value for a token being a small string of text, it's value an array\n * of text tokens.\n *\n * Used for grouping together URLs, emails, hashtags, and other potential\n * creations.\n * @class MultiToken\n * @property {string} t\n * @property {string} v\n * @property {Token[]} tk\n * @abstract\n */\nMultiToken.prototype = {\n  isLink: false,\n  /**\n   * Return the string this token represents.\n   * @return {string}\n   */\n  toString() {\n    return this.v;\n  },\n  /**\n   * What should the value for this token be in the `href` HTML attribute?\n   * Returns the `.toString` value by default.\n   * @param {string} [scheme]\n   * @return {string}\n   */\n  toHref(scheme) {\n    return this.toString();\n  },\n  /**\n   * @param {Options} options Formatting options\n   * @returns {string}\n   */\n  toFormattedString(options) {\n    const val = this.toString();\n    const truncate = options.get('truncate', val, this);\n    const formatted = options.get('format', val, this);\n    return truncate && formatted.length > truncate ? formatted.substring(0, truncate) + '…' : formatted;\n  },\n  /**\n   *\n   * @param {Options} options\n   * @returns {string}\n   */\n  toFormattedHref(options) {\n    return options.get('formatHref', this.toHref(options.get('defaultProtocol')), this);\n  },\n  /**\n   * The start index of this token in the original input string\n   * @returns {number}\n   */\n  startIndex() {\n    return this.tk[0].s;\n  },\n  /**\n   * The end index of this token in the original input string (up to this\n   * index but not including it)\n   * @returns {number}\n   */\n  endIndex() {\n    return this.tk[this.tk.length - 1].e;\n  },\n  /**\n  \tReturns an object  of relevant values for this token, which includes keys\n  \t* type - Kind of token ('url', 'email', etc.)\n  \t* value - Original text\n  \t* href - The value that should be added to the anchor tag's href\n  \t\tattribute\n  \t\t@method toObject\n  \t@param {string} [protocol] `'http'` by default\n  */\n  toObject(protocol = defaults.defaultProtocol) {\n    return {\n      type: this.t,\n      value: this.toString(),\n      isLink: this.isLink,\n      href: this.toHref(protocol),\n      start: this.startIndex(),\n      end: this.endIndex()\n    };\n  },\n  /**\n   *\n   * @param {Options} options Formatting option\n   */\n  toFormattedObject(options) {\n    return {\n      type: this.t,\n      value: this.toFormattedString(options),\n      isLink: this.isLink,\n      href: this.toFormattedHref(options),\n      start: this.startIndex(),\n      end: this.endIndex()\n    };\n  },\n  /**\n   * Whether this token should be rendered as a link according to the given options\n   * @param {Options} options\n   * @returns {boolean}\n   */\n  validate(options) {\n    return options.get('validate', this.toString(), this);\n  },\n  /**\n   * Return an object that represents how this link should be rendered.\n   * @param {Options} options Formattinng options\n   */\n  render(options) {\n    const token = this;\n    const href = this.toHref(options.get('defaultProtocol'));\n    const formattedHref = options.get('formatHref', href, this);\n    const tagName = options.get('tagName', href, token);\n    const content = this.toFormattedString(options);\n    const attributes = {};\n    const className = options.get('className', href, token);\n    const target = options.get('target', href, token);\n    const rel = options.get('rel', href, token);\n    const attrs = options.getObj('attributes', href, token);\n    const eventListeners = options.getObj('events', href, token);\n    attributes.href = formattedHref;\n    if (className) {\n      attributes.class = className;\n    }\n    if (target) {\n      attributes.target = target;\n    }\n    if (rel) {\n      attributes.rel = rel;\n    }\n    if (attrs) {\n      Object.assign(attributes, attrs);\n    }\n    return {\n      tagName,\n      attributes,\n      content,\n      eventListeners\n    };\n  }\n};\n\n/**\n * Create a new token that can be emitted by the parser state machine\n * @param {string} type readable type of the token\n * @param {object} props properties to assign or override, including isLink = true or false\n * @returns {new (value: string, tokens: Token[]) => MultiToken} new token class\n */\nfunction createTokenClass(type, props) {\n  class Token extends MultiToken {\n    constructor(value, tokens) {\n      super(value, tokens);\n      this.t = type;\n    }\n  }\n  for (const p in props) {\n    Token.prototype[p] = props[p];\n  }\n  Token.t = type;\n  return Token;\n}\n\n/**\n\tRepresents a list of tokens making up a valid email address\n*/\nconst Email = createTokenClass('email', {\n  isLink: true,\n  toHref() {\n    return 'mailto:' + this.toString();\n  }\n});\n\n/**\n\tRepresents some plain text\n*/\nconst Text = createTokenClass('text');\n\n/**\n\tMulti-linebreak token - represents a line break\n\t@class Nl\n*/\nconst Nl = createTokenClass('nl');\n\n/**\n\tRepresents a list of text tokens making up a valid URL\n\t@class Url\n*/\nconst Url = createTokenClass('url', {\n  isLink: true,\n  /**\n  \tLowercases relevant parts of the domain and adds the protocol if\n  \trequired. Note that this will not escape unsafe HTML characters in the\n  \tURL.\n  \t\t@param {string} [scheme] default scheme (e.g., 'https')\n  \t@return {string} the full href\n  */\n  toHref(scheme = defaults.defaultProtocol) {\n    // Check if already has a prefix scheme\n    return this.hasProtocol() ? this.v : `${scheme}://${this.v}`;\n  },\n  /**\n   * Check whether this URL token has a protocol\n   * @return {boolean}\n   */\n  hasProtocol() {\n    const tokens = this.tk;\n    return tokens.length >= 2 && tokens[0].t !== LOCALHOST && tokens[1].t === COLON;\n  }\n});\n\nvar multi = /*#__PURE__*/Object.freeze({\n\t__proto__: null,\n\tBase: MultiToken,\n\tEmail: Email,\n\tMultiToken: MultiToken,\n\tNl: Nl,\n\tText: Text,\n\tUrl: Url,\n\tcreateTokenClass: createTokenClass\n});\n\n/**\n\tNot exactly parser, more like the second-stage scanner (although we can\n\ttheoretically hotswap the code here with a real parser in the future... but\n\tfor a little URL-finding utility abstract syntax trees may be a little\n\toverkill).\n\n\tURL format: http://en.wikipedia.org/wiki/URI_scheme\n\tEmail format: http://en.wikipedia.org/wiki/EmailAddress (links to RFC in\n\treference)\n\n\t@module linkify\n\t@submodule parser\n\t@main run\n*/\n\nconst makeState = arg => new State(arg);\n\n/**\n * Generate the parser multi token-based state machine\n * @param {{ groups: Collections<string> }} tokens\n */\nfunction init$1({\n  groups\n}) {\n  // Types of characters the URL can definitely end in\n  const qsAccepting = groups.domain.concat([AMPERSAND, ASTERISK, AT, BACKSLASH, BACKTICK, CARET, DOLLAR, EQUALS, HYPHEN, NUM, PERCENT, PIPE, PLUS, POUND, SLASH, SYM, TILDE, UNDERSCORE]);\n\n  // Types of tokens that can follow a URL and be part of the query string\n  // but cannot be the very last characters\n  // Characters that cannot appear in the URL at all should be excluded\n  const qsNonAccepting = [APOSTROPHE, COLON, COMMA, DOT, EXCLAMATION, PERCENT, QUERY, QUOTE, SEMI, OPENANGLEBRACKET, CLOSEANGLEBRACKET, OPENBRACE, CLOSEBRACE, CLOSEBRACKET, OPENBRACKET, OPENPAREN, CLOSEPAREN, FULLWIDTHLEFTPAREN, FULLWIDTHRIGHTPAREN, LEFTCORNERBRACKET, RIGHTCORNERBRACKET, LEFTWHITECORNERBRACKET, RIGHTWHITECORNERBRACKET, FULLWIDTHLESSTHAN, FULLWIDTHGREATERTHAN];\n\n  // For addresses without the mailto prefix\n  // Tokens allowed in the localpart of the email\n  const localpartAccepting = [AMPERSAND, APOSTROPHE, ASTERISK, BACKSLASH, BACKTICK, CARET, DOLLAR, EQUALS, HYPHEN, OPENBRACE, CLOSEBRACE, PERCENT, PIPE, PLUS, POUND, QUERY, SLASH, SYM, TILDE, UNDERSCORE];\n\n  // The universal starting state.\n  /**\n   * @type State<Token>\n   */\n  const Start = makeState();\n  const Localpart = tt(Start, TILDE); // Local part of the email address\n  ta(Localpart, localpartAccepting, Localpart);\n  ta(Localpart, groups.domain, Localpart);\n  const Domain = makeState(),\n    Scheme = makeState(),\n    SlashScheme = makeState();\n  ta(Start, groups.domain, Domain); // parsed string ends with a potential domain name (A)\n  ta(Start, groups.scheme, Scheme); // e.g., 'mailto'\n  ta(Start, groups.slashscheme, SlashScheme); // e.g., 'http'\n\n  ta(Domain, localpartAccepting, Localpart);\n  ta(Domain, groups.domain, Domain);\n  const LocalpartAt = tt(Domain, AT); // Local part of the email address plus @\n\n  tt(Localpart, AT, LocalpartAt); // close to an email address now\n\n  // Local part of an email address can be e.g. 'http' or 'mailto'\n  tt(Scheme, AT, LocalpartAt);\n  tt(SlashScheme, AT, LocalpartAt);\n  const LocalpartDot = tt(Localpart, DOT); // Local part of the email address plus '.' (localpart cannot end in .)\n  ta(LocalpartDot, localpartAccepting, Localpart);\n  ta(LocalpartDot, groups.domain, Localpart);\n  const EmailDomain = makeState();\n  ta(LocalpartAt, groups.domain, EmailDomain); // parsed string starts with local email info + @ with a potential domain name\n  ta(EmailDomain, groups.domain, EmailDomain);\n  const EmailDomainDot = tt(EmailDomain, DOT); // domain followed by DOT\n  ta(EmailDomainDot, groups.domain, EmailDomain);\n  const Email$1 = makeState(Email); // Possible email address (could have more tlds)\n  ta(EmailDomainDot, groups.tld, Email$1);\n  ta(EmailDomainDot, groups.utld, Email$1);\n  tt(LocalpartAt, LOCALHOST, Email$1);\n\n  // Hyphen can jump back to a domain name\n  const EmailDomainHyphen = tt(EmailDomain, HYPHEN); // parsed string starts with local email info + @ with a potential domain name\n  tt(EmailDomainHyphen, HYPHEN, EmailDomainHyphen);\n  ta(EmailDomainHyphen, groups.domain, EmailDomain);\n  ta(Email$1, groups.domain, EmailDomain);\n  tt(Email$1, DOT, EmailDomainDot);\n  tt(Email$1, HYPHEN, EmailDomainHyphen);\n\n  // Final possible email states\n  const EmailColon = tt(Email$1, COLON); // URL followed by colon (potential port number here)\n  /*const EmailColonPort = */\n  ta(EmailColon, groups.numeric, Email); // URL followed by colon and port number\n\n  // Account for dots and hyphens. Hyphens are usually parts of domain names\n  // (but not TLDs)\n  const DomainHyphen = tt(Domain, HYPHEN); // domain followed by hyphen\n  const DomainDot = tt(Domain, DOT); // domain followed by DOT\n  tt(DomainHyphen, HYPHEN, DomainHyphen);\n  ta(DomainHyphen, groups.domain, Domain);\n  ta(DomainDot, localpartAccepting, Localpart);\n  ta(DomainDot, groups.domain, Domain);\n  const DomainDotTld = makeState(Url); // Simplest possible URL with no query string\n  ta(DomainDot, groups.tld, DomainDotTld);\n  ta(DomainDot, groups.utld, DomainDotTld);\n  ta(DomainDotTld, groups.domain, Domain);\n  ta(DomainDotTld, localpartAccepting, Localpart);\n  tt(DomainDotTld, DOT, DomainDot);\n  tt(DomainDotTld, HYPHEN, DomainHyphen);\n  tt(DomainDotTld, AT, LocalpartAt);\n  const DomainDotTldColon = tt(DomainDotTld, COLON); // URL followed by colon (potential port number here)\n  const DomainDotTldColonPort = makeState(Url); // TLD followed by a port number\n  ta(DomainDotTldColon, groups.numeric, DomainDotTldColonPort);\n\n  // Long URL with optional port and maybe query string\n  const Url$1 = makeState(Url);\n\n  // URL with extra symbols at the end, followed by an opening bracket\n  const UrlNonaccept = makeState(); // URL followed by some symbols (will not be part of the final URL)\n\n  // Query strings\n  ta(Url$1, qsAccepting, Url$1);\n  ta(Url$1, qsNonAccepting, UrlNonaccept);\n  ta(UrlNonaccept, qsAccepting, Url$1);\n  ta(UrlNonaccept, qsNonAccepting, UrlNonaccept);\n\n  // Become real URLs after `SLASH` or `COLON NUM SLASH`\n  // Here works with or without scheme:// prefix\n  tt(DomainDotTld, SLASH, Url$1);\n  tt(DomainDotTldColonPort, SLASH, Url$1);\n\n  // Note that domains that begin with schemes are treated slighly differently\n  const SchemeColon = tt(Scheme, COLON); // e.g., 'mailto:'\n  const SlashSchemeColon = tt(SlashScheme, COLON); // e.g., 'http:'\n  const SlashSchemeColonSlash = tt(SlashSchemeColon, SLASH); // e.g., 'http:/'\n\n  const UriPrefix = tt(SlashSchemeColonSlash, SLASH); // e.g., 'http://'\n\n  // Scheme states can transition to domain states\n  ta(Scheme, groups.domain, Domain);\n  tt(Scheme, DOT, DomainDot);\n  tt(Scheme, HYPHEN, DomainHyphen);\n  ta(SlashScheme, groups.domain, Domain);\n  tt(SlashScheme, DOT, DomainDot);\n  tt(SlashScheme, HYPHEN, DomainHyphen);\n\n  // Force URL with scheme prefix followed by anything sane\n  ta(SchemeColon, groups.domain, Url$1);\n  tt(SchemeColon, SLASH, Url$1);\n  tt(SchemeColon, QUERY, Url$1);\n  ta(UriPrefix, groups.domain, Url$1);\n  ta(UriPrefix, qsAccepting, Url$1);\n  tt(UriPrefix, SLASH, Url$1);\n  const bracketPairs = [[OPENBRACE, CLOSEBRACE],\n  // {}\n  [OPENBRACKET, CLOSEBRACKET],\n  // []\n  [OPENPAREN, CLOSEPAREN],\n  // ()\n  [OPENANGLEBRACKET, CLOSEANGLEBRACKET],\n  // <>\n  [FULLWIDTHLEFTPAREN, FULLWIDTHRIGHTPAREN],\n  // （）\n  [LEFTCORNERBRACKET, RIGHTCORNERBRACKET],\n  // 「」\n  [LEFTWHITECORNERBRACKET, RIGHTWHITECORNERBRACKET],\n  // 『』\n  [FULLWIDTHLESSTHAN, FULLWIDTHGREATERTHAN] // ＜＞\n  ];\n  for (let i = 0; i < bracketPairs.length; i++) {\n    const [OPEN, CLOSE] = bracketPairs[i];\n    const UrlOpen = tt(Url$1, OPEN); // URL followed by open bracket\n\n    // Continue not accepting for open brackets\n    tt(UrlNonaccept, OPEN, UrlOpen);\n\n    // Closing bracket component. This character WILL be included in the URL\n    tt(UrlOpen, CLOSE, Url$1);\n\n    // URL that beings with an opening bracket, followed by a symbols.\n    // Note that the final state can still be `UrlOpen` (if the URL has a\n    // single opening bracket for some reason).\n    const UrlOpenQ = makeState(Url);\n    ta(UrlOpen, qsAccepting, UrlOpenQ);\n    const UrlOpenSyms = makeState(); // UrlOpen followed by some symbols it cannot end it\n    ta(UrlOpen, qsNonAccepting);\n\n    // URL that begins with an opening bracket, followed by some symbols\n    ta(UrlOpenQ, qsAccepting, UrlOpenQ);\n    ta(UrlOpenQ, qsNonAccepting, UrlOpenSyms);\n    ta(UrlOpenSyms, qsAccepting, UrlOpenQ);\n    ta(UrlOpenSyms, qsNonAccepting, UrlOpenSyms);\n\n    // Close brace/bracket to become regular URL\n    tt(UrlOpenQ, CLOSE, Url$1);\n    tt(UrlOpenSyms, CLOSE, Url$1);\n  }\n  tt(Start, LOCALHOST, DomainDotTld); // localhost is a valid URL state\n  tt(Start, NL, Nl); // single new line\n\n  return {\n    start: Start,\n    tokens: tk\n  };\n}\n\n/**\n * Run the parser state machine on a list of scanned string-based tokens to\n * create a list of multi tokens, each of which represents a URL, email address,\n * plain text, etc.\n *\n * @param {State<MultiToken>} start parser start state\n * @param {string} input the original input used to generate the given tokens\n * @param {Token[]} tokens list of scanned tokens\n * @returns {MultiToken[]}\n */\nfunction run(start, input, tokens) {\n  let len = tokens.length;\n  let cursor = 0;\n  let multis = [];\n  let textTokens = [];\n  while (cursor < len) {\n    let state = start;\n    let secondState = null;\n    let nextState = null;\n    let multiLength = 0;\n    let latestAccepting = null;\n    let sinceAccepts = -1;\n    while (cursor < len && !(secondState = state.go(tokens[cursor].t))) {\n      // Starting tokens with nowhere to jump to.\n      // Consider these to be just plain text\n      textTokens.push(tokens[cursor++]);\n    }\n    while (cursor < len && (nextState = secondState || state.go(tokens[cursor].t))) {\n      // Get the next state\n      secondState = null;\n      state = nextState;\n\n      // Keep track of the latest accepting state\n      if (state.accepts()) {\n        sinceAccepts = 0;\n        latestAccepting = state;\n      } else if (sinceAccepts >= 0) {\n        sinceAccepts++;\n      }\n      cursor++;\n      multiLength++;\n    }\n    if (sinceAccepts < 0) {\n      // No accepting state was found, part of a regular text token add\n      // the first text token to the text tokens array and try again from\n      // the next\n      cursor -= multiLength;\n      if (cursor < len) {\n        textTokens.push(tokens[cursor]);\n        cursor++;\n      }\n    } else {\n      // Accepting state!\n      // First close off the textTokens (if available)\n      if (textTokens.length > 0) {\n        multis.push(initMultiToken(Text, input, textTokens));\n        textTokens = [];\n      }\n\n      // Roll back to the latest accepting state\n      cursor -= sinceAccepts;\n      multiLength -= sinceAccepts;\n\n      // Create a new multitoken\n      const Multi = latestAccepting.t;\n      const subtokens = tokens.slice(cursor - multiLength, cursor);\n      multis.push(initMultiToken(Multi, input, subtokens));\n    }\n  }\n\n  // Finally close off the textTokens (if available)\n  if (textTokens.length > 0) {\n    multis.push(initMultiToken(Text, input, textTokens));\n  }\n  return multis;\n}\n\n/**\n * Utility function for instantiating a new multitoken with all the relevant\n * fields during parsing.\n * @param {new (value: string, tokens: Token[]) => MultiToken} Multi class to instantiate\n * @param {string} input original input string\n * @param {Token[]} tokens consecutive tokens scanned from input string\n * @returns {MultiToken}\n */\nfunction initMultiToken(Multi, input, tokens) {\n  const startIdx = tokens[0].s;\n  const endIdx = tokens[tokens.length - 1].e;\n  const value = input.slice(startIdx, endIdx);\n  return new Multi(value, tokens);\n}\n\nconst warn = typeof console !== 'undefined' && console && console.warn || (() => {});\nconst warnAdvice = 'until manual call of linkify.init(). Register all schemes and plugins before invoking linkify the first time.';\n\n// Side-effect initialization state\nconst INIT = {\n  scanner: null,\n  parser: null,\n  tokenQueue: [],\n  pluginQueue: [],\n  customSchemes: [],\n  initialized: false\n};\n\n/**\n * @typedef {{\n * \tstart: State<string>,\n * \ttokens: { groups: Collections<string> } & typeof tk\n * }} ScannerInit\n */\n\n/**\n * @typedef {{\n * \tstart: State<MultiToken>,\n * \ttokens: typeof multi\n * }} ParserInit\n */\n\n/**\n * @typedef {(arg: { scanner: ScannerInit }) => void} TokenPlugin\n */\n\n/**\n * @typedef {(arg: { scanner: ScannerInit, parser: ParserInit }) => void} Plugin\n */\n\n/**\n * De-register all plugins and reset the internal state-machine. Used for\n * testing; not required in practice.\n * @private\n */\nfunction reset() {\n  State.groups = {};\n  INIT.scanner = null;\n  INIT.parser = null;\n  INIT.tokenQueue = [];\n  INIT.pluginQueue = [];\n  INIT.customSchemes = [];\n  INIT.initialized = false;\n  return INIT;\n}\n\n/**\n * Register a token plugin to allow the scanner to recognize additional token\n * types before the parser state machine is constructed from the results.\n * @param {string} name of plugin to register\n * @param {TokenPlugin} plugin function that accepts the scanner state machine\n * and available scanner tokens and collections and extends the state machine to\n * recognize additional tokens or groups.\n */\nfunction registerTokenPlugin(name, plugin) {\n  if (typeof plugin !== 'function') {\n    throw new Error(`linkifyjs: Invalid token plugin ${plugin} (expects function)`);\n  }\n  for (let i = 0; i < INIT.tokenQueue.length; i++) {\n    if (name === INIT.tokenQueue[i][0]) {\n      warn(`linkifyjs: token plugin \"${name}\" already registered - will be overwritten`);\n      INIT.tokenQueue[i] = [name, plugin];\n      return;\n    }\n  }\n  INIT.tokenQueue.push([name, plugin]);\n  if (INIT.initialized) {\n    warn(`linkifyjs: already initialized - will not register token plugin \"${name}\" ${warnAdvice}`);\n  }\n}\n\n/**\n * Register a linkify plugin\n * @param {string} name of plugin to register\n * @param {Plugin} plugin function that accepts the parser state machine and\n * extends the parser to recognize additional link types\n */\nfunction registerPlugin(name, plugin) {\n  if (typeof plugin !== 'function') {\n    throw new Error(`linkifyjs: Invalid plugin ${plugin} (expects function)`);\n  }\n  for (let i = 0; i < INIT.pluginQueue.length; i++) {\n    if (name === INIT.pluginQueue[i][0]) {\n      warn(`linkifyjs: plugin \"${name}\" already registered - will be overwritten`);\n      INIT.pluginQueue[i] = [name, plugin];\n      return;\n    }\n  }\n  INIT.pluginQueue.push([name, plugin]);\n  if (INIT.initialized) {\n    warn(`linkifyjs: already initialized - will not register plugin \"${name}\" ${warnAdvice}`);\n  }\n}\n\n/**\n * Detect URLs with the following additional protocol. Anything with format\n * \"protocol://...\" will be considered a link. If `optionalSlashSlash` is set to\n * `true`, anything with format \"protocol:...\" will be considered a link.\n * @param {string} scheme\n * @param {boolean} [optionalSlashSlash]\n */\nfunction registerCustomProtocol(scheme, optionalSlashSlash = false) {\n  if (INIT.initialized) {\n    warn(`linkifyjs: already initialized - will not register custom scheme \"${scheme}\" ${warnAdvice}`);\n  }\n  if (!/^[0-9a-z]+(-[0-9a-z]+)*$/.test(scheme)) {\n    throw new Error(`linkifyjs: incorrect scheme format.\n1. Must only contain digits, lowercase ASCII letters or \"-\"\n2. Cannot start or end with \"-\"\n3. \"-\" cannot repeat`);\n  }\n  INIT.customSchemes.push([scheme, optionalSlashSlash]);\n}\n\n/**\n * Initialize the linkify state machine. Called automatically the first time\n * linkify is called on a string, but may be called manually as well.\n */\nfunction init() {\n  // Initialize scanner state machine and plugins\n  INIT.scanner = init$2(INIT.customSchemes);\n  for (let i = 0; i < INIT.tokenQueue.length; i++) {\n    INIT.tokenQueue[i][1]({\n      scanner: INIT.scanner\n    });\n  }\n\n  // Initialize parser state machine and plugins\n  INIT.parser = init$1(INIT.scanner.tokens);\n  for (let i = 0; i < INIT.pluginQueue.length; i++) {\n    INIT.pluginQueue[i][1]({\n      scanner: INIT.scanner,\n      parser: INIT.parser\n    });\n  }\n  INIT.initialized = true;\n  return INIT;\n}\n\n/**\n * Parse a string into tokens that represent linkable and non-linkable sub-components\n * @param {string} str\n * @return {MultiToken[]} tokens\n */\nfunction tokenize(str) {\n  if (!INIT.initialized) {\n    init();\n  }\n  return run(INIT.parser.start, str, run$1(INIT.scanner.start, str));\n}\ntokenize.scan = run$1; // for testing\n\n/**\n * Find a list of linkable items in the given string.\n * @param {string} str string to find links in\n * @param {string | Opts} [type] either formatting options or specific type of\n * links to find, e.g., 'url' or 'email'\n * @param {Opts} [opts] formatting options for final output. Cannot be specified\n * if opts already provided in `type` argument\n */\nfunction find(str, type = null, opts = null) {\n  if (type && typeof type === 'object') {\n    if (opts) {\n      throw Error(`linkifyjs: Invalid link type ${type}; must be a string`);\n    }\n    opts = type;\n    type = null;\n  }\n  const options = new Options(opts);\n  const tokens = tokenize(str);\n  const filtered = [];\n  for (let i = 0; i < tokens.length; i++) {\n    const token = tokens[i];\n    if (token.isLink && (!type || token.t === type) && options.check(token)) {\n      filtered.push(token.toFormattedObject(options));\n    }\n  }\n  return filtered;\n}\n\n/**\n * Is the given string valid linkable text of some sort. Note that this does not\n * trim the text for you.\n *\n * Optionally pass in a second `type` param, which is the type of link to test\n * for.\n *\n * For example,\n *\n *     linkify.test(str, 'email');\n *\n * Returns `true` if str is a valid email.\n * @param {string} str string to test for links\n * @param {string} [type] optional specific link type to look for\n * @returns boolean true/false\n */\nfunction test(str, type = null) {\n  const tokens = tokenize(str);\n  return tokens.length === 1 && tokens[0].isLink && (!type || tokens[0].t === type);\n}\n\nexport { MultiToken, Options, State, createTokenClass, find, init, multi, options, regexp, registerCustomProtocol, registerPlugin, registerTokenPlugin, reset, stringToArray, test, multi as text, tokenize };\n"],"names":["encodedTlds","encodedUtlds","numeric","ascii","alpha","asciinumeric","alphanumeric","domain","emoji","scheme","slashscheme","whitespace","registerGroup","name","groups","addToGroups","flags","k","group","flagsForToken","result","c","State","token","input","state","nextState","i","regex","exactOnly","inputs","next","regexp","len","t","templateState","allFlags","ta","tr","ts","tt","WORD","UWORD","ASCIINUMERICAL","ALPHANUMERICAL","LOCALHOST","TLD","UTLD","SCHEME","SLASH_SCHEME","NUM","WS","NL","OPENBRACE","CLOSEBRACE","OPENBRACKET","CLOSEBRACKET","OPENPAREN","CLOSEPAREN","OPENANGLEBRACKET","CLOSEANGLEBRACKET","FULLWIDTHLEFTPAREN","FULLWIDTHRIGHTPAREN","LEFTCORNERBRACKET","RIGHTCORNERBRACKET","LEFTWHITECORNERBRACKET","RIGHTWHITECORNERBRACKET","FULLWIDTHLESSTHAN","FULLWIDTHGREATERTHAN","AMPERSAND","APOSTROPHE","ASTERISK","AT","BACKSLASH","BACKTICK","CARET","COLON","COMMA","DOLLAR","DOT","EQUALS","EXCLAMATION","HYPHEN","PERCENT","PIPE","PLUS","POUND","QUERY","QUOTE","FULLWIDTHMIDDLEDOT","SEMI","SLASH","TILDE","UNDERSCORE","EMOJI$1","SYM","tk","ASCII_LETTER","LETTER","EMOJI","DIGIT","SPACE","CR","LF","EMOJI_VARIATION","EMOJI_JOINER","OBJECT_REPLACEMENT","tlds","utlds","init$2","customSchemes","Start","decodeTlds","Num","Asciinumeric","Alphanumeric","Word","UWord","Nl","Cr","Ws","Emoji","EmojiJoiner","wordjr","uwordjr","fastts","a","b","sch","run$1","start","str","iterable","stringToArray","charCount","tokens","cursor","charCursor","tokenLength","latestAccepting","sinceAccepts","charsSinceAccepts","index","first","second","char","defaultt","jr","encoded","words","stack","digits","popDigitCount","popCount","defaults","noop","Options","opts","defaultRender","o","ignoredTags","uppercaseIgnoredTags","ir","key","operator","isCallable","option","obj","val","MultiToken","value","options","truncate","formatted","protocol","href","formattedHref","tagName","content","attributes","className","target","rel","attrs","eventListeners","createTokenClass","type","props","Token","p","Email","Text","Url","makeState","arg","init$1","qsAccepting","qsNonAccepting","localpartAccepting","Localpart","Domain","Scheme","SlashScheme","LocalpartAt","LocalpartDot","EmailDomain","EmailDomainDot","Email$1","EmailDomainHyphen","EmailColon","DomainHyphen","DomainDot","DomainDotTld","DomainDotTldColon","DomainDotTldColonPort","Url$1","UrlNonaccept","SchemeColon","SlashSchemeColon","SlashSchemeColonSlash","UriPrefix","bracketPairs","OPEN","CLOSE","UrlOpen","UrlOpenQ","UrlOpenSyms","run","multis","textTokens","secondState","multiLength","initMultiToken","Multi","subtokens","startIdx","endIdx","warn","warnAdvice","INIT","reset","registerCustomProtocol","optionalSlashSlash","init","tokenize","find","filtered"],"mappings":"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","x_google_ignoreList":[0]}