{"version":3,"sources":["webpack:///./node_modules/markdown-it/lib/token.js","webpack:///./node_modules/node-libs-browser/node_modules/punycode/punycode.js","webpack:///./node_modules/mdurl/format.js","webpack:///./node_modules/uc.micro/categories/Z/regex.js","webpack:///./node_modules/uc.micro/categories/Cf/regex.js","webpack:///./node_modules/uc.micro/categories/P/regex.js","webpack:///./node_modules/mdurl/decode.js","webpack:///./node_modules/uc.micro/categories/Cc/regex.js","webpack:///./node_modules/mdurl/encode.js","webpack:///./node_modules/uc.micro/properties/Any/regex.js","webpack:///./node_modules/uc.micro/index.js","webpack:///./node_modules/mdurl/index.js","webpack:///./node_modules/mdurl/parse.js"],"names":["Token","type","tag","nesting","this","attrs","map","level","children","content","markup","info","meta","block","hidden","prototype","attrIndex","name","i","len","length","attrPush","attrData","push","attrSet","value","idx","attrGet","attrJoin","module","exports","root","nodeType","freeGlobal","global","window","self","punycode","maxInt","base","regexPunycode","regexNonASCII","regexSeparators","errors","floor","Math","stringFromCharCode","String","fromCharCode","error","RangeError","array","fn","result","mapDomain","string","parts","split","replace","join","ucs2decode","extra","output","counter","charCodeAt","ucs2encode","basicToDigit","codePoint","digitToBasic","digit","flag","adapt","delta","numPoints","firstTime","k","baseMinusTMin","decode","input","out","basic","j","index","oldi","w","t","baseMinusT","inputLength","n","bias","lastIndexOf","splice","encode","handledCPCount","basicLength","m","q","currentValue","handledCPCountPlusOne","qMinusT","test","slice","toLowerCase","url","protocol","slashes","auth","hostname","indexOf","port","pathname","search","hash","decodeCache","exclude","cache","defaultChars","ch","toString","toUpperCase","getDecodeCache","seq","l","b1","b2","b3","b4","chr","parseInt","componentChars","encodeCache","getEncodeCache","keepEscaped","code","nextCode","encodeURIComponent","Any","Cc","Cf","P","Z","format","parse","Url","protocolPattern","portPattern","simplePathPattern","unwise","concat","autoEscape","nonHostChars","hostEndingChars","hostnamePartPattern","hostnamePartStart","hostlessProtocol","slashedProtocol","slashesDenoteHost","lowerProto","hec","rest","trim","simplePath","exec","proto","substr","match","atSign","hostEnd","host","parseHost","ipv6Hostname","hostparts","part","newpart","validParts","notHost","bit","unshift","qm","u"],"mappings":"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","file":"js/chunk-035d93df.7e290b3e.js","sourcesContent":["// Token class\n\n'use strict';\n\n\n/**\n * class Token\n **/\n\n/**\n * new Token(type, tag, nesting)\n *\n * Create new token and fill passed properties.\n **/\nfunction Token(type, tag, nesting) {\n  /**\n   * Token#type -> String\n   *\n   * Type of the token (string, e.g. \"paragraph_open\")\n   **/\n  this.type     = type;\n\n  /**\n   * Token#tag -> String\n   *\n   * html tag name, e.g. \"p\"\n   **/\n  this.tag      = tag;\n\n  /**\n   * Token#attrs -> Array\n   *\n   * Html attributes. Format: `[ [ name1, value1 ], [ name2, value2 ] ]`\n   **/\n  this.attrs    = null;\n\n  /**\n   * Token#map -> Array\n   *\n   * Source map info. Format: `[ line_begin, line_end ]`\n   **/\n  this.map      = null;\n\n  /**\n   * Token#nesting -> Number\n   *\n   * Level change (number in {-1, 0, 1} set), where:\n   *\n   * -  `1` means the tag is opening\n   * -  `0` means the tag is self-closing\n   * - `-1` means the tag is closing\n   **/\n  this.nesting  = nesting;\n\n  /**\n   * Token#level -> Number\n   *\n   * nesting level, the same as `state.level`\n   **/\n  this.level    = 0;\n\n  /**\n   * Token#children -> Array\n   *\n   * An array of child nodes (inline and img tokens)\n   **/\n  this.children = null;\n\n  /**\n   * Token#content -> String\n   *\n   * In a case of self-closing tag (code, html, fence, etc.),\n   * it has contents of this tag.\n   **/\n  this.content  = '';\n\n  /**\n   * Token#markup -> String\n   *\n   * '*' or '_' for emphasis, fence string for fence, etc.\n   **/\n  this.markup   = '';\n\n  /**\n   * Token#info -> String\n   *\n   * Additional information:\n   *\n   * - Info string for \"fence\" tokens\n   * - The value \"auto\" for autolink \"link_open\" and \"link_close\" tokens\n   * - The string value of the item marker for ordered-list \"list_item_open\" tokens\n   **/\n  this.info     = '';\n\n  /**\n   * Token#meta -> Object\n   *\n   * A place for plugins to store an arbitrary data\n   **/\n  this.meta     = null;\n\n  /**\n   * Token#block -> Boolean\n   *\n   * True for block-level tokens, false for inline tokens.\n   * Used in renderer to calculate line breaks\n   **/\n  this.block    = false;\n\n  /**\n   * Token#hidden -> Boolean\n   *\n   * If it's true, ignore this element when rendering. Used for tight lists\n   * to hide paragraphs.\n   **/\n  this.hidden   = false;\n}\n\n\n/**\n * Token.attrIndex(name) -> Number\n *\n * Search attribute index by name.\n **/\nToken.prototype.attrIndex = function attrIndex(name) {\n  var attrs, i, len;\n\n  if (!this.attrs) { return -1; }\n\n  attrs = this.attrs;\n\n  for (i = 0, len = attrs.length; i < len; i++) {\n    if (attrs[i][0] === name) { return i; }\n  }\n  return -1;\n};\n\n\n/**\n * Token.attrPush(attrData)\n *\n * Add `[ name, value ]` attribute to list. Init attrs if necessary\n **/\nToken.prototype.attrPush = function attrPush(attrData) {\n  if (this.attrs) {\n    this.attrs.push(attrData);\n  } else {\n    this.attrs = [ attrData ];\n  }\n};\n\n\n/**\n * Token.attrSet(name, value)\n *\n * Set `name` attribute to `value`. Override old value if exists.\n **/\nToken.prototype.attrSet = function attrSet(name, value) {\n  var idx = this.attrIndex(name),\n      attrData = [ name, value ];\n\n  if (idx < 0) {\n    this.attrPush(attrData);\n  } else {\n    this.attrs[idx] = attrData;\n  }\n};\n\n\n/**\n * Token.attrGet(name)\n *\n * Get the value of attribute `name`, or null if it does not exist.\n **/\nToken.prototype.attrGet = function attrGet(name) {\n  var idx = this.attrIndex(name), value = null;\n  if (idx >= 0) {\n    value = this.attrs[idx][1];\n  }\n  return value;\n};\n\n\n/**\n * Token.attrJoin(name, value)\n *\n * Join value to existing attribute via space. Or create new attribute if not\n * exists. Useful to operate with token classes.\n **/\nToken.prototype.attrJoin = function attrJoin(name, value) {\n  var idx = this.attrIndex(name);\n\n  if (idx < 0) {\n    this.attrPush([ name, value ]);\n  } else {\n    this.attrs[idx][1] = this.attrs[idx][1] + ' ' + value;\n  }\n};\n\n\nmodule.exports = Token;\n","/*! https://mths.be/punycode v1.4.1 by @mathias */\n;(function(root) {\n\n\t/** Detect free variables */\n\tvar freeExports = typeof exports == 'object' && exports &&\n\t\t!exports.nodeType && exports;\n\tvar freeModule = typeof module == 'object' && module &&\n\t\t!module.nodeType && module;\n\tvar freeGlobal = typeof global == 'object' && global;\n\tif (\n\t\tfreeGlobal.global === freeGlobal ||\n\t\tfreeGlobal.window === freeGlobal ||\n\t\tfreeGlobal.self === freeGlobal\n\t) {\n\t\troot = freeGlobal;\n\t}\n\n\t/**\n\t * The `punycode` object.\n\t * @name punycode\n\t * @type Object\n\t */\n\tvar punycode,\n\n\t/** Highest positive signed 32-bit float value */\n\tmaxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1\n\n\t/** Bootstring parameters */\n\tbase = 36,\n\ttMin = 1,\n\ttMax = 26,\n\tskew = 38,\n\tdamp = 700,\n\tinitialBias = 72,\n\tinitialN = 128, // 0x80\n\tdelimiter = '-', // '\\x2D'\n\n\t/** Regular expressions */\n\tregexPunycode = /^xn--/,\n\tregexNonASCII = /[^\\x20-\\x7E]/, // unprintable ASCII chars + non-ASCII chars\n\tregexSeparators = /[\\x2E\\u3002\\uFF0E\\uFF61]/g, // RFC 3490 separators\n\n\t/** Error messages */\n\terrors = {\n\t\t'overflow': 'Overflow: input needs wider integers to process',\n\t\t'not-basic': 'Illegal input >= 0x80 (not a basic code point)',\n\t\t'invalid-input': 'Invalid input'\n\t},\n\n\t/** Convenience shortcuts */\n\tbaseMinusTMin = base - tMin,\n\tfloor = Math.floor,\n\tstringFromCharCode = String.fromCharCode,\n\n\t/** Temporary variable */\n\tkey;\n\n\t/*--------------------------------------------------------------------------*/\n\n\t/**\n\t * A generic error utility function.\n\t * @private\n\t * @param {String} type The error type.\n\t * @returns {Error} Throws a `RangeError` with the applicable error message.\n\t */\n\tfunction error(type) {\n\t\tthrow new RangeError(errors[type]);\n\t}\n\n\t/**\n\t * A generic `Array#map` utility function.\n\t * @private\n\t * @param {Array} array The array to iterate over.\n\t * @param {Function} callback The function that gets called for every array\n\t * item.\n\t * @returns {Array} A new array of values returned by the callback function.\n\t */\n\tfunction map(array, fn) {\n\t\tvar length = array.length;\n\t\tvar result = [];\n\t\twhile (length--) {\n\t\t\tresult[length] = fn(array[length]);\n\t\t}\n\t\treturn result;\n\t}\n\n\t/**\n\t * A simple `Array#map`-like wrapper to work with domain name strings or email\n\t * addresses.\n\t * @private\n\t * @param {String} domain The domain name or email address.\n\t * @param {Function} callback The function that gets called for every\n\t * character.\n\t * @returns {Array} A new string of characters returned by the callback\n\t * function.\n\t */\n\tfunction mapDomain(string, fn) {\n\t\tvar parts = string.split('@');\n\t\tvar result = '';\n\t\tif (parts.length > 1) {\n\t\t\t// In email addresses, only the domain name should be punycoded. Leave\n\t\t\t// the local part (i.e. everything up to `@`) intact.\n\t\t\tresult = parts[0] + '@';\n\t\t\tstring = parts[1];\n\t\t}\n\t\t// Avoid `split(regex)` for IE8 compatibility. See #17.\n\t\tstring = string.replace(regexSeparators, '\\x2E');\n\t\tvar labels = string.split('.');\n\t\tvar encoded = map(labels, fn).join('.');\n\t\treturn result + encoded;\n\t}\n\n\t/**\n\t * Creates an array containing the numeric code points of each Unicode\n\t * character in the string. While JavaScript uses UCS-2 internally,\n\t * this function will convert a pair of surrogate halves (each of which\n\t * UCS-2 exposes as separate characters) into a single code point,\n\t * matching UTF-16.\n\t * @see `punycode.ucs2.encode`\n\t * @see <https://mathiasbynens.be/notes/javascript-encoding>\n\t * @memberOf punycode.ucs2\n\t * @name decode\n\t * @param {String} string The Unicode input string (UCS-2).\n\t * @returns {Array} The new array of code points.\n\t */\n\tfunction ucs2decode(string) {\n\t\tvar output = [],\n\t\t    counter = 0,\n\t\t    length = string.length,\n\t\t    value,\n\t\t    extra;\n\t\twhile (counter < length) {\n\t\t\tvalue = string.charCodeAt(counter++);\n\t\t\tif (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n\t\t\t\t// high surrogate, and there is a next character\n\t\t\t\textra = string.charCodeAt(counter++);\n\t\t\t\tif ((extra & 0xFC00) == 0xDC00) { // low surrogate\n\t\t\t\t\toutput.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n\t\t\t\t} else {\n\t\t\t\t\t// unmatched surrogate; only append this code unit, in case the next\n\t\t\t\t\t// code unit is the high surrogate of a surrogate pair\n\t\t\t\t\toutput.push(value);\n\t\t\t\t\tcounter--;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\toutput.push(value);\n\t\t\t}\n\t\t}\n\t\treturn output;\n\t}\n\n\t/**\n\t * Creates a string based on an array of numeric code points.\n\t * @see `punycode.ucs2.decode`\n\t * @memberOf punycode.ucs2\n\t * @name encode\n\t * @param {Array} codePoints The array of numeric code points.\n\t * @returns {String} The new Unicode string (UCS-2).\n\t */\n\tfunction ucs2encode(array) {\n\t\treturn map(array, function(value) {\n\t\t\tvar output = '';\n\t\t\tif (value > 0xFFFF) {\n\t\t\t\tvalue -= 0x10000;\n\t\t\t\toutput += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);\n\t\t\t\tvalue = 0xDC00 | value & 0x3FF;\n\t\t\t}\n\t\t\toutput += stringFromCharCode(value);\n\t\t\treturn output;\n\t\t}).join('');\n\t}\n\n\t/**\n\t * Converts a basic code point into a digit/integer.\n\t * @see `digitToBasic()`\n\t * @private\n\t * @param {Number} codePoint The basic numeric code point value.\n\t * @returns {Number} The numeric value of a basic code point (for use in\n\t * representing integers) in the range `0` to `base - 1`, or `base` if\n\t * the code point does not represent a value.\n\t */\n\tfunction basicToDigit(codePoint) {\n\t\tif (codePoint - 48 < 10) {\n\t\t\treturn codePoint - 22;\n\t\t}\n\t\tif (codePoint - 65 < 26) {\n\t\t\treturn codePoint - 65;\n\t\t}\n\t\tif (codePoint - 97 < 26) {\n\t\t\treturn codePoint - 97;\n\t\t}\n\t\treturn base;\n\t}\n\n\t/**\n\t * Converts a digit/integer into a basic code point.\n\t * @see `basicToDigit()`\n\t * @private\n\t * @param {Number} digit The numeric value of a basic code point.\n\t * @returns {Number} The basic code point whose value (when used for\n\t * representing integers) is `digit`, which needs to be in the range\n\t * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is\n\t * used; else, the lowercase form is used. The behavior is undefined\n\t * if `flag` is non-zero and `digit` has no uppercase form.\n\t */\n\tfunction digitToBasic(digit, flag) {\n\t\t//  0..25 map to ASCII a..z or A..Z\n\t\t// 26..35 map to ASCII 0..9\n\t\treturn digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);\n\t}\n\n\t/**\n\t * Bias adaptation function as per section 3.4 of RFC 3492.\n\t * https://tools.ietf.org/html/rfc3492#section-3.4\n\t * @private\n\t */\n\tfunction adapt(delta, numPoints, firstTime) {\n\t\tvar k = 0;\n\t\tdelta = firstTime ? floor(delta / damp) : delta >> 1;\n\t\tdelta += floor(delta / numPoints);\n\t\tfor (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {\n\t\t\tdelta = floor(delta / baseMinusTMin);\n\t\t}\n\t\treturn floor(k + (baseMinusTMin + 1) * delta / (delta + skew));\n\t}\n\n\t/**\n\t * Converts a Punycode string of ASCII-only symbols to a string of Unicode\n\t * symbols.\n\t * @memberOf punycode\n\t * @param {String} input The Punycode string of ASCII-only symbols.\n\t * @returns {String} The resulting string of Unicode symbols.\n\t */\n\tfunction decode(input) {\n\t\t// Don't use UCS-2\n\t\tvar output = [],\n\t\t    inputLength = input.length,\n\t\t    out,\n\t\t    i = 0,\n\t\t    n = initialN,\n\t\t    bias = initialBias,\n\t\t    basic,\n\t\t    j,\n\t\t    index,\n\t\t    oldi,\n\t\t    w,\n\t\t    k,\n\t\t    digit,\n\t\t    t,\n\t\t    /** Cached calculation results */\n\t\t    baseMinusT;\n\n\t\t// Handle the basic code points: let `basic` be the number of input code\n\t\t// points before the last delimiter, or `0` if there is none, then copy\n\t\t// the first basic code points to the output.\n\n\t\tbasic = input.lastIndexOf(delimiter);\n\t\tif (basic < 0) {\n\t\t\tbasic = 0;\n\t\t}\n\n\t\tfor (j = 0; j < basic; ++j) {\n\t\t\t// if it's not a basic code point\n\t\t\tif (input.charCodeAt(j) >= 0x80) {\n\t\t\t\terror('not-basic');\n\t\t\t}\n\t\t\toutput.push(input.charCodeAt(j));\n\t\t}\n\n\t\t// Main decoding loop: start just after the last delimiter if any basic code\n\t\t// points were copied; start at the beginning otherwise.\n\n\t\tfor (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {\n\n\t\t\t// `index` is the index of the next character to be consumed.\n\t\t\t// Decode a generalized variable-length integer into `delta`,\n\t\t\t// which gets added to `i`. The overflow checking is easier\n\t\t\t// if we increase `i` as we go, then subtract off its starting\n\t\t\t// value at the end to obtain `delta`.\n\t\t\tfor (oldi = i, w = 1, k = base; /* no condition */; k += base) {\n\n\t\t\t\tif (index >= inputLength) {\n\t\t\t\t\terror('invalid-input');\n\t\t\t\t}\n\n\t\t\t\tdigit = basicToDigit(input.charCodeAt(index++));\n\n\t\t\t\tif (digit >= base || digit > floor((maxInt - i) / w)) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\ti += digit * w;\n\t\t\t\tt = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\n\t\t\t\tif (digit < t) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\tbaseMinusT = base - t;\n\t\t\t\tif (w > floor(maxInt / baseMinusT)) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\tw *= baseMinusT;\n\n\t\t\t}\n\n\t\t\tout = output.length + 1;\n\t\t\tbias = adapt(i - oldi, out, oldi == 0);\n\n\t\t\t// `i` was supposed to wrap around from `out` to `0`,\n\t\t\t// incrementing `n` each time, so we'll fix that now:\n\t\t\tif (floor(i / out) > maxInt - n) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\tn += floor(i / out);\n\t\t\ti %= out;\n\n\t\t\t// Insert `n` at position `i` of the output\n\t\t\toutput.splice(i++, 0, n);\n\n\t\t}\n\n\t\treturn ucs2encode(output);\n\t}\n\n\t/**\n\t * Converts a string of Unicode symbols (e.g. a domain name label) to a\n\t * Punycode string of ASCII-only symbols.\n\t * @memberOf punycode\n\t * @param {String} input The string of Unicode symbols.\n\t * @returns {String} The resulting Punycode string of ASCII-only symbols.\n\t */\n\tfunction encode(input) {\n\t\tvar n,\n\t\t    delta,\n\t\t    handledCPCount,\n\t\t    basicLength,\n\t\t    bias,\n\t\t    j,\n\t\t    m,\n\t\t    q,\n\t\t    k,\n\t\t    t,\n\t\t    currentValue,\n\t\t    output = [],\n\t\t    /** `inputLength` will hold the number of code points in `input`. */\n\t\t    inputLength,\n\t\t    /** Cached calculation results */\n\t\t    handledCPCountPlusOne,\n\t\t    baseMinusT,\n\t\t    qMinusT;\n\n\t\t// Convert the input in UCS-2 to Unicode\n\t\tinput = ucs2decode(input);\n\n\t\t// Cache the length\n\t\tinputLength = input.length;\n\n\t\t// Initialize the state\n\t\tn = initialN;\n\t\tdelta = 0;\n\t\tbias = initialBias;\n\n\t\t// Handle the basic code points\n\t\tfor (j = 0; j < inputLength; ++j) {\n\t\t\tcurrentValue = input[j];\n\t\t\tif (currentValue < 0x80) {\n\t\t\t\toutput.push(stringFromCharCode(currentValue));\n\t\t\t}\n\t\t}\n\n\t\thandledCPCount = basicLength = output.length;\n\n\t\t// `handledCPCount` is the number of code points that have been handled;\n\t\t// `basicLength` is the number of basic code points.\n\n\t\t// Finish the basic string - if it is not empty - with a delimiter\n\t\tif (basicLength) {\n\t\t\toutput.push(delimiter);\n\t\t}\n\n\t\t// Main encoding loop:\n\t\twhile (handledCPCount < inputLength) {\n\n\t\t\t// All non-basic code points < n have been handled already. Find the next\n\t\t\t// larger one:\n\t\t\tfor (m = maxInt, j = 0; j < inputLength; ++j) {\n\t\t\t\tcurrentValue = input[j];\n\t\t\t\tif (currentValue >= n && currentValue < m) {\n\t\t\t\t\tm = currentValue;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,\n\t\t\t// but guard against overflow\n\t\t\thandledCPCountPlusOne = handledCPCount + 1;\n\t\t\tif (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\tdelta += (m - n) * handledCPCountPlusOne;\n\t\t\tn = m;\n\n\t\t\tfor (j = 0; j < inputLength; ++j) {\n\t\t\t\tcurrentValue = input[j];\n\n\t\t\t\tif (currentValue < n && ++delta > maxInt) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\tif (currentValue == n) {\n\t\t\t\t\t// Represent delta as a generalized variable-length integer\n\t\t\t\t\tfor (q = delta, k = base; /* no condition */; k += base) {\n\t\t\t\t\t\tt = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\t\t\t\t\t\tif (q < t) {\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tqMinusT = q - t;\n\t\t\t\t\t\tbaseMinusT = base - t;\n\t\t\t\t\t\toutput.push(\n\t\t\t\t\t\t\tstringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))\n\t\t\t\t\t\t);\n\t\t\t\t\t\tq = floor(qMinusT / baseMinusT);\n\t\t\t\t\t}\n\n\t\t\t\t\toutput.push(stringFromCharCode(digitToBasic(q, 0)));\n\t\t\t\t\tbias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);\n\t\t\t\t\tdelta = 0;\n\t\t\t\t\t++handledCPCount;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t++delta;\n\t\t\t++n;\n\n\t\t}\n\t\treturn output.join('');\n\t}\n\n\t/**\n\t * Converts a Punycode string representing a domain name or an email address\n\t * to Unicode. Only the Punycoded parts of the input will be converted, i.e.\n\t * it doesn't matter if you call it on a string that has already been\n\t * converted to Unicode.\n\t * @memberOf punycode\n\t * @param {String} input The Punycoded domain name or email address to\n\t * convert to Unicode.\n\t * @returns {String} The Unicode representation of the given Punycode\n\t * string.\n\t */\n\tfunction toUnicode(input) {\n\t\treturn mapDomain(input, function(string) {\n\t\t\treturn regexPunycode.test(string)\n\t\t\t\t? decode(string.slice(4).toLowerCase())\n\t\t\t\t: string;\n\t\t});\n\t}\n\n\t/**\n\t * Converts a Unicode string representing a domain name or an email address to\n\t * Punycode. Only the non-ASCII parts of the domain name will be converted,\n\t * i.e. it doesn't matter if you call it with a domain that's already in\n\t * ASCII.\n\t * @memberOf punycode\n\t * @param {String} input The domain name or email address to convert, as a\n\t * Unicode string.\n\t * @returns {String} The Punycode representation of the given domain name or\n\t * email address.\n\t */\n\tfunction toASCII(input) {\n\t\treturn mapDomain(input, function(string) {\n\t\t\treturn regexNonASCII.test(string)\n\t\t\t\t? 'xn--' + encode(string)\n\t\t\t\t: string;\n\t\t});\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\t/** Define the public API */\n\tpunycode = {\n\t\t/**\n\t\t * A string representing the current Punycode.js version number.\n\t\t * @memberOf punycode\n\t\t * @type String\n\t\t */\n\t\t'version': '1.4.1',\n\t\t/**\n\t\t * An object of methods to convert from JavaScript's internal character\n\t\t * representation (UCS-2) to Unicode code points, and back.\n\t\t * @see <https://mathiasbynens.be/notes/javascript-encoding>\n\t\t * @memberOf punycode\n\t\t * @type Object\n\t\t */\n\t\t'ucs2': {\n\t\t\t'decode': ucs2decode,\n\t\t\t'encode': ucs2encode\n\t\t},\n\t\t'decode': decode,\n\t\t'encode': encode,\n\t\t'toASCII': toASCII,\n\t\t'toUnicode': toUnicode\n\t};\n\n\t/** Expose `punycode` */\n\t// Some AMD build optimizers, like r.js, check for specific condition patterns\n\t// like the following:\n\tif (\n\t\ttypeof define == 'function' &&\n\t\ttypeof define.amd == 'object' &&\n\t\tdefine.amd\n\t) {\n\t\tdefine('punycode', function() {\n\t\t\treturn punycode;\n\t\t});\n\t} else if (freeExports && freeModule) {\n\t\tif (module.exports == freeExports) {\n\t\t\t// in Node.js, io.js, or RingoJS v0.8.0+\n\t\t\tfreeModule.exports = punycode;\n\t\t} else {\n\t\t\t// in Narwhal or RingoJS v0.7.0-\n\t\t\tfor (key in punycode) {\n\t\t\t\tpunycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);\n\t\t\t}\n\t\t}\n\t} else {\n\t\t// in Rhino or a web browser\n\t\troot.punycode = punycode;\n\t}\n\n}(this));\n","\n'use strict';\n\n\nmodule.exports = function format(url) {\n  var result = '';\n\n  result += url.protocol || '';\n  result += url.slashes ? '//' : '';\n  result += url.auth ? url.auth + '@' : '';\n\n  if (url.hostname && url.hostname.indexOf(':') !== -1) {\n    // ipv6 address\n    result += '[' + url.hostname + ']';\n  } else {\n    result += url.hostname || '';\n  }\n\n  result += url.port ? ':' + url.port : '';\n  result += url.pathname || '';\n  result += url.search || '';\n  result += url.hash || '';\n\n  return result;\n};\n","module.exports=/[ \\xA0\\u1680\\u2000-\\u200A\\u2028\\u2029\\u202F\\u205F\\u3000]/","module.exports=/[\\xAD\\u0600-\\u0605\\u061C\\u06DD\\u070F\\u08E2\\u180E\\u200B-\\u200F\\u202A-\\u202E\\u2060-\\u2064\\u2066-\\u206F\\uFEFF\\uFFF9-\\uFFFB]|\\uD804[\\uDCBD\\uDCCD]|\\uD82F[\\uDCA0-\\uDCA3]|\\uD834[\\uDD73-\\uDD7A]|\\uDB40[\\uDC01\\uDC20-\\uDC7F]/","module.exports=/[!-#%-\\*,-\\/:;\\?@\\[-\\]_\\{\\}\\xA1\\xA7\\xAB\\xB6\\xB7\\xBB\\xBF\\u037E\\u0387\\u055A-\\u055F\\u0589\\u058A\\u05BE\\u05C0\\u05C3\\u05C6\\u05F3\\u05F4\\u0609\\u060A\\u060C\\u060D\\u061B\\u061E\\u061F\\u066A-\\u066D\\u06D4\\u0700-\\u070D\\u07F7-\\u07F9\\u0830-\\u083E\\u085E\\u0964\\u0965\\u0970\\u09FD\\u0A76\\u0AF0\\u0C84\\u0DF4\\u0E4F\\u0E5A\\u0E5B\\u0F04-\\u0F12\\u0F14\\u0F3A-\\u0F3D\\u0F85\\u0FD0-\\u0FD4\\u0FD9\\u0FDA\\u104A-\\u104F\\u10FB\\u1360-\\u1368\\u1400\\u166D\\u166E\\u169B\\u169C\\u16EB-\\u16ED\\u1735\\u1736\\u17D4-\\u17D6\\u17D8-\\u17DA\\u1800-\\u180A\\u1944\\u1945\\u1A1E\\u1A1F\\u1AA0-\\u1AA6\\u1AA8-\\u1AAD\\u1B5A-\\u1B60\\u1BFC-\\u1BFF\\u1C3B-\\u1C3F\\u1C7E\\u1C7F\\u1CC0-\\u1CC7\\u1CD3\\u2010-\\u2027\\u2030-\\u2043\\u2045-\\u2051\\u2053-\\u205E\\u207D\\u207E\\u208D\\u208E\\u2308-\\u230B\\u2329\\u232A\\u2768-\\u2775\\u27C5\\u27C6\\u27E6-\\u27EF\\u2983-\\u2998\\u29D8-\\u29DB\\u29FC\\u29FD\\u2CF9-\\u2CFC\\u2CFE\\u2CFF\\u2D70\\u2E00-\\u2E2E\\u2E30-\\u2E4E\\u3001-\\u3003\\u3008-\\u3011\\u3014-\\u301F\\u3030\\u303D\\u30A0\\u30FB\\uA4FE\\uA4FF\\uA60D-\\uA60F\\uA673\\uA67E\\uA6F2-\\uA6F7\\uA874-\\uA877\\uA8CE\\uA8CF\\uA8F8-\\uA8FA\\uA8FC\\uA92E\\uA92F\\uA95F\\uA9C1-\\uA9CD\\uA9DE\\uA9DF\\uAA5C-\\uAA5F\\uAADE\\uAADF\\uAAF0\\uAAF1\\uABEB\\uFD3E\\uFD3F\\uFE10-\\uFE19\\uFE30-\\uFE52\\uFE54-\\uFE61\\uFE63\\uFE68\\uFE6A\\uFE6B\\uFF01-\\uFF03\\uFF05-\\uFF0A\\uFF0C-\\uFF0F\\uFF1A\\uFF1B\\uFF1F\\uFF20\\uFF3B-\\uFF3D\\uFF3F\\uFF5B\\uFF5D\\uFF5F-\\uFF65]|\\uD800[\\uDD00-\\uDD02\\uDF9F\\uDFD0]|\\uD801\\uDD6F|\\uD802[\\uDC57\\uDD1F\\uDD3F\\uDE50-\\uDE58\\uDE7F\\uDEF0-\\uDEF6\\uDF39-\\uDF3F\\uDF99-\\uDF9C]|\\uD803[\\uDF55-\\uDF59]|\\uD804[\\uDC47-\\uDC4D\\uDCBB\\uDCBC\\uDCBE-\\uDCC1\\uDD40-\\uDD43\\uDD74\\uDD75\\uDDC5-\\uDDC8\\uDDCD\\uDDDB\\uDDDD-\\uDDDF\\uDE38-\\uDE3D\\uDEA9]|\\uD805[\\uDC4B-\\uDC4F\\uDC5B\\uDC5D\\uDCC6\\uDDC1-\\uDDD7\\uDE41-\\uDE43\\uDE60-\\uDE6C\\uDF3C-\\uDF3E]|\\uD806[\\uDC3B\\uDE3F-\\uDE46\\uDE9A-\\uDE9C\\uDE9E-\\uDEA2]|\\uD807[\\uDC41-\\uDC45\\uDC70\\uDC71\\uDEF7\\uDEF8]|\\uD809[\\uDC70-\\uDC74]|\\uD81A[\\uDE6E\\uDE6F\\uDEF5\\uDF37-\\uDF3B\\uDF44]|\\uD81B[\\uDE97-\\uDE9A]|\\uD82F\\uDC9F|\\uD836[\\uDE87-\\uDE8B]|\\uD83A[\\uDD5E\\uDD5F]/","\n'use strict';\n\n\n/* eslint-disable no-bitwise */\n\nvar decodeCache = {};\n\nfunction getDecodeCache(exclude) {\n  var i, ch, cache = decodeCache[exclude];\n  if (cache) { return cache; }\n\n  cache = decodeCache[exclude] = [];\n\n  for (i = 0; i < 128; i++) {\n    ch = String.fromCharCode(i);\n    cache.push(ch);\n  }\n\n  for (i = 0; i < exclude.length; i++) {\n    ch = exclude.charCodeAt(i);\n    cache[ch] = '%' + ('0' + ch.toString(16).toUpperCase()).slice(-2);\n  }\n\n  return cache;\n}\n\n\n// Decode percent-encoded string.\n//\nfunction decode(string, exclude) {\n  var cache;\n\n  if (typeof exclude !== 'string') {\n    exclude = decode.defaultChars;\n  }\n\n  cache = getDecodeCache(exclude);\n\n  return string.replace(/(%[a-f0-9]{2})+/gi, function(seq) {\n    var i, l, b1, b2, b3, b4, chr,\n        result = '';\n\n    for (i = 0, l = seq.length; i < l; i += 3) {\n      b1 = parseInt(seq.slice(i + 1, i + 3), 16);\n\n      if (b1 < 0x80) {\n        result += cache[b1];\n        continue;\n      }\n\n      if ((b1 & 0xE0) === 0xC0 && (i + 3 < l)) {\n        // 110xxxxx 10xxxxxx\n        b2 = parseInt(seq.slice(i + 4, i + 6), 16);\n\n        if ((b2 & 0xC0) === 0x80) {\n          chr = ((b1 << 6) & 0x7C0) | (b2 & 0x3F);\n\n          if (chr < 0x80) {\n            result += '\\ufffd\\ufffd';\n          } else {\n            result += String.fromCharCode(chr);\n          }\n\n          i += 3;\n          continue;\n        }\n      }\n\n      if ((b1 & 0xF0) === 0xE0 && (i + 6 < l)) {\n        // 1110xxxx 10xxxxxx 10xxxxxx\n        b2 = parseInt(seq.slice(i + 4, i + 6), 16);\n        b3 = parseInt(seq.slice(i + 7, i + 9), 16);\n\n        if ((b2 & 0xC0) === 0x80 && (b3 & 0xC0) === 0x80) {\n          chr = ((b1 << 12) & 0xF000) | ((b2 << 6) & 0xFC0) | (b3 & 0x3F);\n\n          if (chr < 0x800 || (chr >= 0xD800 && chr <= 0xDFFF)) {\n            result += '\\ufffd\\ufffd\\ufffd';\n          } else {\n            result += String.fromCharCode(chr);\n          }\n\n          i += 6;\n          continue;\n        }\n      }\n\n      if ((b1 & 0xF8) === 0xF0 && (i + 9 < l)) {\n        // 111110xx 10xxxxxx 10xxxxxx 10xxxxxx\n        b2 = parseInt(seq.slice(i + 4, i + 6), 16);\n        b3 = parseInt(seq.slice(i + 7, i + 9), 16);\n        b4 = parseInt(seq.slice(i + 10, i + 12), 16);\n\n        if ((b2 & 0xC0) === 0x80 && (b3 & 0xC0) === 0x80 && (b4 & 0xC0) === 0x80) {\n          chr = ((b1 << 18) & 0x1C0000) | ((b2 << 12) & 0x3F000) | ((b3 << 6) & 0xFC0) | (b4 & 0x3F);\n\n          if (chr < 0x10000 || chr > 0x10FFFF) {\n            result += '\\ufffd\\ufffd\\ufffd\\ufffd';\n          } else {\n            chr -= 0x10000;\n            result += String.fromCharCode(0xD800 + (chr >> 10), 0xDC00 + (chr & 0x3FF));\n          }\n\n          i += 9;\n          continue;\n        }\n      }\n\n      result += '\\ufffd';\n    }\n\n    return result;\n  });\n}\n\n\ndecode.defaultChars   = ';/?:@&=+$,#';\ndecode.componentChars = '';\n\n\nmodule.exports = decode;\n","module.exports=/[\\0-\\x1F\\x7F-\\x9F]/","\n'use strict';\n\n\nvar encodeCache = {};\n\n\n// Create a lookup array where anything but characters in `chars` string\n// and alphanumeric chars is percent-encoded.\n//\nfunction getEncodeCache(exclude) {\n  var i, ch, cache = encodeCache[exclude];\n  if (cache) { return cache; }\n\n  cache = encodeCache[exclude] = [];\n\n  for (i = 0; i < 128; i++) {\n    ch = String.fromCharCode(i);\n\n    if (/^[0-9a-z]$/i.test(ch)) {\n      // always allow unencoded alphanumeric characters\n      cache.push(ch);\n    } else {\n      cache.push('%' + ('0' + i.toString(16).toUpperCase()).slice(-2));\n    }\n  }\n\n  for (i = 0; i < exclude.length; i++) {\n    cache[exclude.charCodeAt(i)] = exclude[i];\n  }\n\n  return cache;\n}\n\n\n// Encode unsafe characters with percent-encoding, skipping already\n// encoded sequences.\n//\n//  - string       - string to encode\n//  - exclude      - list of characters to ignore (in addition to a-zA-Z0-9)\n//  - keepEscaped  - don't encode '%' in a correct escape sequence (default: true)\n//\nfunction encode(string, exclude, keepEscaped) {\n  var i, l, code, nextCode, cache,\n      result = '';\n\n  if (typeof exclude !== 'string') {\n    // encode(string, keepEscaped)\n    keepEscaped  = exclude;\n    exclude = encode.defaultChars;\n  }\n\n  if (typeof keepEscaped === 'undefined') {\n    keepEscaped = true;\n  }\n\n  cache = getEncodeCache(exclude);\n\n  for (i = 0, l = string.length; i < l; i++) {\n    code = string.charCodeAt(i);\n\n    if (keepEscaped && code === 0x25 /* % */ && i + 2 < l) {\n      if (/^[0-9a-f]{2}$/i.test(string.slice(i + 1, i + 3))) {\n        result += string.slice(i, i + 3);\n        i += 2;\n        continue;\n      }\n    }\n\n    if (code < 128) {\n      result += cache[code];\n      continue;\n    }\n\n    if (code >= 0xD800 && code <= 0xDFFF) {\n      if (code >= 0xD800 && code <= 0xDBFF && i + 1 < l) {\n        nextCode = string.charCodeAt(i + 1);\n        if (nextCode >= 0xDC00 && nextCode <= 0xDFFF) {\n          result += encodeURIComponent(string[i] + string[i + 1]);\n          i++;\n          continue;\n        }\n      }\n      result += '%EF%BF%BD';\n      continue;\n    }\n\n    result += encodeURIComponent(string[i]);\n  }\n\n  return result;\n}\n\nencode.defaultChars   = \";/?:@&=+$,-_.!~*'()#\";\nencode.componentChars = \"-_.!~*'()\";\n\n\nmodule.exports = encode;\n","module.exports=/[\\0-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF]/","'use strict';\n\nexports.Any = require('./properties/Any/regex');\nexports.Cc  = require('./categories/Cc/regex');\nexports.Cf  = require('./categories/Cf/regex');\nexports.P   = require('./categories/P/regex');\nexports.Z   = require('./categories/Z/regex');\n","'use strict';\n\n\nmodule.exports.encode = require('./encode');\nmodule.exports.decode = require('./decode');\nmodule.exports.format = require('./format');\nmodule.exports.parse  = require('./parse');\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\n//\n// Changes from joyent/node:\n//\n// 1. No leading slash in paths,\n//    e.g. in `url.parse('http://foo?bar')` pathname is ``, not `/`\n//\n// 2. Backslashes are not replaced with slashes,\n//    so `http:\\\\example.org\\` is treated like a relative path\n//\n// 3. Trailing colon is treated like a part of the path,\n//    i.e. in `http://example.org:foo` pathname is `:foo`\n//\n// 4. Nothing is URL-encoded in the resulting object,\n//    (in joyent/node some chars in auth and paths are encoded)\n//\n// 5. `url.parse()` does not have `parseQueryString` argument\n//\n// 6. Removed extraneous result properties: `host`, `path`, `query`, etc.,\n//    which can be constructed using other parts of the url.\n//\n\n\nfunction Url() {\n  this.protocol = null;\n  this.slashes = null;\n  this.auth = null;\n  this.port = null;\n  this.hostname = null;\n  this.hash = null;\n  this.search = null;\n  this.pathname = null;\n}\n\n// Reference: RFC 3986, RFC 1808, RFC 2396\n\n// define these here so at least they only have to be\n// compiled once on the first module load.\nvar protocolPattern = /^([a-z0-9.+-]+:)/i,\n    portPattern = /:[0-9]*$/,\n\n    // Special case for a simple path URL\n    simplePathPattern = /^(\\/\\/?(?!\\/)[^\\?\\s]*)(\\?[^\\s]*)?$/,\n\n    // RFC 2396: characters reserved for delimiting URLs.\n    // We actually just auto-escape these.\n    delims = [ '<', '>', '\"', '`', ' ', '\\r', '\\n', '\\t' ],\n\n    // RFC 2396: characters not allowed for various reasons.\n    unwise = [ '{', '}', '|', '\\\\', '^', '`' ].concat(delims),\n\n    // Allowed by RFCs, but cause of XSS attacks.  Always escape these.\n    autoEscape = [ '\\'' ].concat(unwise),\n    // Characters that are never ever allowed in a hostname.\n    // Note that any invalid chars are also handled, but these\n    // are the ones that are *expected* to be seen, so we fast-path\n    // them.\n    nonHostChars = [ '%', '/', '?', ';', '#' ].concat(autoEscape),\n    hostEndingChars = [ '/', '?', '#' ],\n    hostnameMaxLen = 255,\n    hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,\n    hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,\n    // protocols that can allow \"unsafe\" and \"unwise\" chars.\n    /* eslint-disable no-script-url */\n    // protocols that never have a hostname.\n    hostlessProtocol = {\n      'javascript': true,\n      'javascript:': true\n    },\n    // protocols that always contain a // bit.\n    slashedProtocol = {\n      'http': true,\n      'https': true,\n      'ftp': true,\n      'gopher': true,\n      'file': true,\n      'http:': true,\n      'https:': true,\n      'ftp:': true,\n      'gopher:': true,\n      'file:': true\n    };\n    /* eslint-enable no-script-url */\n\nfunction urlParse(url, slashesDenoteHost) {\n  if (url && url instanceof Url) { return url; }\n\n  var u = new Url();\n  u.parse(url, slashesDenoteHost);\n  return u;\n}\n\nUrl.prototype.parse = function(url, slashesDenoteHost) {\n  var i, l, lowerProto, hec, slashes,\n      rest = url;\n\n  // trim before proceeding.\n  // This is to support parse stuff like \"  http://foo.com  \\n\"\n  rest = rest.trim();\n\n  if (!slashesDenoteHost && url.split('#').length === 1) {\n    // Try fast path regexp\n    var simplePath = simplePathPattern.exec(rest);\n    if (simplePath) {\n      this.pathname = simplePath[1];\n      if (simplePath[2]) {\n        this.search = simplePath[2];\n      }\n      return this;\n    }\n  }\n\n  var proto = protocolPattern.exec(rest);\n  if (proto) {\n    proto = proto[0];\n    lowerProto = proto.toLowerCase();\n    this.protocol = proto;\n    rest = rest.substr(proto.length);\n  }\n\n  // figure out if it's got a host\n  // user@server is *always* interpreted as a hostname, and url\n  // resolution will treat //foo/bar as host=foo,path=bar because that's\n  // how the browser resolves relative URLs.\n  if (slashesDenoteHost || proto || rest.match(/^\\/\\/[^@\\/]+@[^@\\/]+/)) {\n    slashes = rest.substr(0, 2) === '//';\n    if (slashes && !(proto && hostlessProtocol[proto])) {\n      rest = rest.substr(2);\n      this.slashes = true;\n    }\n  }\n\n  if (!hostlessProtocol[proto] &&\n      (slashes || (proto && !slashedProtocol[proto]))) {\n\n    // there's a hostname.\n    // the first instance of /, ?, ;, or # ends the host.\n    //\n    // If there is an @ in the hostname, then non-host chars *are* allowed\n    // to the left of the last @ sign, unless some host-ending character\n    // comes *before* the @-sign.\n    // URLs are obnoxious.\n    //\n    // ex:\n    // http://a@b@c/ => user:a@b host:c\n    // http://a@b?@c => user:a host:c path:/?@c\n\n    // v0.12 TODO(isaacs): This is not quite how Chrome does things.\n    // Review our test case against browsers more comprehensively.\n\n    // find the first instance of any hostEndingChars\n    var hostEnd = -1;\n    for (i = 0; i < hostEndingChars.length; i++) {\n      hec = rest.indexOf(hostEndingChars[i]);\n      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {\n        hostEnd = hec;\n      }\n    }\n\n    // at this point, either we have an explicit point where the\n    // auth portion cannot go past, or the last @ char is the decider.\n    var auth, atSign;\n    if (hostEnd === -1) {\n      // atSign can be anywhere.\n      atSign = rest.lastIndexOf('@');\n    } else {\n      // atSign must be in auth portion.\n      // http://a@b/c@d => host:b auth:a path:/c@d\n      atSign = rest.lastIndexOf('@', hostEnd);\n    }\n\n    // Now we have a portion which is definitely the auth.\n    // Pull that off.\n    if (atSign !== -1) {\n      auth = rest.slice(0, atSign);\n      rest = rest.slice(atSign + 1);\n      this.auth = auth;\n    }\n\n    // the host is the remaining to the left of the first non-host char\n    hostEnd = -1;\n    for (i = 0; i < nonHostChars.length; i++) {\n      hec = rest.indexOf(nonHostChars[i]);\n      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {\n        hostEnd = hec;\n      }\n    }\n    // if we still have not hit it, then the entire thing is a host.\n    if (hostEnd === -1) {\n      hostEnd = rest.length;\n    }\n\n    if (rest[hostEnd - 1] === ':') { hostEnd--; }\n    var host = rest.slice(0, hostEnd);\n    rest = rest.slice(hostEnd);\n\n    // pull out port.\n    this.parseHost(host);\n\n    // we've indicated that there is a hostname,\n    // so even if it's empty, it has to be present.\n    this.hostname = this.hostname || '';\n\n    // if hostname begins with [ and ends with ]\n    // assume that it's an IPv6 address.\n    var ipv6Hostname = this.hostname[0] === '[' &&\n        this.hostname[this.hostname.length - 1] === ']';\n\n    // validate a little.\n    if (!ipv6Hostname) {\n      var hostparts = this.hostname.split(/\\./);\n      for (i = 0, l = hostparts.length; i < l; i++) {\n        var part = hostparts[i];\n        if (!part) { continue; }\n        if (!part.match(hostnamePartPattern)) {\n          var newpart = '';\n          for (var j = 0, k = part.length; j < k; j++) {\n            if (part.charCodeAt(j) > 127) {\n              // we replace non-ASCII char with a temporary placeholder\n              // we need this to make sure size of hostname is not\n              // broken by replacing non-ASCII by nothing\n              newpart += 'x';\n            } else {\n              newpart += part[j];\n            }\n          }\n          // we test again with ASCII char only\n          if (!newpart.match(hostnamePartPattern)) {\n            var validParts = hostparts.slice(0, i);\n            var notHost = hostparts.slice(i + 1);\n            var bit = part.match(hostnamePartStart);\n            if (bit) {\n              validParts.push(bit[1]);\n              notHost.unshift(bit[2]);\n            }\n            if (notHost.length) {\n              rest = notHost.join('.') + rest;\n            }\n            this.hostname = validParts.join('.');\n            break;\n          }\n        }\n      }\n    }\n\n    if (this.hostname.length > hostnameMaxLen) {\n      this.hostname = '';\n    }\n\n    // strip [ and ] from the hostname\n    // the host field still retains them, though\n    if (ipv6Hostname) {\n      this.hostname = this.hostname.substr(1, this.hostname.length - 2);\n    }\n  }\n\n  // chop off from the tail first.\n  var hash = rest.indexOf('#');\n  if (hash !== -1) {\n    // got a fragment string.\n    this.hash = rest.substr(hash);\n    rest = rest.slice(0, hash);\n  }\n  var qm = rest.indexOf('?');\n  if (qm !== -1) {\n    this.search = rest.substr(qm);\n    rest = rest.slice(0, qm);\n  }\n  if (rest) { this.pathname = rest; }\n  if (slashedProtocol[lowerProto] &&\n      this.hostname && !this.pathname) {\n    this.pathname = '';\n  }\n\n  return this;\n};\n\nUrl.prototype.parseHost = function(host) {\n  var port = portPattern.exec(host);\n  if (port) {\n    port = port[0];\n    if (port !== ':') {\n      this.port = port.substr(1);\n    }\n    host = host.substr(0, host.length - port.length);\n  }\n  if (host) { this.hostname = host; }\n};\n\nmodule.exports = urlParse;\n"],"sourceRoot":""}