{"version":3,"file":"npm-path-to-regexp-dde8818909f50aaf204f.js","mappings":"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","sources":["webpack:///../node_modules/path-to-regexp/index.js","webpack:///../node_modules/path-to-regexp/node_modules/isarray/index.js"],"sourcesContent":["var isarray = require('isarray')\n\n/**\n * Expose `pathToRegexp`.\n */\nmodule.exports = pathToRegexp\nmodule.exports.parse = parse\nmodule.exports.compile = compile\nmodule.exports.tokensToFunction = tokensToFunction\nmodule.exports.tokensToRegExp = tokensToRegExp\n\n/**\n * The main path matching regexp utility.\n *\n * @type {RegExp}\n */\nvar PATH_REGEXP = new RegExp([\n  // Match escaped characters that would otherwise appear in future matches.\n  // This allows the user to escape special characters that won't transform.\n  '(\\\\\\\\.)',\n  // Match Express-style parameters and un-named parameters with a prefix\n  // and optional suffixes. Matches appear as:\n  //\n  // \"/:test(\\\\d+)?\" => [\"/\", \"test\", \"\\d+\", undefined, \"?\", undefined]\n  // \"/route(\\\\d+)\"  => [undefined, undefined, undefined, \"\\d+\", undefined, undefined]\n  // \"/*\"            => [\"/\", undefined, undefined, undefined, undefined, \"*\"]\n  '([\\\\/.])?(?:(?:\\\\:(\\\\w+)(?:\\\\(((?:\\\\\\\\.|[^\\\\\\\\()])+)\\\\))?|\\\\(((?:\\\\\\\\.|[^\\\\\\\\()])+)\\\\))([+*?])?|(\\\\*))'\n].join('|'), 'g')\n\n/**\n * Parse a string for the raw tokens.\n *\n * @param  {string}  str\n * @param  {Object=} options\n * @return {!Array}\n */\nfunction parse (str, options) {\n  var tokens = []\n  var key = 0\n  var index = 0\n  var path = ''\n  var defaultDelimiter = options && options.delimiter || '/'\n  var res\n\n  while ((res = PATH_REGEXP.exec(str)) != null) {\n    var m = res[0]\n    var escaped = res[1]\n    var offset = res.index\n    path += str.slice(index, offset)\n    index = offset + m.length\n\n    // Ignore already escaped sequences.\n    if (escaped) {\n      path += escaped[1]\n      continue\n    }\n\n    var next = str[index]\n    var prefix = res[2]\n    var name = res[3]\n    var capture = res[4]\n    var group = res[5]\n    var modifier = res[6]\n    var asterisk = res[7]\n\n    // Push the current path onto the tokens.\n    if (path) {\n      tokens.push(path)\n      path = ''\n    }\n\n    var partial = prefix != null && next != null && next !== prefix\n    var repeat = modifier === '+' || modifier === '*'\n    var optional = modifier === '?' || modifier === '*'\n    var delimiter = res[2] || defaultDelimiter\n    var pattern = capture || group\n\n    tokens.push({\n      name: name || key++,\n      prefix: prefix || '',\n      delimiter: delimiter,\n      optional: optional,\n      repeat: repeat,\n      partial: partial,\n      asterisk: !!asterisk,\n      pattern: pattern ? escapeGroup(pattern) : (asterisk ? '.*' : '[^' + escapeString(delimiter) + ']+?')\n    })\n  }\n\n  // Match any characters still remaining.\n  if (index < str.length) {\n    path += str.substr(index)\n  }\n\n  // If the path exists, push it onto the end.\n  if (path) {\n    tokens.push(path)\n  }\n\n  return tokens\n}\n\n/**\n * Compile a string to a template function for the path.\n *\n * @param  {string}             str\n * @param  {Object=}            options\n * @return {!function(Object=, Object=)}\n */\nfunction compile (str, options) {\n  return tokensToFunction(parse(str, options), options)\n}\n\n/**\n * Prettier encoding of URI path segments.\n *\n * @param  {string}\n * @return {string}\n */\nfunction encodeURIComponentPretty (str) {\n  return encodeURI(str).replace(/[\\/?#]/g, function (c) {\n    return '%' + c.charCodeAt(0).toString(16).toUpperCase()\n  })\n}\n\n/**\n * Encode the asterisk parameter. Similar to `pretty`, but allows slashes.\n *\n * @param  {string}\n * @return {string}\n */\nfunction encodeAsterisk (str) {\n  return encodeURI(str).replace(/[?#]/g, function (c) {\n    return '%' + c.charCodeAt(0).toString(16).toUpperCase()\n  })\n}\n\n/**\n * Expose a method for transforming tokens into the path function.\n */\nfunction tokensToFunction (tokens, options) {\n  // Compile all the tokens into regexps.\n  var matches = new Array(tokens.length)\n\n  // Compile all the patterns before compilation.\n  for (var i = 0; i < tokens.length; i++) {\n    if (typeof tokens[i] === 'object') {\n      matches[i] = new RegExp('^(?:' + tokens[i].pattern + ')$', flags(options))\n    }\n  }\n\n  return function (obj, opts) {\n    var path = ''\n    var data = obj || {}\n    var options = opts || {}\n    var encode = options.pretty ? encodeURIComponentPretty : encodeURIComponent\n\n    for (var i = 0; i < tokens.length; i++) {\n      var token = tokens[i]\n\n      if (typeof token === 'string') {\n        path += token\n\n        continue\n      }\n\n      var value = data[token.name]\n      var segment\n\n      if (value == null) {\n        if (token.optional) {\n          // Prepend partial segment prefixes.\n          if (token.partial) {\n            path += token.prefix\n          }\n\n          continue\n        } else {\n          throw new TypeError('Expected \"' + token.name + '\" to be defined')\n        }\n      }\n\n      if (isarray(value)) {\n        if (!token.repeat) {\n          throw new TypeError('Expected \"' + token.name + '\" to not repeat, but received `' + JSON.stringify(value) + '`')\n        }\n\n        if (value.length === 0) {\n          if (token.optional) {\n            continue\n          } else {\n            throw new TypeError('Expected \"' + token.name + '\" to not be empty')\n          }\n        }\n\n        for (var j = 0; j < value.length; j++) {\n          segment = encode(value[j])\n\n          if (!matches[i].test(segment)) {\n            throw new TypeError('Expected all \"' + token.name + '\" to match \"' + token.pattern + '\", but received `' + JSON.stringify(segment) + '`')\n          }\n\n          path += (j === 0 ? token.prefix : token.delimiter) + segment\n        }\n\n        continue\n      }\n\n      segment = token.asterisk ? encodeAsterisk(value) : encode(value)\n\n      if (!matches[i].test(segment)) {\n        throw new TypeError('Expected \"' + token.name + '\" to match \"' + token.pattern + '\", but received \"' + segment + '\"')\n      }\n\n      path += token.prefix + segment\n    }\n\n    return path\n  }\n}\n\n/**\n * Escape a regular expression string.\n *\n * @param  {string} str\n * @return {string}\n */\nfunction escapeString (str) {\n  return str.replace(/([.+*?=^!:${}()[\\]|\\/\\\\])/g, '\\\\$1')\n}\n\n/**\n * Escape the capturing group by escaping special characters and meaning.\n *\n * @param  {string} group\n * @return {string}\n */\nfunction escapeGroup (group) {\n  return group.replace(/([=!:$\\/()])/g, '\\\\$1')\n}\n\n/**\n * Attach the keys as a property of the regexp.\n *\n * @param  {!RegExp} re\n * @param  {Array}   keys\n * @return {!RegExp}\n */\nfunction attachKeys (re, keys) {\n  re.keys = keys\n  return re\n}\n\n/**\n * Get the flags for a regexp from the options.\n *\n * @param  {Object} options\n * @return {string}\n */\nfunction flags (options) {\n  return options && options.sensitive ? '' : 'i'\n}\n\n/**\n * Pull out keys from a regexp.\n *\n * @param  {!RegExp} path\n * @param  {!Array}  keys\n * @return {!RegExp}\n */\nfunction regexpToRegexp (path, keys) {\n  // Use a negative lookahead to match only capturing groups.\n  var groups = path.source.match(/\\((?!\\?)/g)\n\n  if (groups) {\n    for (var i = 0; i < groups.length; i++) {\n      keys.push({\n        name: i,\n        prefix: null,\n        delimiter: null,\n        optional: false,\n        repeat: false,\n        partial: false,\n        asterisk: false,\n        pattern: null\n      })\n    }\n  }\n\n  return attachKeys(path, keys)\n}\n\n/**\n * Transform an array into a regexp.\n *\n * @param  {!Array}  path\n * @param  {Array}   keys\n * @param  {!Object} options\n * @return {!RegExp}\n */\nfunction arrayToRegexp (path, keys, options) {\n  var parts = []\n\n  for (var i = 0; i < path.length; i++) {\n    parts.push(pathToRegexp(path[i], keys, options).source)\n  }\n\n  var regexp = new RegExp('(?:' + parts.join('|') + ')', flags(options))\n\n  return attachKeys(regexp, keys)\n}\n\n/**\n * Create a path regexp from string input.\n *\n * @param  {string}  path\n * @param  {!Array}  keys\n * @param  {!Object} options\n * @return {!RegExp}\n */\nfunction stringToRegexp (path, keys, options) {\n  return tokensToRegExp(parse(path, options), keys, options)\n}\n\n/**\n * Expose a function for taking tokens and returning a RegExp.\n *\n * @param  {!Array}          tokens\n * @param  {(Array|Object)=} keys\n * @param  {Object=}         options\n * @return {!RegExp}\n */\nfunction tokensToRegExp (tokens, keys, options) {\n  if (!isarray(keys)) {\n    options = /** @type {!Object} */ (keys || options)\n    keys = []\n  }\n\n  options = options || {}\n\n  var strict = options.strict\n  var end = options.end !== false\n  var route = ''\n\n  // Iterate over the tokens and create our regexp string.\n  for (var i = 0; i < tokens.length; i++) {\n    var token = tokens[i]\n\n    if (typeof token === 'string') {\n      route += escapeString(token)\n    } else {\n      var prefix = escapeString(token.prefix)\n      var capture = '(?:' + token.pattern + ')'\n\n      keys.push(token)\n\n      if (token.repeat) {\n        capture += '(?:' + prefix + capture + ')*'\n      }\n\n      if (token.optional) {\n        if (!token.partial) {\n          capture = '(?:' + prefix + '(' + capture + '))?'\n        } else {\n          capture = prefix + '(' + capture + ')?'\n        }\n      } else {\n        capture = prefix + '(' + capture + ')'\n      }\n\n      route += capture\n    }\n  }\n\n  var delimiter = escapeString(options.delimiter || '/')\n  var endsWithDelimiter = route.slice(-delimiter.length) === delimiter\n\n  // In non-strict mode we allow a slash at the end of match. If the path to\n  // match already ends with a slash, we remove it for consistency. The slash\n  // is valid at the end of a path match, not in the middle. This is important\n  // in non-ending mode, where \"/test/\" shouldn't match \"/test//route\".\n  if (!strict) {\n    route = (endsWithDelimiter ? route.slice(0, -delimiter.length) : route) + '(?:' + delimiter + '(?=$))?'\n  }\n\n  if (end) {\n    route += '$'\n  } else {\n    // In non-ending mode, we need the capturing groups to match as much as\n    // possible by using a positive lookahead to the end or next path segment.\n    route += strict && endsWithDelimiter ? '' : '(?=' + delimiter + '|$)'\n  }\n\n  return attachKeys(new RegExp('^' + route, flags(options)), keys)\n}\n\n/**\n * Normalize the given path string, returning a regular expression.\n *\n * An empty array can be passed in for the keys, which will hold the\n * placeholder key descriptions. For example, using `/user/:id`, `keys` will\n * contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`.\n *\n * @param  {(string|RegExp|Array)} path\n * @param  {(Array|Object)=}       keys\n * @param  {Object=}               options\n * @return {!RegExp}\n */\nfunction pathToRegexp (path, keys, options) {\n  if (!isarray(keys)) {\n    options = /** @type {!Object} */ (keys || options)\n    keys = []\n  }\n\n  options = options || {}\n\n  if (path instanceof RegExp) {\n    return regexpToRegexp(path, /** @type {!Array} */ (keys))\n  }\n\n  if (isarray(path)) {\n    return arrayToRegexp(/** @type {!Array} */ (path), /** @type {!Array} */ (keys), options)\n  }\n\n  return stringToRegexp(/** @type {string} */ (path), /** @type {!Array} */ (keys), options)\n}\n","module.exports = Array.isArray || function (arr) {\n  return Object.prototype.toString.call(arr) == '[object Array]';\n};\n"],"names":["isarray","require","module","exports","pathToRegexp","path","keys","options","RegExp","groups","source","match","i","length","push","name","prefix","delimiter","optional","repeat","partial","asterisk","pattern","attachKeys","regexpToRegexp","parts","join","flags","arrayToRegexp","tokensToRegExp","parse","stringToRegexp","compile","str","tokensToFunction","PATH_REGEXP","res","tokens","key","index","defaultDelimiter","exec","m","escaped","offset","slice","next","capture","group","modifier","escapeGroup","escapeString","substr","encodeURIComponentPretty","encodeURI","replace","c","charCodeAt","toString","toUpperCase","matches","Array","obj","opts","data","encode","pretty","encodeURIComponent","token","segment","value","TypeError","JSON","stringify","j","test","re","sensitive","strict","end","route","endsWithDelimiter","isArray","arr","Object","prototype","call"],"sourceRoot":""}