{"version":3,"sources":["webpack:///./node_modules/querystring-es3/encode.js","webpack:///./node_modules/url/url.js","webpack:///./node_modules/node-libs-browser/node_modules/punycode/punycode.js","webpack:///./node_modules/url/util.js","webpack:///./node_modules/htmlsanitize/lib/uri.js","webpack:///./node_modules/escape-html/index.js","webpack:///./node_modules/htmlsanitize/lib/index.js","webpack:///./node_modules/isomorphic-html-sanitize/client/sanitize.js","webpack:///./node_modules/querystring-es3/decode.js","webpack:///./node_modules/querystring-es3/index.js"],"names":["stringifyPrimitive","v","isFinite","module","exports","obj","sep","eq","name","undefined","map","objectKeys","k","ks","encodeURIComponent","isArray","join","Array","xs","Object","prototype","toString","call","f","res","i","length","push","keys","key","hasOwnProperty","punycode","util","Url","this","protocol","slashes","auth","host","port","hostname","hash","search","query","pathname","path","href","parse","urlParse","resolve","source","relative","resolveObject","format","isString","protocolPattern","portPattern","simplePathPattern","unwise","concat","autoEscape","nonHostChars","hostEndingChars","hostnamePartPattern","hostnamePartStart","unsafeProtocol","hostlessProtocol","slashedProtocol","querystring","url","parseQueryString","slashesDenoteHost","isObject","u","TypeError","queryIndex","indexOf","splitter","uSplit","split","replace","rest","trim","simplePath","exec","substr","proto","lowerProto","toLowerCase","match","atSign","hostEnd","hec","lastIndexOf","slice","decodeURIComponent","parseHost","ipv6Hostname","hostparts","l","part","newpart","j","charCodeAt","validParts","notHost","bit","unshift","toASCII","p","h","ae","esc","escape","qm","s","stringify","charAt","rel","result","tkeys","tk","tkey","rkeys","rk","rkey","relPath","shift","isSourceAbs","isRelAbs","mustEndAbs","removeAllDots","srcPath","psychotic","pop","isNullOrUndefined","authInHost","isNull","last","hasTrailingSlash","up","splice","isAbsolute","root","nodeType","freeGlobal","global","window","self","maxInt","regexPunycode","regexNonASCII","regexSeparators","errors","floor","Math","stringFromCharCode","String","fromCharCode","error","type","RangeError","array","fn","mapDomain","string","parts","ucs2decode","value","extra","output","counter","ucs2encode","digitToBasic","digit","flag","adapt","delta","numPoints","firstTime","baseMinusTMin","base","decode","input","out","basic","index","oldi","w","t","baseMinusT","codePoint","inputLength","n","bias","encode","handledCPCount","basicLength","m","q","currentValue","handledCPCountPlusOne","qMinusT","test","arg","aHrefSanitizationWhitelist","imgSrcSanitizationWhitelist","uri","isImage","regex","normalizedVal","matchHtmlRegExp","str","html","lastIndex","substring","escapeHTML","sanitizeUri","toMap","lowercaseKeys","items","voidElements","optionalEndTagBlockElements","optionalEndTagInlineElements","optionalEndTagElements","assign","blockElements","inlineElements","blockedElements","validElements","uriAttrs","htmlAttrs","svgAttrs","validAttrs","getInertBodyElement","document","inertDocument","implementation","Error","inertBodyElement","createHTMLDocument","documentElement","getDocumentElement","querySelector","innerHTML","body","DOMParser","parseFromString","firstChild","remove","e","documentMode","stripCustomNsAttrs","encodeURI","xhr","XMLHttpRequest","responseType","open","send","response","attrToMap","attrs","ii","attr","node","Node","ELEMENT_NODE","attributes","attrNode","attrName","removeAttributeNode","nextNode","getNonDescendant","propName","parentNode","containsNode","outerHTML","outerText","buf","handler","mXSSAttempts","start","nodeName","chars","textContent","end","removeChild","htmlParser","uriValidator","ignoreCurrentElement","tag","forEach","lkey","_chars","htmlSanitizeWriter","prop","qs","options","regexp","maxKeys","len","kstr","vstr","x","idx"],"mappings":"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","file":"7390d24a3eb14421b98b676349696fde8910a2b3-6984e0b856cec4c74906.js","sourcesContent":["// 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'use strict';\n\nvar stringifyPrimitive = function stringifyPrimitive(v) {\n  switch (typeof v) {\n    case 'string':\n      return v;\n\n    case 'boolean':\n      return v ? 'true' : 'false';\n\n    case 'number':\n      return isFinite(v) ? v : '';\n\n    default:\n      return '';\n  }\n};\n\nmodule.exports = function (obj, sep, eq, name) {\n  sep = sep || '&';\n  eq = eq || '=';\n\n  if (obj === null) {\n    obj = undefined;\n  }\n\n  if (typeof obj === 'object') {\n    return map(objectKeys(obj), function (k) {\n      var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;\n\n      if (isArray(obj[k])) {\n        return map(obj[k], function (v) {\n          return ks + encodeURIComponent(stringifyPrimitive(v));\n        }).join(sep);\n      } else {\n        return ks + encodeURIComponent(stringifyPrimitive(obj[k]));\n      }\n    }).join(sep);\n  }\n\n  if (!name) return '';\n  return encodeURIComponent(stringifyPrimitive(name)) + eq + encodeURIComponent(stringifyPrimitive(obj));\n};\n\nvar isArray = Array.isArray || function (xs) {\n  return Object.prototype.toString.call(xs) === '[object Array]';\n};\n\nfunction map(xs, f) {\n  if (xs.map) return xs.map(f);\n  var res = [];\n\n  for (var i = 0; i < xs.length; i++) {\n    res.push(f(xs[i], i));\n  }\n\n  return res;\n}\n\nvar objectKeys = Object.keys || function (obj) {\n  var res = [];\n\n  for (var key in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, key)) res.push(key);\n  }\n\n  return res;\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'use strict';\n\nvar punycode = require('punycode');\n\nvar util = require('./util');\n\nexports.parse = urlParse;\nexports.resolve = urlResolve;\nexports.resolveObject = urlResolveObject;\nexports.format = urlFormat;\nexports.Url = Url;\n\nfunction Url() {\n  this.protocol = null;\n  this.slashes = null;\n  this.auth = null;\n  this.host = null;\n  this.port = null;\n  this.hostname = null;\n  this.hash = null;\n  this.search = null;\n  this.query = null;\n  this.pathname = null;\n  this.path = null;\n  this.href = null;\n} // Reference: RFC 3986, RFC 1808, RFC 2396\n// define these here so at least they only have to be\n// compiled once on the first module load.\n\n\nvar protocolPattern = /^([a-z0-9.+-]+:)/i,\n    portPattern = /:[0-9]*$/,\n    // Special case for a simple path URL\nsimplePathPattern = /^(\\/\\/?(?!\\/)[^\\?\\s]*)(\\?[^\\s]*)?$/,\n    // RFC 2396: characters reserved for delimiting URLs.\n// We actually just auto-escape these.\ndelims = ['<', '>', '\"', '`', ' ', '\\r', '\\n', '\\t'],\n    // RFC 2396: characters not allowed for various reasons.\nunwise = ['{', '}', '|', '\\\\', '^', '`'].concat(delims),\n    // Allowed by RFCs, but cause of XSS attacks.  Always escape these.\nautoEscape = ['\\''].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.\nnonHostChars = ['%', '/', '?', ';', '#'].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.\nunsafeProtocol = {\n  'javascript': true,\n  'javascript:': true\n},\n    // protocols that never have a hostname.\nhostlessProtocol = {\n  'javascript': true,\n  'javascript:': true\n},\n    // protocols that always contain a // bit.\nslashedProtocol = {\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    querystring = require('querystring');\n\nfunction urlParse(url, parseQueryString, slashesDenoteHost) {\n  if (url && util.isObject(url) && url instanceof Url) return url;\n  var u = new Url();\n  u.parse(url, parseQueryString, slashesDenoteHost);\n  return u;\n}\n\nUrl.prototype.parse = function (url, parseQueryString, slashesDenoteHost) {\n  if (!util.isString(url)) {\n    throw new TypeError(\"Parameter 'url' must be a string, not \" + typeof url);\n  } // Copy chrome, IE, opera backslash-handling behavior.\n  // Back slashes before the query string get converted to forward slashes\n  // See: https://code.google.com/p/chromium/issues/detail?id=25916\n\n\n  var queryIndex = url.indexOf('?'),\n      splitter = queryIndex !== -1 && queryIndex < url.indexOf('#') ? '?' : '#',\n      uSplit = url.split(splitter),\n      slashRegex = /\\\\/g;\n  uSplit[0] = uSplit[0].replace(slashRegex, '/');\n  url = uSplit.join(splitter);\n  var rest = url; // trim before proceeding.\n  // This is to support parse stuff like \"  http://foo.com  \\n\"\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\n    if (simplePath) {\n      this.path = rest;\n      this.href = rest;\n      this.pathname = simplePath[1];\n\n      if (simplePath[2]) {\n        this.search = simplePath[2];\n\n        if (parseQueryString) {\n          this.query = querystring.parse(this.search.substr(1));\n        } else {\n          this.query = this.search.substr(1);\n        }\n      } else if (parseQueryString) {\n        this.search = '';\n        this.query = {};\n      }\n\n      return this;\n    }\n  }\n\n  var proto = protocolPattern.exec(rest);\n\n  if (proto) {\n    proto = proto[0];\n    var lowerProto = proto.toLowerCase();\n    this.protocol = lowerProto;\n    rest = rest.substr(proto.length);\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\n\n  if (slashesDenoteHost || proto || rest.match(/^\\/\\/[^@\\/]+@[^@\\/]+/)) {\n    var slashes = rest.substr(0, 2) === '//';\n\n    if (slashes && !(proto && hostlessProtocol[proto])) {\n      rest = rest.substr(2);\n      this.slashes = true;\n    }\n  }\n\n  if (!hostlessProtocol[proto] && (slashes || proto && !slashedProtocol[proto])) {\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    // v0.12 TODO(isaacs): This is not quite how Chrome does things.\n    // Review our test case against browsers more comprehensively.\n    // find the first instance of any hostEndingChars\n    var hostEnd = -1;\n\n    for (var i = 0; i < hostEndingChars.length; i++) {\n      var hec = rest.indexOf(hostEndingChars[i]);\n      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) hostEnd = hec;\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\n\n    var auth, atSign;\n\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    } // Now we have a portion which is definitely the auth.\n    // Pull that off.\n\n\n    if (atSign !== -1) {\n      auth = rest.slice(0, atSign);\n      rest = rest.slice(atSign + 1);\n      this.auth = decodeURIComponent(auth);\n    } // the host is the remaining to the left of the first non-host char\n\n\n    hostEnd = -1;\n\n    for (var i = 0; i < nonHostChars.length; i++) {\n      var hec = rest.indexOf(nonHostChars[i]);\n      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) hostEnd = hec;\n    } // if we still have not hit it, then the entire thing is a host.\n\n\n    if (hostEnd === -1) hostEnd = rest.length;\n    this.host = rest.slice(0, hostEnd);\n    rest = rest.slice(hostEnd); // pull out port.\n\n    this.parseHost(); // we've indicated that there is a hostname,\n    // so even if it's empty, it has to be present.\n\n    this.hostname = this.hostname || ''; // if hostname begins with [ and ends with ]\n    // assume that it's an IPv6 address.\n\n    var ipv6Hostname = this.hostname[0] === '[' && this.hostname[this.hostname.length - 1] === ']'; // validate a little.\n\n    if (!ipv6Hostname) {\n      var hostparts = this.hostname.split(/\\./);\n\n      for (var i = 0, l = hostparts.length; i < l; i++) {\n        var part = hostparts[i];\n        if (!part) continue;\n\n        if (!part.match(hostnamePartPattern)) {\n          var newpart = '';\n\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          } // we test again with ASCII char only\n\n\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\n            if (bit) {\n              validParts.push(bit[1]);\n              notHost.unshift(bit[2]);\n            }\n\n            if (notHost.length) {\n              rest = '/' + notHost.join('.') + rest;\n            }\n\n            this.hostname = validParts.join('.');\n            break;\n          }\n        }\n      }\n    }\n\n    if (this.hostname.length > hostnameMaxLen) {\n      this.hostname = '';\n    } else {\n      // hostnames are always lower case.\n      this.hostname = this.hostname.toLowerCase();\n    }\n\n    if (!ipv6Hostname) {\n      // IDNA Support: Returns a punycoded representation of \"domain\".\n      // It only converts parts of the domain name that\n      // have non-ASCII characters, i.e. it doesn't matter if\n      // you call it with a domain that already is ASCII-only.\n      this.hostname = punycode.toASCII(this.hostname);\n    }\n\n    var p = this.port ? ':' + this.port : '';\n    var h = this.hostname || '';\n    this.host = h + p;\n    this.href += this.host; // strip [ and ] from the hostname\n    // the host field still retains them, though\n\n    if (ipv6Hostname) {\n      this.hostname = this.hostname.substr(1, this.hostname.length - 2);\n\n      if (rest[0] !== '/') {\n        rest = '/' + rest;\n      }\n    }\n  } // now rest is set to the post-host stuff.\n  // chop off any delim chars.\n\n\n  if (!unsafeProtocol[lowerProto]) {\n    // First, make 100% sure that any \"autoEscape\" chars get\n    // escaped, even if encodeURIComponent doesn't think they\n    // need to be.\n    for (var i = 0, l = autoEscape.length; i < l; i++) {\n      var ae = autoEscape[i];\n      if (rest.indexOf(ae) === -1) continue;\n      var esc = encodeURIComponent(ae);\n\n      if (esc === ae) {\n        esc = escape(ae);\n      }\n\n      rest = rest.split(ae).join(esc);\n    }\n  } // chop off from the tail first.\n\n\n  var hash = rest.indexOf('#');\n\n  if (hash !== -1) {\n    // got a fragment string.\n    this.hash = rest.substr(hash);\n    rest = rest.slice(0, hash);\n  }\n\n  var qm = rest.indexOf('?');\n\n  if (qm !== -1) {\n    this.search = rest.substr(qm);\n    this.query = rest.substr(qm + 1);\n\n    if (parseQueryString) {\n      this.query = querystring.parse(this.query);\n    }\n\n    rest = rest.slice(0, qm);\n  } else if (parseQueryString) {\n    // no query string, but parseQueryString still requested\n    this.search = '';\n    this.query = {};\n  }\n\n  if (rest) this.pathname = rest;\n\n  if (slashedProtocol[lowerProto] && this.hostname && !this.pathname) {\n    this.pathname = '/';\n  } //to support http.request\n\n\n  if (this.pathname || this.search) {\n    var p = this.pathname || '';\n    var s = this.search || '';\n    this.path = p + s;\n  } // finally, reconstruct the href based on what has been validated.\n\n\n  this.href = this.format();\n  return this;\n}; // format a parsed object into a url string\n\n\nfunction urlFormat(obj) {\n  // ensure it's an object, and not a string url.\n  // If it's an obj, this is a no-op.\n  // this way, you can call url_format() on strings\n  // to clean up potentially wonky urls.\n  if (util.isString(obj)) obj = urlParse(obj);\n  if (!(obj instanceof Url)) return Url.prototype.format.call(obj);\n  return obj.format();\n}\n\nUrl.prototype.format = function () {\n  var auth = this.auth || '';\n\n  if (auth) {\n    auth = encodeURIComponent(auth);\n    auth = auth.replace(/%3A/i, ':');\n    auth += '@';\n  }\n\n  var protocol = this.protocol || '',\n      pathname = this.pathname || '',\n      hash = this.hash || '',\n      host = false,\n      query = '';\n\n  if (this.host) {\n    host = auth + this.host;\n  } else if (this.hostname) {\n    host = auth + (this.hostname.indexOf(':') === -1 ? this.hostname : '[' + this.hostname + ']');\n\n    if (this.port) {\n      host += ':' + this.port;\n    }\n  }\n\n  if (this.query && util.isObject(this.query) && Object.keys(this.query).length) {\n    query = querystring.stringify(this.query);\n  }\n\n  var search = this.search || query && '?' + query || '';\n  if (protocol && protocol.substr(-1) !== ':') protocol += ':'; // only the slashedProtocols get the //.  Not mailto:, xmpp:, etc.\n  // unless they had them to begin with.\n\n  if (this.slashes || (!protocol || slashedProtocol[protocol]) && host !== false) {\n    host = '//' + (host || '');\n    if (pathname && pathname.charAt(0) !== '/') pathname = '/' + pathname;\n  } else if (!host) {\n    host = '';\n  }\n\n  if (hash && hash.charAt(0) !== '#') hash = '#' + hash;\n  if (search && search.charAt(0) !== '?') search = '?' + search;\n  pathname = pathname.replace(/[?#]/g, function (match) {\n    return encodeURIComponent(match);\n  });\n  search = search.replace('#', '%23');\n  return protocol + host + pathname + search + hash;\n};\n\nfunction urlResolve(source, relative) {\n  return urlParse(source, false, true).resolve(relative);\n}\n\nUrl.prototype.resolve = function (relative) {\n  return this.resolveObject(urlParse(relative, false, true)).format();\n};\n\nfunction urlResolveObject(source, relative) {\n  if (!source) return relative;\n  return urlParse(source, false, true).resolveObject(relative);\n}\n\nUrl.prototype.resolveObject = function (relative) {\n  if (util.isString(relative)) {\n    var rel = new Url();\n    rel.parse(relative, false, true);\n    relative = rel;\n  }\n\n  var result = new Url();\n  var tkeys = Object.keys(this);\n\n  for (var tk = 0; tk < tkeys.length; tk++) {\n    var tkey = tkeys[tk];\n    result[tkey] = this[tkey];\n  } // hash is always overridden, no matter what.\n  // even href=\"\" will remove it.\n\n\n  result.hash = relative.hash; // if the relative url is empty, then there's nothing left to do here.\n\n  if (relative.href === '') {\n    result.href = result.format();\n    return result;\n  } // hrefs like //foo/bar always cut to the protocol.\n\n\n  if (relative.slashes && !relative.protocol) {\n    // take everything except the protocol from relative\n    var rkeys = Object.keys(relative);\n\n    for (var rk = 0; rk < rkeys.length; rk++) {\n      var rkey = rkeys[rk];\n      if (rkey !== 'protocol') result[rkey] = relative[rkey];\n    } //urlParse appends trailing / to urls like http://www.example.com\n\n\n    if (slashedProtocol[result.protocol] && result.hostname && !result.pathname) {\n      result.path = result.pathname = '/';\n    }\n\n    result.href = result.format();\n    return result;\n  }\n\n  if (relative.protocol && relative.protocol !== result.protocol) {\n    // if it's a known url protocol, then changing\n    // the protocol does weird things\n    // first, if it's not file:, then we MUST have a host,\n    // and if there was a path\n    // to begin with, then we MUST have a path.\n    // if it is file:, then the host is dropped,\n    // because that's known to be hostless.\n    // anything else is assumed to be absolute.\n    if (!slashedProtocol[relative.protocol]) {\n      var keys = Object.keys(relative);\n\n      for (var v = 0; v < keys.length; v++) {\n        var k = keys[v];\n        result[k] = relative[k];\n      }\n\n      result.href = result.format();\n      return result;\n    }\n\n    result.protocol = relative.protocol;\n\n    if (!relative.host && !hostlessProtocol[relative.protocol]) {\n      var relPath = (relative.pathname || '').split('/');\n\n      while (relPath.length && !(relative.host = relPath.shift())) {\n        ;\n      }\n\n      if (!relative.host) relative.host = '';\n      if (!relative.hostname) relative.hostname = '';\n      if (relPath[0] !== '') relPath.unshift('');\n      if (relPath.length < 2) relPath.unshift('');\n      result.pathname = relPath.join('/');\n    } else {\n      result.pathname = relative.pathname;\n    }\n\n    result.search = relative.search;\n    result.query = relative.query;\n    result.host = relative.host || '';\n    result.auth = relative.auth;\n    result.hostname = relative.hostname || relative.host;\n    result.port = relative.port; // to support http.request\n\n    if (result.pathname || result.search) {\n      var p = result.pathname || '';\n      var s = result.search || '';\n      result.path = p + s;\n    }\n\n    result.slashes = result.slashes || relative.slashes;\n    result.href = result.format();\n    return result;\n  }\n\n  var isSourceAbs = result.pathname && result.pathname.charAt(0) === '/',\n      isRelAbs = relative.host || relative.pathname && relative.pathname.charAt(0) === '/',\n      mustEndAbs = isRelAbs || isSourceAbs || result.host && relative.pathname,\n      removeAllDots = mustEndAbs,\n      srcPath = result.pathname && result.pathname.split('/') || [],\n      relPath = relative.pathname && relative.pathname.split('/') || [],\n      psychotic = result.protocol && !slashedProtocol[result.protocol]; // if the url is a non-slashed url, then relative\n  // links like ../.. should be able\n  // to crawl up to the hostname, as well.  This is strange.\n  // result.protocol has already been set by now.\n  // Later on, put the first path part into the host field.\n\n  if (psychotic) {\n    result.hostname = '';\n    result.port = null;\n\n    if (result.host) {\n      if (srcPath[0] === '') srcPath[0] = result.host;else srcPath.unshift(result.host);\n    }\n\n    result.host = '';\n\n    if (relative.protocol) {\n      relative.hostname = null;\n      relative.port = null;\n\n      if (relative.host) {\n        if (relPath[0] === '') relPath[0] = relative.host;else relPath.unshift(relative.host);\n      }\n\n      relative.host = null;\n    }\n\n    mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');\n  }\n\n  if (isRelAbs) {\n    // it's absolute.\n    result.host = relative.host || relative.host === '' ? relative.host : result.host;\n    result.hostname = relative.hostname || relative.hostname === '' ? relative.hostname : result.hostname;\n    result.search = relative.search;\n    result.query = relative.query;\n    srcPath = relPath; // fall through to the dot-handling below.\n  } else if (relPath.length) {\n    // it's relative\n    // throw away the existing file, and take the new path instead.\n    if (!srcPath) srcPath = [];\n    srcPath.pop();\n    srcPath = srcPath.concat(relPath);\n    result.search = relative.search;\n    result.query = relative.query;\n  } else if (!util.isNullOrUndefined(relative.search)) {\n    // just pull out the search.\n    // like href='?foo'.\n    // Put this after the other two cases because it simplifies the booleans\n    if (psychotic) {\n      result.hostname = result.host = srcPath.shift(); //occationaly the auth can get stuck only in host\n      //this especially happens in cases like\n      //url.resolveObject('mailto:local1@domain1', 'local2@domain2')\n\n      var authInHost = result.host && result.host.indexOf('@') > 0 ? result.host.split('@') : false;\n\n      if (authInHost) {\n        result.auth = authInHost.shift();\n        result.host = result.hostname = authInHost.shift();\n      }\n    }\n\n    result.search = relative.search;\n    result.query = relative.query; //to support http.request\n\n    if (!util.isNull(result.pathname) || !util.isNull(result.search)) {\n      result.path = (result.pathname ? result.pathname : '') + (result.search ? result.search : '');\n    }\n\n    result.href = result.format();\n    return result;\n  }\n\n  if (!srcPath.length) {\n    // no path at all.  easy.\n    // we've already handled the other stuff above.\n    result.pathname = null; //to support http.request\n\n    if (result.search) {\n      result.path = '/' + result.search;\n    } else {\n      result.path = null;\n    }\n\n    result.href = result.format();\n    return result;\n  } // if a url ENDs in . or .., then it must get a trailing slash.\n  // however, if it ends in anything else non-slashy,\n  // then it must NOT get a trailing slash.\n\n\n  var last = srcPath.slice(-1)[0];\n  var hasTrailingSlash = (result.host || relative.host || srcPath.length > 1) && (last === '.' || last === '..') || last === ''; // strip single dots, resolve double dots to parent dir\n  // if the path tries to go above the root, `up` ends up > 0\n\n  var up = 0;\n\n  for (var i = srcPath.length; i >= 0; i--) {\n    last = srcPath[i];\n\n    if (last === '.') {\n      srcPath.splice(i, 1);\n    } else if (last === '..') {\n      srcPath.splice(i, 1);\n      up++;\n    } else if (up) {\n      srcPath.splice(i, 1);\n      up--;\n    }\n  } // if the path is allowed to go above the root, restore leading ..s\n\n\n  if (!mustEndAbs && !removeAllDots) {\n    for (; up--; up) {\n      srcPath.unshift('..');\n    }\n  }\n\n  if (mustEndAbs && srcPath[0] !== '' && (!srcPath[0] || srcPath[0].charAt(0) !== '/')) {\n    srcPath.unshift('');\n  }\n\n  if (hasTrailingSlash && srcPath.join('/').substr(-1) !== '/') {\n    srcPath.push('');\n  }\n\n  var isAbsolute = srcPath[0] === '' || srcPath[0] && srcPath[0].charAt(0) === '/'; // put the host back\n\n  if (psychotic) {\n    result.hostname = result.host = isAbsolute ? '' : srcPath.length ? srcPath.shift() : ''; //occationaly the auth can get stuck only in host\n    //this especially happens in cases like\n    //url.resolveObject('mailto:local1@domain1', 'local2@domain2')\n\n    var authInHost = result.host && result.host.indexOf('@') > 0 ? result.host.split('@') : false;\n\n    if (authInHost) {\n      result.auth = authInHost.shift();\n      result.host = result.hostname = authInHost.shift();\n    }\n  }\n\n  mustEndAbs = mustEndAbs || result.host && srcPath.length;\n\n  if (mustEndAbs && !isAbsolute) {\n    srcPath.unshift('');\n  }\n\n  if (!srcPath.length) {\n    result.pathname = null;\n    result.path = null;\n  } else {\n    result.pathname = srcPath.join('/');\n  } //to support request.http\n\n\n  if (!util.isNull(result.pathname) || !util.isNull(result.search)) {\n    result.path = (result.pathname ? result.pathname : '') + (result.search ? result.search : '');\n  }\n\n  result.auth = relative.auth || result.auth;\n  result.slashes = result.slashes || relative.slashes;\n  result.href = result.format();\n  return result;\n};\n\nUrl.prototype.parseHost = function () {\n  var host = this.host;\n  var port = portPattern.exec(host);\n\n  if (port) {\n    port = port[0];\n\n    if (port !== ':') {\n      this.port = port.substr(1);\n    }\n\n    host = host.substr(0, host.length - port.length);\n  }\n\n  if (host) this.hostname = host;\n};","/*! https://mths.be/punycode v1.4.1 by @mathias */\n;\n\n(function (root) {\n  /** Detect free variables */\n  var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n  var freeModule = typeof module == 'object' && module && !module.nodeType && module;\n  var freeGlobal = typeof global == 'object' && global;\n\n  if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal || freeGlobal.self === freeGlobal) {\n    root = freeGlobal;\n  }\n  /**\n   * The `punycode` object.\n   * @name punycode\n   * @type Object\n   */\n\n\n  var punycode,\n\n  /** Highest positive signed 32-bit float value */\n  maxInt = 2147483647,\n      // aka. 0x7FFFFFFF or 2^31-1\n\n  /** Bootstring parameters */\n  base = 36,\n      tMin = 1,\n      tMax = 26,\n      skew = 38,\n      damp = 700,\n      initialBias = 72,\n      initialN = 128,\n      // 0x80\n  delimiter = '-',\n      // '\\x2D'\n\n  /** Regular expressions */\n  regexPunycode = /^xn--/,\n      regexNonASCII = /[^\\x20-\\x7E]/,\n      // unprintable ASCII chars + non-ASCII chars\n  regexSeparators = /[\\x2E\\u3002\\uFF0E\\uFF61]/g,\n      // RFC 3490 separators\n\n  /** Error messages */\n  errors = {\n    'overflow': 'Overflow: input needs wider integers to process',\n    'not-basic': 'Illegal input >= 0x80 (not a basic code point)',\n    'invalid-input': 'Invalid input'\n  },\n\n  /** Convenience shortcuts */\n  baseMinusTMin = base - tMin,\n      floor = Math.floor,\n      stringFromCharCode = String.fromCharCode,\n\n  /** Temporary variable */\n  key;\n  /*--------------------------------------------------------------------------*/\n\n  /**\n   * A generic error utility function.\n   * @private\n   * @param {String} type The error type.\n   * @returns {Error} Throws a `RangeError` with the applicable error message.\n   */\n\n  function error(type) {\n    throw new RangeError(errors[type]);\n  }\n  /**\n   * A generic `Array#map` utility function.\n   * @private\n   * @param {Array} array The array to iterate over.\n   * @param {Function} callback The function that gets called for every array\n   * item.\n   * @returns {Array} A new array of values returned by the callback function.\n   */\n\n\n  function map(array, fn) {\n    var length = array.length;\n    var result = [];\n\n    while (length--) {\n      result[length] = fn(array[length]);\n    }\n\n    return result;\n  }\n  /**\n   * A simple `Array#map`-like wrapper to work with domain name strings or email\n   * addresses.\n   * @private\n   * @param {String} domain The domain name or email address.\n   * @param {Function} callback The function that gets called for every\n   * character.\n   * @returns {Array} A new string of characters returned by the callback\n   * function.\n   */\n\n\n  function mapDomain(string, fn) {\n    var parts = string.split('@');\n    var result = '';\n\n    if (parts.length > 1) {\n      // In email addresses, only the domain name should be punycoded. Leave\n      // the local part (i.e. everything up to `@`) intact.\n      result = parts[0] + '@';\n      string = parts[1];\n    } // Avoid `split(regex)` for IE8 compatibility. See #17.\n\n\n    string = string.replace(regexSeparators, '\\x2E');\n    var labels = string.split('.');\n    var encoded = map(labels, fn).join('.');\n    return result + encoded;\n  }\n  /**\n   * Creates an array containing the numeric code points of each Unicode\n   * character in the string. While JavaScript uses UCS-2 internally,\n   * this function will convert a pair of surrogate halves (each of which\n   * UCS-2 exposes as separate characters) into a single code point,\n   * matching UTF-16.\n   * @see `punycode.ucs2.encode`\n   * @see <https://mathiasbynens.be/notes/javascript-encoding>\n   * @memberOf punycode.ucs2\n   * @name decode\n   * @param {String} string The Unicode input string (UCS-2).\n   * @returns {Array} The new array of code points.\n   */\n\n\n  function ucs2decode(string) {\n    var output = [],\n        counter = 0,\n        length = string.length,\n        value,\n        extra;\n\n    while (counter < length) {\n      value = string.charCodeAt(counter++);\n\n      if (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n        // high surrogate, and there is a next character\n        extra = string.charCodeAt(counter++);\n\n        if ((extra & 0xFC00) == 0xDC00) {\n          // low surrogate\n          output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n        } else {\n          // unmatched surrogate; only append this code unit, in case the next\n          // code unit is the high surrogate of a surrogate pair\n          output.push(value);\n          counter--;\n        }\n      } else {\n        output.push(value);\n      }\n    }\n\n    return output;\n  }\n  /**\n   * Creates a string based on an array of numeric code points.\n   * @see `punycode.ucs2.decode`\n   * @memberOf punycode.ucs2\n   * @name encode\n   * @param {Array} codePoints The array of numeric code points.\n   * @returns {String} The new Unicode string (UCS-2).\n   */\n\n\n  function ucs2encode(array) {\n    return map(array, function (value) {\n      var output = '';\n\n      if (value > 0xFFFF) {\n        value -= 0x10000;\n        output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);\n        value = 0xDC00 | value & 0x3FF;\n      }\n\n      output += stringFromCharCode(value);\n      return output;\n    }).join('');\n  }\n  /**\n   * Converts a basic code point into a digit/integer.\n   * @see `digitToBasic()`\n   * @private\n   * @param {Number} codePoint The basic numeric code point value.\n   * @returns {Number} The numeric value of a basic code point (for use in\n   * representing integers) in the range `0` to `base - 1`, or `base` if\n   * the code point does not represent a value.\n   */\n\n\n  function basicToDigit(codePoint) {\n    if (codePoint - 48 < 10) {\n      return codePoint - 22;\n    }\n\n    if (codePoint - 65 < 26) {\n      return codePoint - 65;\n    }\n\n    if (codePoint - 97 < 26) {\n      return codePoint - 97;\n    }\n\n    return base;\n  }\n  /**\n   * Converts a digit/integer into a basic code point.\n   * @see `basicToDigit()`\n   * @private\n   * @param {Number} digit The numeric value of a basic code point.\n   * @returns {Number} The basic code point whose value (when used for\n   * representing integers) is `digit`, which needs to be in the range\n   * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is\n   * used; else, the lowercase form is used. The behavior is undefined\n   * if `flag` is non-zero and `digit` has no uppercase form.\n   */\n\n\n  function digitToBasic(digit, flag) {\n    //  0..25 map to ASCII a..z or A..Z\n    // 26..35 map to ASCII 0..9\n    return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);\n  }\n  /**\n   * Bias adaptation function as per section 3.4 of RFC 3492.\n   * https://tools.ietf.org/html/rfc3492#section-3.4\n   * @private\n   */\n\n\n  function adapt(delta, numPoints, firstTime) {\n    var k = 0;\n    delta = firstTime ? floor(delta / damp) : delta >> 1;\n    delta += floor(delta / numPoints);\n\n    for (;\n    /* no initialization */\n    delta > baseMinusTMin * tMax >> 1; k += base) {\n      delta = floor(delta / baseMinusTMin);\n    }\n\n    return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));\n  }\n  /**\n   * Converts a Punycode string of ASCII-only symbols to a string of Unicode\n   * symbols.\n   * @memberOf punycode\n   * @param {String} input The Punycode string of ASCII-only symbols.\n   * @returns {String} The resulting string of Unicode symbols.\n   */\n\n\n  function decode(input) {\n    // Don't use UCS-2\n    var output = [],\n        inputLength = input.length,\n        out,\n        i = 0,\n        n = initialN,\n        bias = initialBias,\n        basic,\n        j,\n        index,\n        oldi,\n        w,\n        k,\n        digit,\n        t,\n\n    /** Cached calculation results */\n    baseMinusT; // Handle the basic code points: let `basic` be the number of input code\n    // points before the last delimiter, or `0` if there is none, then copy\n    // the first basic code points to the output.\n\n    basic = input.lastIndexOf(delimiter);\n\n    if (basic < 0) {\n      basic = 0;\n    }\n\n    for (j = 0; j < basic; ++j) {\n      // if it's not a basic code point\n      if (input.charCodeAt(j) >= 0x80) {\n        error('not-basic');\n      }\n\n      output.push(input.charCodeAt(j));\n    } // Main decoding loop: start just after the last delimiter if any basic code\n    // points were copied; start at the beginning otherwise.\n\n\n    for (index = basic > 0 ? basic + 1 : 0; index < inputLength;)\n    /* no final expression */\n    {\n      // `index` is the index of the next character to be consumed.\n      // Decode a generalized variable-length integer into `delta`,\n      // which gets added to `i`. The overflow checking is easier\n      // if we increase `i` as we go, then subtract off its starting\n      // value at the end to obtain `delta`.\n      for (oldi = i, w = 1, k = base;;\n      /* no condition */\n      k += base) {\n        if (index >= inputLength) {\n          error('invalid-input');\n        }\n\n        digit = basicToDigit(input.charCodeAt(index++));\n\n        if (digit >= base || digit > floor((maxInt - i) / w)) {\n          error('overflow');\n        }\n\n        i += digit * w;\n        t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;\n\n        if (digit < t) {\n          break;\n        }\n\n        baseMinusT = base - t;\n\n        if (w > floor(maxInt / baseMinusT)) {\n          error('overflow');\n        }\n\n        w *= baseMinusT;\n      }\n\n      out = output.length + 1;\n      bias = adapt(i - oldi, out, oldi == 0); // `i` was supposed to wrap around from `out` to `0`,\n      // incrementing `n` each time, so we'll fix that now:\n\n      if (floor(i / out) > maxInt - n) {\n        error('overflow');\n      }\n\n      n += floor(i / out);\n      i %= out; // Insert `n` at position `i` of the output\n\n      output.splice(i++, 0, n);\n    }\n\n    return ucs2encode(output);\n  }\n  /**\n   * Converts a string of Unicode symbols (e.g. a domain name label) to a\n   * Punycode string of ASCII-only symbols.\n   * @memberOf punycode\n   * @param {String} input The string of Unicode symbols.\n   * @returns {String} The resulting Punycode string of ASCII-only symbols.\n   */\n\n\n  function encode(input) {\n    var n,\n        delta,\n        handledCPCount,\n        basicLength,\n        bias,\n        j,\n        m,\n        q,\n        k,\n        t,\n        currentValue,\n        output = [],\n\n    /** `inputLength` will hold the number of code points in `input`. */\n    inputLength,\n\n    /** Cached calculation results */\n    handledCPCountPlusOne,\n        baseMinusT,\n        qMinusT; // Convert the input in UCS-2 to Unicode\n\n    input = ucs2decode(input); // Cache the length\n\n    inputLength = input.length; // Initialize the state\n\n    n = initialN;\n    delta = 0;\n    bias = initialBias; // Handle the basic code points\n\n    for (j = 0; j < inputLength; ++j) {\n      currentValue = input[j];\n\n      if (currentValue < 0x80) {\n        output.push(stringFromCharCode(currentValue));\n      }\n    }\n\n    handledCPCount = basicLength = output.length; // `handledCPCount` is the number of code points that have been handled;\n    // `basicLength` is the number of basic code points.\n    // Finish the basic string - if it is not empty - with a delimiter\n\n    if (basicLength) {\n      output.push(delimiter);\n    } // Main encoding loop:\n\n\n    while (handledCPCount < inputLength) {\n      // All non-basic code points < n have been handled already. Find the next\n      // larger one:\n      for (m = maxInt, j = 0; j < inputLength; ++j) {\n        currentValue = input[j];\n\n        if (currentValue >= n && currentValue < m) {\n          m = currentValue;\n        }\n      } // Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,\n      // but guard against overflow\n\n\n      handledCPCountPlusOne = handledCPCount + 1;\n\n      if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {\n        error('overflow');\n      }\n\n      delta += (m - n) * handledCPCountPlusOne;\n      n = m;\n\n      for (j = 0; j < inputLength; ++j) {\n        currentValue = input[j];\n\n        if (currentValue < n && ++delta > maxInt) {\n          error('overflow');\n        }\n\n        if (currentValue == n) {\n          // Represent delta as a generalized variable-length integer\n          for (q = delta, k = base;;\n          /* no condition */\n          k += base) {\n            t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;\n\n            if (q < t) {\n              break;\n            }\n\n            qMinusT = q - t;\n            baseMinusT = base - t;\n            output.push(stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0)));\n            q = floor(qMinusT / baseMinusT);\n          }\n\n          output.push(stringFromCharCode(digitToBasic(q, 0)));\n          bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);\n          delta = 0;\n          ++handledCPCount;\n        }\n      }\n\n      ++delta;\n      ++n;\n    }\n\n    return output.join('');\n  }\n  /**\n   * Converts a Punycode string representing a domain name or an email address\n   * to Unicode. Only the Punycoded parts of the input will be converted, i.e.\n   * it doesn't matter if you call it on a string that has already been\n   * converted to Unicode.\n   * @memberOf punycode\n   * @param {String} input The Punycoded domain name or email address to\n   * convert to Unicode.\n   * @returns {String} The Unicode representation of the given Punycode\n   * string.\n   */\n\n\n  function toUnicode(input) {\n    return mapDomain(input, function (string) {\n      return regexPunycode.test(string) ? decode(string.slice(4).toLowerCase()) : string;\n    });\n  }\n  /**\n   * Converts a Unicode string representing a domain name or an email address to\n   * Punycode. Only the non-ASCII parts of the domain name will be converted,\n   * i.e. it doesn't matter if you call it with a domain that's already in\n   * ASCII.\n   * @memberOf punycode\n   * @param {String} input The domain name or email address to convert, as a\n   * Unicode string.\n   * @returns {String} The Punycode representation of the given domain name or\n   * email address.\n   */\n\n\n  function toASCII(input) {\n    return mapDomain(input, function (string) {\n      return regexNonASCII.test(string) ? 'xn--' + encode(string) : string;\n    });\n  }\n  /*--------------------------------------------------------------------------*/\n\n  /** Define the public API */\n\n\n  punycode = {\n    /**\n     * A string representing the current Punycode.js version number.\n     * @memberOf punycode\n     * @type String\n     */\n    'version': '1.4.1',\n\n    /**\n     * An object of methods to convert from JavaScript's internal character\n     * representation (UCS-2) to Unicode code points, and back.\n     * @see <https://mathiasbynens.be/notes/javascript-encoding>\n     * @memberOf punycode\n     * @type Object\n     */\n    'ucs2': {\n      'decode': ucs2decode,\n      'encode': ucs2encode\n    },\n    'decode': decode,\n    'encode': encode,\n    'toASCII': toASCII,\n    'toUnicode': toUnicode\n  };\n  /** Expose `punycode` */\n  // Some AMD build optimizers, like r.js, check for specific condition patterns\n  // like the following:\n\n  if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {\n    define('punycode', function () {\n      return punycode;\n    });\n  } else if (freeExports && freeModule) {\n    if (module.exports == freeExports) {\n      // in Node.js, io.js, or RingoJS v0.8.0+\n      freeModule.exports = punycode;\n    } else {\n      // in Narwhal or RingoJS v0.7.0-\n      for (key in punycode) {\n        punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);\n      }\n    }\n  } else {\n    // in Rhino or a web browser\n    root.punycode = punycode;\n  }\n})(this);","'use strict';\n\nmodule.exports = {\n  isString: function isString(arg) {\n    return typeof arg === 'string';\n  },\n  isObject: function isObject(arg) {\n    return typeof arg === 'object' && arg !== null;\n  },\n  isNull: function isNull(arg) {\n    return arg === null;\n  },\n  isNullOrUndefined: function isNullOrUndefined(arg) {\n    return arg == null;\n  }\n};","'use strict';\n\nvar _require = require('url'),\n    parse = _require.parse;\n\nvar aHrefSanitizationWhitelist = /^\\s*(https?|ftp|mailto|tel|file):/;\nvar imgSrcSanitizationWhitelist = /^\\s*((https?|ftp|file|blob):|data:image\\/)/;\n\nmodule.exports = function sanitizeUri(uri, isImage) {\n  var regex = isImage ? imgSrcSanitizationWhitelist : aHrefSanitizationWhitelist;\n  var normalizedVal = parse(uri).href;\n\n  if (normalizedVal !== '' && !normalizedVal.match(regex)) {\n    return 'unsafe:' + normalizedVal;\n  }\n\n  return uri;\n};","/*!\n * escape-html\n * Copyright(c) 2012-2013 TJ Holowaychuk\n * Copyright(c) 2015 Andreas Lubbe\n * Copyright(c) 2015 Tiancheng \"Timothy\" Gu\n * MIT Licensed\n */\n'use strict';\n/**\n * Module variables.\n * @private\n */\n\nvar matchHtmlRegExp = /[\"'&<>]/;\n/**\n * Module exports.\n * @public\n */\n\nmodule.exports = escapeHtml;\n/**\n * Escape special characters in the given string of html.\n *\n * @param  {string} string The string to escape for inserting into HTML\n * @return {string}\n * @public\n */\n\nfunction escapeHtml(string) {\n  var str = '' + string;\n  var match = matchHtmlRegExp.exec(str);\n\n  if (!match) {\n    return str;\n  }\n\n  var escape;\n  var html = '';\n  var index = 0;\n  var lastIndex = 0;\n\n  for (index = match.index; index < str.length; index++) {\n    switch (str.charCodeAt(index)) {\n      case 34:\n        // \"\n        escape = '&quot;';\n        break;\n\n      case 38:\n        // &\n        escape = '&amp;';\n        break;\n\n      case 39:\n        // '\n        escape = '&#39;';\n        break;\n\n      case 60:\n        // <\n        escape = '&lt;';\n        break;\n\n      case 62:\n        // >\n        escape = '&gt;';\n        break;\n\n      default:\n        continue;\n    }\n\n    if (lastIndex !== index) {\n      html += str.substring(lastIndex, index);\n    }\n\n    lastIndex = index + 1;\n    html += escape;\n  }\n\n  return lastIndex !== index ? html + str.substring(lastIndex, index) : html;\n}","'use strict';\n\nvar escapeHTML = require('escape-html');\n\nvar sanitizeUri = require('./uri');\n\nfunction toMap(str, lowercaseKeys) {\n  var obj = {};\n  var items = str.split(',');\n  var i = void 0;\n\n  for (i = 0; i < items.length; i += 1) {\n    obj[lowercaseKeys ? items[i].toLowerCase() : items[i]] = true;\n  }\n\n  return obj;\n} // Good source of info about elements and attributes\n// http://dev.w3.org/html5/spec/Overview.html#semantics\n// http://simon.html5.org/html-elements\n// Safe Void Elements - HTML5\n// http://dev.w3.org/html5/spec/Overview.html#void-elements\n\n\nvar voidElements = toMap('area,br,col,hr,img,wbr'); // Elements that you can, intentionally, leave open (and which close themselves)\n// http://dev.w3.org/html5/spec/Overview.html#optional-tags\n\nvar optionalEndTagBlockElements = toMap('colgroup,dd,dt,li,p,tbody,td,tfoot,th,thead,tr');\nvar optionalEndTagInlineElements = toMap('rp,rt');\nvar optionalEndTagElements = Object.assign({}, optionalEndTagInlineElements, optionalEndTagBlockElements); // Safe Block Elements - HTML5\n\nvar blockElements = Object.assign({}, optionalEndTagBlockElements, toMap('address,article,' + 'aside,blockquote,caption,center,del,dir,div,dl,figure,figcaption,footer,h1,h2,h3,h4,h5,' + 'h6,header,hgroup,hr,ins,map,menu,nav,ol,pre,section,table,ul,tbody,thead')); // Inline Elements - HTML5\n\nvar inlineElements = Object.assign({}, optionalEndTagInlineElements, toMap('a,abbr,acronym,b,' + 'bdi,bdo,big,br,cite,code,del,dfn,em,font,i,img,ins,kbd,label,map,mark,q,ruby,rp,rt,s,' + 'samp,small,span,strike,strong,sub,sup,time,tt,u,var')); // Blocked Elements (will be stripped)\n\nvar blockedElements = toMap('script,style');\nvar validElements = Object.assign({}, voidElements, blockElements, inlineElements, optionalEndTagElements); // Attributes that have href and hence need to be sanitized\n\nvar uriAttrs = toMap('background,cite,href,longdesc,src,xlink:href');\nvar htmlAttrs = toMap('abbr,align,alt,axis,bgcolor,border,cellpadding,cellspacing,class,clear,' + 'color,cols,colspan,compact,coords,dir,face,headers,height,hreflang,hspace,' + 'ismap,lang,language,nohref,nowrap,rel,rev,rows,rowspan,rules,' + 'scope,scrolling,shape,size,span,start,summary,tabindex,target,title,type,' + 'valign,value,vspace,width'); // SVG attributes (without \"id\" and \"name\" attributes)\n// https://wiki.whatwg.org/wiki/Sanitization_rules#svg_Attributes\n\nvar svgAttrs = toMap('accent-height,accumulate,additive,alphabetic,arabic-form,ascent,' + 'baseProfile,bbox,begin,by,calcMode,cap-height,class,color,color-rendering,content,' + 'cx,cy,d,dx,dy,descent,display,dur,end,fill,fill-rule,font-family,font-size,font-stretch,' + 'font-style,font-variant,font-weight,from,fx,fy,g1,g2,glyph-name,gradientUnits,hanging,' + 'height,horiz-adv-x,horiz-origin-x,ideographic,k,keyPoints,keySplines,keyTimes,lang,' + 'marker-end,marker-mid,marker-start,markerHeight,markerUnits,markerWidth,mathematical,' + 'max,min,offset,opacity,orient,origin,overline-position,overline-thickness,panose-1,' + 'path,pathLength,points,preserveAspectRatio,r,refX,refY,repeatCount,repeatDur,' + 'requiredExtensions,requiredFeatures,restart,rotate,rx,ry,slope,stemh,stemv,stop-color,' + 'stop-opacity,strikethrough-position,strikethrough-thickness,stroke,stroke-dasharray,' + 'stroke-dashoffset,stroke-linecap,stroke-linejoin,stroke-miterlimit,stroke-opacity,' + 'stroke-width,systemLanguage,target,text-anchor,to,transform,type,u1,u2,underline-position,' + 'underline-thickness,unicode,unicode-range,units-per-em,values,version,viewBox,visibility,' + 'width,widths,x,x-height,x1,x2,xlink:actuate,xlink:arcrole,xlink:role,xlink:show,xlink:title,' + 'xlink:type,xml:base,xml:lang,xml:space,xmlns,xmlns:xlink,y,y1,y2,zoomAndPan', true);\nvar validAttrs = Object.assign({}, uriAttrs, svgAttrs, htmlAttrs); // Create an inert document that contains the dirty HTML that needs sanitizing\n// Depending upon browser support we use one of three strategies for doing this.\n// Support: Safari 10.x -> XHR strategy\n// Support: Firefox -> DomParser strategy\n\nvar getInertBodyElement\n/* function(html: string): HTMLBodyElement */\n= function getInertBodyElementInner(window, document) {\n  var inertDocument = void 0;\n\n  if (document && document.implementation) {\n    inertDocument = document.implementation.createHTMLDocument('inert');\n  } else {\n    throw new Error('Can\\'t create an inert html document');\n  }\n\n  var inertBodyElement = (inertDocument.documentElement || inertDocument.getDocumentElement()).querySelector('body'); // Check for the Safari 10.1 bug - which allows JS to run inside the SVG G element\n\n  inertBodyElement.innerHTML = '<svg><g onload=\"this.parentNode.remove()\"></g></svg>';\n\n  if (!inertBodyElement.querySelector('svg')) {\n    return getInertBodyElementXHR;\n  } // Check for the Firefox bug - which prevents the inner img JS from being sanitized\n\n\n  inertBodyElement.innerHTML = '<svg><p><style><img src=\"</style><img src=x onerror=alert(1)//\">';\n\n  if (inertBodyElement.querySelector('svg img')) {\n    return getInertBodyElementDOMParser;\n  }\n\n  return getInertBodyElementInertDocument;\n\n  function getInertBodyElementXHR(html) {\n    // We add this dummy element to ensure that the rest of the content is parsed as expected\n    // e.g. leading whitespace is maintained and tags like `<meta>` do not get hoisted to the `<head>` tag.\n    html = '<remove></remove>' + html;\n\n    try {\n      html = encodeURI(html);\n    } catch (e) {\n      return undefined;\n    }\n\n    var xhr = new window.XMLHttpRequest();\n    xhr.responseType = 'document';\n    xhr.open('GET', 'data:text/html;charset=utf-8,' + html, false);\n    xhr.send(null);\n    var body = xhr.response.body;\n    body.firstChild.remove();\n    return body;\n  }\n\n  function getInertBodyElementDOMParser(html) {\n    // We add this dummy element to ensure that the rest of the content is parsed as expected\n    // e.g. leading whitespace is maintained and tags like `<meta>` do not get hoisted to the `<head>` tag.\n    html = '<remove></remove>' + html;\n\n    try {\n      var _parseFromString = new window.DOMParser().parseFromString(html, 'text/html'),\n          body = _parseFromString.body;\n\n      body.firstChild.remove();\n      return body;\n    } catch (e) {\n      return undefined;\n    }\n  }\n\n  function getInertBodyElementInertDocument(html) {\n    inertBodyElement.innerHTML = html; // Support: IE 9-11 only\n    // strip custom-namespaced attributes on IE<=11\n\n    if (document.documentMode) {\n      stripCustomNsAttrs(inertBodyElement);\n    }\n\n    return inertBodyElement;\n  }\n}(window, window.document);\n\nfunction htmlParser(html, handler) {\n  if (html === null || html === undefined) {\n    html = '';\n  } else if (typeof html !== 'string') {\n    html = '' + html;\n  }\n\n  var inertBodyElement = getInertBodyElement(html);\n  if (!inertBodyElement) return; // mXSS protection\n\n  var mXSSAttempts = 5;\n\n  do {\n    if (mXSSAttempts === 0) {\n      throw new Error('Failed to sanitize html because the input is unstable');\n    }\n\n    mXSSAttempts -= 1; // trigger mXSS if it is going to happen by reading and writing the innerHTML\n\n    html = inertBodyElement.innerHTML;\n    inertBodyElement = getInertBodyElement(html);\n  } while (html !== inertBodyElement.innerHTML);\n\n  var node = inertBodyElement.firstChild;\n\n  while (node) {\n    switch (node.nodeType) {\n      case 1:\n        // ELEMENT_NODE\n        handler.start(node.nodeName.toLowerCase(), attrToMap(node.attributes));\n        break;\n\n      case 3:\n        // TEXT NODE\n        handler.chars(node.textContent);\n        break;\n\n      default:\n        break;\n    }\n\n    var nextNode = node.firstChild;\n\n    if (!nextNode) {\n      if (node.nodeType === 1) {\n        handler.end(node.nodeName.toLowerCase());\n      }\n\n      nextNode = getNonDescendant('nextSibling', node);\n\n      if (!nextNode) {\n        while (nextNode == null) {\n          node = getNonDescendant('parentNode', node);\n          if (node === inertBodyElement) break;\n          nextNode = getNonDescendant('nextSibling', node);\n\n          if (node.nodeType === 1) {\n            handler.end(node.nodeName.toLowerCase());\n          }\n        }\n      }\n    }\n\n    node = nextNode;\n  } // eslint-disable-next-line no-cond-assign\n\n\n  while (node = inertBodyElement.firstChild) {\n    inertBodyElement.removeChild(node);\n  }\n}\n\nfunction attrToMap(attrs) {\n  var map = {};\n\n  for (var i = 0, ii = attrs.length; i < ii; i += 1) {\n    var attr = attrs[i];\n    map[attr.name] = attr.value;\n  }\n\n  return map;\n} // create an HTML/XML writer which writes to buffer\n\n\nfunction htmlSanitizeWriter(buf, uriValidator) {\n  var ignoreCurrentElement = false;\n  return {\n    start: function start(tag, attrs) {\n      tag = tag.toLowerCase();\n\n      if (!ignoreCurrentElement && blockedElements[tag]) {\n        ignoreCurrentElement = tag;\n      }\n\n      if (!ignoreCurrentElement && validElements[tag] === true) {\n        buf.push('<');\n        buf.push(tag);\n        Object.keys(attrs).forEach(function (key) {\n          var value = attrs[key];\n          var lkey = key.toLowerCase();\n          var isImage = tag === 'img' && lkey === 'src' || lkey === 'background';\n\n          if (validAttrs[lkey] === true && (uriAttrs[lkey] !== true || uriValidator(value, isImage))) {\n            buf.push(' ');\n            buf.push(key);\n            buf.push('=\"');\n            buf.push(escapeHTML(value));\n            buf.push('\"');\n          }\n        });\n        buf.push('>');\n      }\n    },\n    end: function end(tag) {\n      tag = tag.toLowerCase();\n\n      if (!ignoreCurrentElement && validElements[tag] === true && voidElements[tag] !== true) {\n        buf.push('</');\n        buf.push(tag);\n        buf.push('>');\n      } // eslint-disable-next-line eqeqeq\n\n\n      if (tag == ignoreCurrentElement) {\n        ignoreCurrentElement = false;\n      }\n    },\n    chars: function chars(_chars) {\n      if (!ignoreCurrentElement) {\n        buf.push(escapeHTML(_chars));\n      }\n    }\n  };\n} // When IE9-11 comes across an unknown namespaced attribute e.g. 'xlink:foo' it adds 'xmlns:ns1' attribute to declare\n// ns1 namespace and prefixes the attribute with 'ns1' (e.g. 'ns1:xlink:foo'). This is undesirable since we don't want\n// to allow any of these custom attributes. This method strips them all.\n\n\nfunction stripCustomNsAttrs(node) {\n  while (node) {\n    if (node.nodeType === window.Node.ELEMENT_NODE) {\n      var attrs = node.attributes;\n\n      for (var i = 0, l = attrs.length; i < l; i += 1) {\n        var attrNode = attrs[i];\n        var attrName = attrNode.name.toLowerCase();\n\n        if (attrName === 'xmlns:ns1' || attrName.lastIndexOf('ns1:', 0) === 0) {\n          node.removeAttributeNode(attrNode);\n          i -= 1;\n          l -= 1;\n        }\n      }\n    }\n\n    var nextNode = node.firstChild;\n\n    if (nextNode) {\n      stripCustomNsAttrs(nextNode);\n    }\n\n    node = getNonDescendant('nextSibling', node);\n  }\n}\n\nfunction getNonDescendant(propName, node) {\n  // An element is clobbered if its `propName` property points to one of its descendants\n  var nextNode = node[propName];\n\n  if (nextNode && containsNode(node, nextNode)) {\n    throw new Error('Failed to sanitize html because the element is clobbered: ' + (node.outerHTML || node.outerText));\n  }\n\n  return nextNode;\n}\n\nfunction containsNode(node, nextNode) {\n  // eslint-disable-next-line no-cond-assign\n  do {\n    if (node === nextNode) {\n      return true;\n    }\n  } while (nextNode = nextNode && nextNode.parentNode);\n\n  return false;\n}\n\nmodule.exports = function sanitizeHTML(html) {\n  var buf = [];\n  htmlParser(html, htmlSanitizeWriter(buf, function (uri, isImage) {\n    return !/^unsafe:/.test(sanitizeUri(uri, isImage));\n  }));\n  return buf.join('');\n};","module.exports = require('htmlsanitize');","// 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'use strict'; // If obj.hasOwnProperty has been overridden, then calling\n// obj.hasOwnProperty(prop) will break.\n// See: https://github.com/joyent/node/issues/1707\n\nfunction hasOwnProperty(obj, prop) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n\nmodule.exports = function (qs, sep, eq, options) {\n  sep = sep || '&';\n  eq = eq || '=';\n  var obj = {};\n\n  if (typeof qs !== 'string' || qs.length === 0) {\n    return obj;\n  }\n\n  var regexp = /\\+/g;\n  qs = qs.split(sep);\n  var maxKeys = 1000;\n\n  if (options && typeof options.maxKeys === 'number') {\n    maxKeys = options.maxKeys;\n  }\n\n  var len = qs.length; // maxKeys <= 0 means that we should not limit keys count\n\n  if (maxKeys > 0 && len > maxKeys) {\n    len = maxKeys;\n  }\n\n  for (var i = 0; i < len; ++i) {\n    var x = qs[i].replace(regexp, '%20'),\n        idx = x.indexOf(eq),\n        kstr,\n        vstr,\n        k,\n        v;\n\n    if (idx >= 0) {\n      kstr = x.substr(0, idx);\n      vstr = x.substr(idx + 1);\n    } else {\n      kstr = x;\n      vstr = '';\n    }\n\n    k = decodeURIComponent(kstr);\n    v = decodeURIComponent(vstr);\n\n    if (!hasOwnProperty(obj, k)) {\n      obj[k] = v;\n    } else if (isArray(obj[k])) {\n      obj[k].push(v);\n    } else {\n      obj[k] = [obj[k], v];\n    }\n  }\n\n  return obj;\n};\n\nvar isArray = Array.isArray || function (xs) {\n  return Object.prototype.toString.call(xs) === '[object Array]';\n};","'use strict';\n\nexports.decode = exports.parse = require('./decode');\nexports.encode = exports.stringify = require('./encode');"],"sourceRoot":""}