{"version":3,"file":"chunks/2625.2625.js","mappings":"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","sources":["webpack:///./node_modules/@atlassiansox/origin-tracing/dist/es2019/encoder.js","webpack:///./node_modules/@atlassiansox/origin-tracing/dist/es2019/env.js","webpack:///./node_modules/@atlassiansox/origin-tracing/dist/es2019/origin-tracer.js","webpack:///./node_modules/@atlassiansox/origin-tracing/dist/es2019/util/base64url.js","webpack:///./node_modules/core-js/internals/function-bind.js","webpack:///./node_modules/core-js/modules/es.reflect.construct.js","webpack:///./node_modules/querystring/decode.js","webpack:///./node_modules/querystring/encode.js","webpack:///./node_modules/querystring/index.js","webpack:///./node_modules/url/node_modules/punycode/punycode.js","webpack:///./node_modules/url/url.js","webpack:///./node_modules/url/util.js"],"sourcesContent":["import { base64ToBase64Url, base64UrlToBase64 } from './util/base64url';\nimport { getEnv } from './env';\nconst productShorthands = {\n  confluence: 'c',\n  jira: 'j',\n  stride: 's',\n  bitbucket: 'b',\n  trello: 't'\n};\nexport function encode(originData) {\n  const json = JSON.stringify(toJSONObject(originData));\n  const base64 = getEnv().btoa(json);\n  return base64ToBase64Url(base64);\n}\nexport function decode(encodedOriginString) {\n  const base64 = base64UrlToBase64(encodedOriginString);\n  const json = getEnv().atob(base64);\n  return fromJSONObject(JSON.parse(json));\n}\nexport function toJSONObject({\n  id,\n  product\n}) {\n  return {\n    i: id,\n    p: product && product in productShorthands ? productShorthands[product] : product\n  };\n}\nexport function fromJSONObject(originJSONObject) {\n  const originData = {};\n\n  if (originJSONObject.i) {\n    originData.id = originJSONObject.i;\n  }\n\n  if (originJSONObject.p) {\n    originData.product = expandProductShorthand(originJSONObject.p);\n  }\n\n  return originData;\n}\n\nfunction expandProductShorthand(maybeShorthand) {\n  const products = Object.keys(productShorthands);\n\n  for (let i = 0; i < products.length; i++) {\n    const product = products[i];\n    const shorthand = productShorthands[product];\n\n    if (maybeShorthand === shorthand) {\n      return product;\n    }\n  }\n\n  return maybeShorthand;\n}","export const getEnvGlobals = () => ({\n  atob: // atob/btoa need to be bound because they throw an illegal invocation error when called as a method (obj.atob())\n  typeof atob === 'function' && atob.bind(undefined) || typeof Buffer !== 'undefined' && (encoded => Buffer.from(encoded, 'base64').toString()),\n  btoa: typeof btoa === 'function' && btoa.bind(undefined) || typeof Buffer !== 'undefined' && (str => Buffer.from(str).toString('base64')),\n  URLSearchParams: typeof URLSearchParams === 'function' && URLSearchParams || typeof require === 'function' && require('url').URLSearchParams\n});\nlet env;\nexport const getEnv = () => env || (env = validateEnv(getEnvGlobals()));\n\nconst validateEnv = env => {\n  if (!(env.atob && env.btoa && env.URLSearchParams)) {\n    throw new TypeError(`Origin-Tracing: missing environment APIs. Required: btoa(), atob(), URLSearchParams() (or in Node: Buffer, require('url').URLSearchParams).`);\n  }\n\n  return env;\n};","import uuid from 'uuid/v4';\nimport { encode, decode } from './encoder';\nimport { getEnv } from './env';\nconst packageVersion = \"6.0.7\";\nconst originParamName = 'atlOrigin';\nconst originVersioningAttributes = {\n  originLibrary: `origin-tracing.js@${packageVersion}`\n};\nexport default class OriginTracer {\n  constructor({\n    id = OriginTracer.generateId(),\n    product,\n    dangerouslySkipValidation = false\n  }) {\n    this.id = id;\n    this.product = product;\n\n    if (!dangerouslySkipValidation) {\n      this.validate();\n    }\n  }\n\n  static isValidId(value) {\n    return typeof value === 'string' && /^[-_a-zA-Z0-9]{1,36}$/.test(value);\n  }\n\n  static isValidProduct(value) {\n    return typeof value === 'string' && /^[-_a-zA-Z0-9]{1,20}$/.test(value);\n  }\n\n  static generateId() {\n    const id = uuid(); // Dash positions are fixed so they don't add to uniqueness.\n    // Remove them to save space in the encoded form.\n\n    return id.replace(/-/g, '');\n  }\n\n  static createEmpty() {\n    return new EmptyOriginTracer();\n  }\n\n  static createMalformed() {\n    return new MalformedOriginTracer();\n  }\n\n  static fromUrl(url) {\n    let params = new (getEnv().URLSearchParams)();\n    replaceQuery(url, queryString => {\n      params = new (getEnv().URLSearchParams)(queryString);\n    });\n    return OriginTracer.fromEncoded(params.get(originParamName));\n  }\n\n  static fromEncoded(encoded) {\n    if (!encoded) {\n      return OriginTracer.createEmpty();\n    }\n\n    try {\n      return OriginTracer.decode(encoded);\n    } catch (e) {\n      return OriginTracer.createMalformed();\n    }\n  }\n\n  static removeFromUrl(url) {\n    return replaceQuery(url, queryString => {\n      const params = new (getEnv().URLSearchParams)(queryString);\n      params.delete(originParamName);\n      return params.toString();\n    });\n  }\n\n  static decode(encodedOrigin) {\n    const originData = decode(encodedOrigin);\n    return new OriginTracer(originData);\n  }\n\n  encode() {\n    return encode({\n      id: this.id,\n      product: this.product\n    });\n  }\n\n  addToUrl(url) {\n    return replaceQuery(url, originalQueryString => {\n      const params = new (getEnv().URLSearchParams)(originalQueryString);\n      params.set(originParamName, this.encode());\n      return params.toString();\n    });\n  }\n\n  isEmpty() {\n    return false;\n  }\n\n  isMalformed() {\n    return !this.isEmpty() && !this.isValid();\n  }\n\n  isValid() {\n    return true;\n  }\n\n  toAnalyticsAttributes({\n    transformValue = v => v === null ? undefined : v,\n    hasGeneratedId = false\n  } = {}) {\n    // `originIdGenerated` should be used in analytic events that generated this originId.\n    // Subsequent events should use `originId`.\n    // No two events should have the same value of originIdGenerated.\n    const originIdProp = hasGeneratedId ? 'originIdGenerated' : 'originId';\n    return {\n      [originIdProp]: transformValue(this.id),\n      originProduct: transformValue(this.product),\n      ...originVersioningAttributes\n    };\n  }\n\n  validate() {\n    if (!OriginTracer.isValidId(this.id)) {\n      throw new TypeError('Invalid Origin id');\n    }\n\n    if (!OriginTracer.isValidProduct(this.product)) {\n      throw new TypeError('Missing/invalid Origin product');\n    }\n  }\n\n}\n\nclass EmptyOriginTracer extends OriginTracer {\n  constructor() {\n    super({\n      id: null,\n      product: null,\n      dangerouslySkipValidation: true\n    });\n  }\n\n  isValid() {\n    return false;\n  }\n\n  isEmpty() {\n    return true;\n  }\n\n  toAnalyticsAttributes() {\n    return { ...originVersioningAttributes\n    };\n  }\n\n}\n\nclass MalformedOriginTracer extends OriginTracer {\n  constructor() {\n    super({\n      id: null,\n      product: null,\n      dangerouslySkipValidation: true\n    });\n  }\n\n  isValid() {\n    return false;\n  }\n\n  isEmpty() {\n    return false;\n  }\n\n  toAnalyticsAttributes() {\n    return {\n      originMalformed: true,\n      ...originVersioningAttributes\n    };\n  }\n\n}\n\nfunction replaceQuery(url, replacer) {\n  const urlWithQueryStringRegex = /(^[^?#]*)(?:\\?)?([^#]*?)(#.*|$)$/; // If we get passed window.location, we don't want to call window.location.replace()\n\n  const urlString = String(url);\n  return urlString.replace(urlWithQueryStringRegex, (wholeMatch, beforeQuery, queryString, afterQuery) => {\n    let newQueryString = replacer(queryString);\n\n    if (newQueryString) {\n      newQueryString = `?${newQueryString}`;\n    }\n\n    return `${beforeQuery}${newQueryString}${afterQuery}`;\n  });\n}","/**\n * This file converts between Base64 and Base 64 Encoding with URL and Filename Safe Alphabet,\n * the latter of which has URL-safe characters only (drops =, + and /).\n *\n * Why not use a library? The popular libs use Buffer to be able to\n * encode any data to base64. We don't need this capability, and it causes\n * Webpack to include 30KB of a Buffer polyfill.\n * Webpack's/UglifyJS's Tree Shaking seems to be unable to drop it.\n *\n * See: RFC 4648 section 5 (https://tools.ietf.org/html/rfc4648#section-5)\n */\nexport function base64ToBase64Url(base64) {\n  if (base64 == null) {\n    return '';\n  }\n\n  return String(base64).replace(/\\+/g, '-').replace(/\\//g, '_').replace(/=/g, '');\n}\nexport function base64UrlToBase64(base64url) {\n  if (base64url == null) {\n    return '';\n  }\n\n  const base64 = String(base64url).replace(/-/g, '+').replace(/_/g, '/');\n  const padLength = (4 - base64url.length % 4) % 4;\n  const pad = '==='.slice(0, padLength);\n  return base64 + pad;\n}","'use strict';\nvar global = require('../internals/global');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar aCallable = require('../internals/a-callable');\nvar isObject = require('../internals/is-object');\nvar hasOwn = require('../internals/has-own-property');\nvar arraySlice = require('../internals/array-slice');\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar Function = global.Function;\nvar concat = uncurryThis([].concat);\nvar join = uncurryThis([].join);\nvar factories = {};\n\nvar construct = function (C, argsLength, args) {\n  if (!hasOwn(factories, argsLength)) {\n    for (var list = [], i = 0; i < argsLength; i++) list[i] = 'a[' + i + ']';\n    factories[argsLength] = Function('C,a', 'return new C(' + join(list, ',') + ')');\n  } return factories[argsLength](C, args);\n};\n\n// `Function.prototype.bind` method implementation\n// https://tc39.es/ecma262/#sec-function.prototype.bind\nmodule.exports = NATIVE_BIND ? Function.bind : function bind(that /* , ...args */) {\n  var F = aCallable(this);\n  var Prototype = F.prototype;\n  var partArgs = arraySlice(arguments, 1);\n  var boundFunction = function bound(/* args... */) {\n    var args = concat(partArgs, arraySlice(arguments));\n    return this instanceof boundFunction ? construct(F, args.length, args) : F.apply(that, args);\n  };\n  if (isObject(Prototype)) boundFunction.prototype = Prototype;\n  return boundFunction;\n};\n","var $ = require('../internals/export');\nvar getBuiltIn = require('../internals/get-built-in');\nvar apply = require('../internals/function-apply');\nvar bind = require('../internals/function-bind');\nvar aConstructor = require('../internals/a-constructor');\nvar anObject = require('../internals/an-object');\nvar isObject = require('../internals/is-object');\nvar create = require('../internals/object-create');\nvar fails = require('../internals/fails');\n\nvar nativeConstruct = getBuiltIn('Reflect', 'construct');\nvar ObjectPrototype = Object.prototype;\nvar push = [].push;\n\n// `Reflect.construct` method\n// https://tc39.es/ecma262/#sec-reflect.construct\n// MS Edge supports only 2 arguments and argumentsList argument is optional\n// FF Nightly sets third argument as `new.target`, but does not create `this` from it\nvar NEW_TARGET_BUG = fails(function () {\n  function F() { /* empty */ }\n  return !(nativeConstruct(function () { /* empty */ }, [], F) instanceof F);\n});\n\nvar ARGS_BUG = !fails(function () {\n  nativeConstruct(function () { /* empty */ });\n});\n\nvar FORCED = NEW_TARGET_BUG || ARGS_BUG;\n\n$({ target: 'Reflect', stat: true, forced: FORCED, sham: FORCED }, {\n  construct: function construct(Target, args /* , newTarget */) {\n    aConstructor(Target);\n    anObject(args);\n    var newTarget = arguments.length < 3 ? Target : aConstructor(arguments[2]);\n    if (ARGS_BUG && !NEW_TARGET_BUG) return nativeConstruct(Target, args, newTarget);\n    if (Target == newTarget) {\n      // w/o altered newTarget, optimization for 0-4 arguments\n      switch (args.length) {\n        case 0: return new Target();\n        case 1: return new Target(args[0]);\n        case 2: return new Target(args[0], args[1]);\n        case 3: return new Target(args[0], args[1], args[2]);\n        case 4: return new Target(args[0], args[1], args[2], args[3]);\n      }\n      // w/o altered newTarget, lot of arguments case\n      var $args = [null];\n      apply(push, $args, args);\n      return new (apply(bind, Target, $args))();\n    }\n    // with altered newTarget, not support built-in constructors\n    var proto = newTarget.prototype;\n    var instance = create(isObject(proto) ? proto : ObjectPrototype);\n    var result = apply(Target, instance, args);\n    return isObject(result) ? result : instance;\n  }\n});\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// If obj.hasOwnProperty has been overridden, then calling\n// obj.hasOwnProperty(prop) will break.\n// See: https://github.com/joyent/node/issues/1707\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\n  var maxKeys = 1000;\n  if (options && typeof options.maxKeys === 'number') {\n    maxKeys = options.maxKeys;\n  }\n\n  var len = qs.length;\n  // maxKeys <= 0 means that we should not limit keys count\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, vstr, k, 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 (Array.isArray(obj[k])) {\n      obj[k].push(v);\n    } else {\n      obj[k] = [obj[k], v];\n    }\n  }\n\n  return obj;\n};\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\nvar stringifyPrimitive = function(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  if (obj === null) {\n    obj = undefined;\n  }\n\n  if (typeof obj === 'object') {\n    return Object.keys(obj).map(function(k) {\n      var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;\n      if (Array.isArray(obj[k])) {\n        return obj[k].map(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\n  if (!name) return '';\n  return encodeURIComponent(stringifyPrimitive(name)) + eq +\n         encodeURIComponent(stringifyPrimitive(obj));\n};\n","'use strict';\n\nexports.decode = exports.parse = require('./decode');\nexports.encode = exports.stringify = require('./encode');\n","/*! https://mths.be/punycode v1.3.2 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 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 * http://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.3.2',\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) { // in Node.js or RingoJS v0.8.0+\n\t\t\tfreeModule.exports = punycode;\n\t\t} else { // 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 { // in Rhino or a web browser\n\t\troot.punycode = punycode;\n\t}\n\n}(this));\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\nvar punycode = require('punycode');\nvar util = require('./util');\n\nexports.parse = urlParse;\nexports.resolve = urlResolve;\nexports.resolveObject = urlResolveObject;\nexports.format = urlFormat;\n\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}\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    unsafeProtocol = {\n      'javascript': true,\n      'javascript:': true\n    },\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    querystring = require('querystring');\n\nfunction urlParse(url, parseQueryString, slashesDenoteHost) {\n  if (url && util.isObject(url) && url instanceof Url) return url;\n\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  }\n\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  var queryIndex = url.indexOf('?'),\n      splitter =\n          (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\n  var 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.path = rest;\n      this.href = rest;\n      this.pathname = simplePath[1];\n      if (simplePath[2]) {\n        this.search = simplePath[2];\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      return this;\n    }\n  }\n\n  var proto = protocolPattern.exec(rest);\n  if (proto) {\n    proto = proto[0];\n    var lowerProto = proto.toLowerCase();\n    this.protocol = lowerProto;\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    var 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 (var i = 0; i < hostEndingChars.length; i++) {\n      var hec = rest.indexOf(hostEndingChars[i]);\n      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))\n        hostEnd = hec;\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 = decodeURIComponent(auth);\n    }\n\n    // the host is the remaining to the left of the first non-host char\n    hostEnd = -1;\n    for (var i = 0; i < nonHostChars.length; i++) {\n      var hec = rest.indexOf(nonHostChars[i]);\n      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))\n        hostEnd = hec;\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    this.host = rest.slice(0, hostEnd);\n    rest = rest.slice(hostEnd);\n\n    // pull out port.\n    this.parseHost();\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 (var 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    } 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;\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      if (rest[0] !== '/') {\n        rest = '/' + rest;\n      }\n    }\n  }\n\n  // now rest is set to the post-host stuff.\n  // chop off any delim chars.\n  if (!unsafeProtocol[lowerProto]) {\n\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)\n        continue;\n      var esc = encodeURIComponent(ae);\n      if (esc === ae) {\n        esc = escape(ae);\n      }\n      rest = rest.split(ae).join(esc);\n    }\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    this.query = rest.substr(qm + 1);\n    if (parseQueryString) {\n      this.query = querystring.parse(this.query);\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  if (rest) this.pathname = rest;\n  if (slashedProtocol[lowerProto] &&\n      this.hostname && !this.pathname) {\n    this.pathname = '/';\n  }\n\n  //to support http.request\n  if (this.pathname || this.search) {\n    var p = this.pathname || '';\n    var s = this.search || '';\n    this.path = p + s;\n  }\n\n  // finally, reconstruct the href based on what has been validated.\n  this.href = this.format();\n  return this;\n};\n\n// format a parsed object into a url string\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  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 ?\n        this.hostname :\n        '[' + this.hostname + ']');\n    if (this.port) {\n      host += ':' + this.port;\n    }\n  }\n\n  if (this.query &&\n      util.isObject(this.query) &&\n      Object.keys(this.query).length) {\n    query = querystring.stringify(this.query);\n  }\n\n  var search = this.search || (query && ('?' + query)) || '';\n\n  if (protocol && protocol.substr(-1) !== ':') protocol += ':';\n\n  // only the slashedProtocols get the //.  Not mailto:, xmpp:, etc.\n  // unless they had them to begin with.\n  if (this.slashes ||\n      (!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\n  pathname = pathname.replace(/[?#]/g, function(match) {\n    return encodeURIComponent(match);\n  });\n  search = search.replace('#', '%23');\n\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  for (var tk = 0; tk < tkeys.length; tk++) {\n    var tkey = tkeys[tk];\n    result[tkey] = this[tkey];\n  }\n\n  // hash is always overridden, no matter what.\n  // even href=\"\" will remove it.\n  result.hash = relative.hash;\n\n  // if the relative url is empty, then there's nothing left to do here.\n  if (relative.href === '') {\n    result.href = result.format();\n    return result;\n  }\n\n  // hrefs like //foo/bar always cut to the protocol.\n  if (relative.slashes && !relative.protocol) {\n    // take everything except the protocol from relative\n    var rkeys = Object.keys(relative);\n    for (var rk = 0; rk < rkeys.length; rk++) {\n      var rkey = rkeys[rk];\n      if (rkey !== 'protocol')\n        result[rkey] = relative[rkey];\n    }\n\n    //urlParse appends trailing / to urls like http://www.example.com\n    if (slashedProtocol[result.protocol] &&\n        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      for (var v = 0; v < keys.length; v++) {\n        var k = keys[v];\n        result[k] = relative[k];\n      }\n      result.href = result.format();\n      return result;\n    }\n\n    result.protocol = relative.protocol;\n    if (!relative.host && !hostlessProtocol[relative.protocol]) {\n      var relPath = (relative.pathname || '').split('/');\n      while (relPath.length && !(relative.host = relPath.shift()));\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    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;\n    // to support http.request\n    if (result.pathname || result.search) {\n      var p = result.pathname || '';\n      var s = result.search || '';\n      result.path = p + s;\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 = (\n          relative.host ||\n          relative.pathname && relative.pathname.charAt(0) === '/'\n      ),\n      mustEndAbs = (isRelAbs || isSourceAbs ||\n                    (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];\n\n  // 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  if (psychotic) {\n    result.hostname = '';\n    result.port = null;\n    if (result.host) {\n      if (srcPath[0] === '') srcPath[0] = result.host;\n      else srcPath.unshift(result.host);\n    }\n    result.host = '';\n    if (relative.protocol) {\n      relative.hostname = null;\n      relative.port = null;\n      if (relative.host) {\n        if (relPath[0] === '') relPath[0] = relative.host;\n        else relPath.unshift(relative.host);\n      }\n      relative.host = null;\n    }\n    mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');\n  }\n\n  if (isRelAbs) {\n    // it's absolute.\n    result.host = (relative.host || relative.host === '') ?\n                  relative.host : result.host;\n    result.hostname = (relative.hostname || relative.hostname === '') ?\n                      relative.hostname : result.hostname;\n    result.search = relative.search;\n    result.query = relative.query;\n    srcPath = relPath;\n    // 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();\n      //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      var authInHost = result.host && result.host.indexOf('@') > 0 ?\n                       result.host.split('@') : false;\n      if (authInHost) {\n        result.auth = authInHost.shift();\n        result.host = result.hostname = authInHost.shift();\n      }\n    }\n    result.search = relative.search;\n    result.query = relative.query;\n    //to support http.request\n    if (!util.isNull(result.pathname) || !util.isNull(result.search)) {\n      result.path = (result.pathname ? result.pathname : '') +\n                    (result.search ? result.search : '');\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;\n    //to support http.request\n    if (result.search) {\n      result.path = '/' + result.search;\n    } else {\n      result.path = null;\n    }\n    result.href = result.format();\n    return result;\n  }\n\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  var last = srcPath.slice(-1)[0];\n  var hasTrailingSlash = (\n      (result.host || relative.host || srcPath.length > 1) &&\n      (last === '.' || last === '..') || last === '');\n\n  // strip single dots, resolve double dots to parent dir\n  // if the path tries to go above the root, `up` ends up > 0\n  var up = 0;\n  for (var i = srcPath.length; i >= 0; i--) {\n    last = srcPath[i];\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  }\n\n  // if the path is allowed to go above the root, restore leading ..s\n  if (!mustEndAbs && !removeAllDots) {\n    for (; up--; up) {\n      srcPath.unshift('..');\n    }\n  }\n\n  if (mustEndAbs && srcPath[0] !== '' &&\n      (!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] === '' ||\n      (srcPath[0] && srcPath[0].charAt(0) === '/');\n\n  // put the host back\n  if (psychotic) {\n    result.hostname = result.host = isAbsolute ? '' :\n                                    srcPath.length ? srcPath.shift() : '';\n    //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    var authInHost = result.host && result.host.indexOf('@') > 0 ?\n                     result.host.split('@') : false;\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  }\n\n  //to support request.http\n  if (!util.isNull(result.pathname) || !util.isNull(result.search)) {\n    result.path = (result.pathname ? result.pathname : '') +\n                  (result.search ? result.search : '');\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  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","'use strict';\n\nmodule.exports = {\n  isString: function(arg) {\n    return typeof(arg) === 'string';\n  },\n  isObject: function(arg) {\n    return typeof(arg) === 'object' && arg !== null;\n  },\n  isNull: function(arg) {\n    return arg === null;\n  },\n  isNullOrUndefined: function(arg) {\n    return arg == null;\n  }\n};\n"],"names":["productShorthands","confluence","jira","stride","bitbucket","trello","encode","originData","json","JSON","stringify","id","product","i","p","toJSONObject","base64","getEnv","btoa","base64ToBase64Url","decode","encodedOriginString","base64UrlToBase64","atob","originJSONObject","maybeShorthand","products","Object","keys","length","expandProductShorthand","fromJSONObject","parse","env","validateEnv","bind","undefined","Buffer","encoded","from","toString","str","URLSearchParams","require","TypeError","originParamName","originVersioningAttributes","originLibrary","OriginTracer","constructor","generateId","dangerouslySkipValidation","this","validate","value","test","uuid","replace","EmptyOriginTracer","MalformedOriginTracer","url","params","replaceQuery","queryString","fromEncoded","get","createEmpty","e","createMalformed","delete","encodedOrigin","addToUrl","originalQueryString","set","isEmpty","isMalformed","isValid","toAnalyticsAttributes","transformValue","v","hasGeneratedId","originProduct","isValidId","isValidProduct","super","originMalformed","replacer","String","wholeMatch","beforeQuery","afterQuery","newQueryString","base64url","padLength","slice","global","uncurryThis","aCallable","isObject","hasOwn","arraySlice","NATIVE_BIND","Function","concat","join","factories","construct","C","argsLength","args","list","module","exports","that","F","Prototype","prototype","partArgs","arguments","boundFunction","apply","$","getBuiltIn","aConstructor","anObject","create","fails","nativeConstruct","ObjectPrototype","push","NEW_TARGET_BUG","ARGS_BUG","FORCED","target","stat","forced","sham","Target","newTarget","$args","proto","instance","result","hasOwnProperty","obj","prop","call","qs","sep","eq","options","regexp","split","maxKeys","len","kstr","vstr","k","x","idx","indexOf","substr","decodeURIComponent","Array","isArray","stringifyPrimitive","isFinite","name","map","ks","encodeURIComponent","root","nodeType","freeGlobal","g","window","self","punycode","maxInt","base","regexPunycode","regexNonASCII","regexSeparators","errors","floor","Math","stringFromCharCode","fromCharCode","error","type","RangeError","array","fn","mapDomain","string","parts","ucs2decode","extra","output","counter","charCodeAt","ucs2encode","digitToBasic","digit","flag","adapt","delta","numPoints","firstTime","baseMinusTMin","input","out","basic","j","index","oldi","w","t","baseMinusT","codePoint","inputLength","n","bias","lastIndexOf","splice","handledCPCount","basicLength","m","q","currentValue","handledCPCountPlusOne","qMinusT","toLowerCase","util","Url","protocol","slashes","auth","host","port","hostname","hash","search","query","pathname","path","href","protocolPattern","portPattern","simplePathPattern","unwise","autoEscape","nonHostChars","hostEndingChars","hostnamePartPattern","hostnamePartStart","unsafeProtocol","hostlessProtocol","slashedProtocol","querystring","parseQueryString","slashesDenoteHost","isString","queryIndex","splitter","uSplit","rest","trim","simplePath","exec","lowerProto","match","atSign","hostEnd","hec","parseHost","ipv6Hostname","hostparts","l","part","newpart","validParts","notHost","bit","unshift","toASCII","h","ae","esc","escape","qm","s","format","charAt","resolve","relative","resolveObject","u","urlParse","rel","tkeys","tk","tkey","rkeys","rk","rkey","relPath","shift","isSourceAbs","isRelAbs","mustEndAbs","removeAllDots","srcPath","psychotic","pop","isNullOrUndefined","authInHost","isNull","last","hasTrailingSlash","up","isAbsolute","arg"],"sourceRoot":""}