{"version":3,"sources":["webpack:///./node_modules/path-browserify/index.js"],"names":["normalizeArray","parts","allowAboveRoot","up","i","length","last","splice","unshift","basename","path","start","end","matchedSlash","charCodeAt","slice","filter","xs","f","res","push","exports","resolve","resolvedPath","resolvedAbsolute","arguments","process","cwd","TypeError","charAt","split","p","join","normalize","isAbsolute","trailingSlash","substr","paths","Array","prototype","call","index","relative","from","to","trim","arr","fromParts","toParts","Math","min","samePartsLength","outputParts","concat","sep","delimiter","dirname","code","hasRoot","ext","extname","startDot","startPart","preDotState","str","len"],"mappings":"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","file":"js/npm.path-browserify.84d20a6c.js","sourcesContent":["// .dirname, .basename, and .extname methods are extracted from Node.js v8.11.1,\n// backported and transplited with Babel, with backwards-compat fixes\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// resolves . and .. elements in a path array with directory names there\n// must be no slashes, empty elements, or device names (c:\\) in the array\n// (so also no leading and trailing slashes - it does not distinguish\n// relative and absolute paths)\nfunction normalizeArray(parts, allowAboveRoot) {\n  // if the path tries to go above the root, `up` ends up > 0\n  var up = 0;\n  for (var i = parts.length - 1; i >= 0; i--) {\n    var last = parts[i];\n    if (last === '.') {\n      parts.splice(i, 1);\n    } else if (last === '..') {\n      parts.splice(i, 1);\n      up++;\n    } else if (up) {\n      parts.splice(i, 1);\n      up--;\n    }\n  }\n\n  // if the path is allowed to go above the root, restore leading ..s\n  if (allowAboveRoot) {\n    for (; up--; up) {\n      parts.unshift('..');\n    }\n  }\n\n  return parts;\n}\n\n// path.resolve([from ...], to)\n// posix version\nexports.resolve = function() {\n  var resolvedPath = '',\n      resolvedAbsolute = false;\n\n  for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n    var path = (i >= 0) ? arguments[i] : process.cwd();\n\n    // Skip empty and invalid entries\n    if (typeof path !== 'string') {\n      throw new TypeError('Arguments to path.resolve must be strings');\n    } else if (!path) {\n      continue;\n    }\n\n    resolvedPath = path + '/' + resolvedPath;\n    resolvedAbsolute = path.charAt(0) === '/';\n  }\n\n  // At this point the path should be resolved to a full absolute path, but\n  // handle relative paths to be safe (might happen when process.cwd() fails)\n\n  // Normalize the path\n  resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {\n    return !!p;\n  }), !resolvedAbsolute).join('/');\n\n  return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';\n};\n\n// path.normalize(path)\n// posix version\nexports.normalize = function(path) {\n  var isAbsolute = exports.isAbsolute(path),\n      trailingSlash = substr(path, -1) === '/';\n\n  // Normalize the path\n  path = normalizeArray(filter(path.split('/'), function(p) {\n    return !!p;\n  }), !isAbsolute).join('/');\n\n  if (!path && !isAbsolute) {\n    path = '.';\n  }\n  if (path && trailingSlash) {\n    path += '/';\n  }\n\n  return (isAbsolute ? '/' : '') + path;\n};\n\n// posix version\nexports.isAbsolute = function(path) {\n  return path.charAt(0) === '/';\n};\n\n// posix version\nexports.join = function() {\n  var paths = Array.prototype.slice.call(arguments, 0);\n  return exports.normalize(filter(paths, function(p, index) {\n    if (typeof p !== 'string') {\n      throw new TypeError('Arguments to path.join must be strings');\n    }\n    return p;\n  }).join('/'));\n};\n\n\n// path.relative(from, to)\n// posix version\nexports.relative = function(from, to) {\n  from = exports.resolve(from).substr(1);\n  to = exports.resolve(to).substr(1);\n\n  function trim(arr) {\n    var start = 0;\n    for (; start < arr.length; start++) {\n      if (arr[start] !== '') break;\n    }\n\n    var end = arr.length - 1;\n    for (; end >= 0; end--) {\n      if (arr[end] !== '') break;\n    }\n\n    if (start > end) return [];\n    return arr.slice(start, end - start + 1);\n  }\n\n  var fromParts = trim(from.split('/'));\n  var toParts = trim(to.split('/'));\n\n  var length = Math.min(fromParts.length, toParts.length);\n  var samePartsLength = length;\n  for (var i = 0; i < length; i++) {\n    if (fromParts[i] !== toParts[i]) {\n      samePartsLength = i;\n      break;\n    }\n  }\n\n  var outputParts = [];\n  for (var i = samePartsLength; i < fromParts.length; i++) {\n    outputParts.push('..');\n  }\n\n  outputParts = outputParts.concat(toParts.slice(samePartsLength));\n\n  return outputParts.join('/');\n};\n\nexports.sep = '/';\nexports.delimiter = ':';\n\nexports.dirname = function (path) {\n  if (typeof path !== 'string') path = path + '';\n  if (path.length === 0) return '.';\n  var code = path.charCodeAt(0);\n  var hasRoot = code === 47 /*/*/;\n  var end = -1;\n  var matchedSlash = true;\n  for (var i = path.length - 1; i >= 1; --i) {\n    code = path.charCodeAt(i);\n    if (code === 47 /*/*/) {\n        if (!matchedSlash) {\n          end = i;\n          break;\n        }\n      } else {\n      // We saw the first non-path separator\n      matchedSlash = false;\n    }\n  }\n\n  if (end === -1) return hasRoot ? '/' : '.';\n  if (hasRoot && end === 1) {\n    // return '//';\n    // Backwards-compat fix:\n    return '/';\n  }\n  return path.slice(0, end);\n};\n\nfunction basename(path) {\n  if (typeof path !== 'string') path = path + '';\n\n  var start = 0;\n  var end = -1;\n  var matchedSlash = true;\n  var i;\n\n  for (i = path.length - 1; i >= 0; --i) {\n    if (path.charCodeAt(i) === 47 /*/*/) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          start = i + 1;\n          break;\n        }\n      } else if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // path component\n      matchedSlash = false;\n      end = i + 1;\n    }\n  }\n\n  if (end === -1) return '';\n  return path.slice(start, end);\n}\n\n// Uses a mixed approach for backwards-compatibility, as ext behavior changed\n// in new Node.js versions, so only basename() above is backported here\nexports.basename = function (path, ext) {\n  var f = basename(path);\n  if (ext && f.substr(-1 * ext.length) === ext) {\n    f = f.substr(0, f.length - ext.length);\n  }\n  return f;\n};\n\nexports.extname = function (path) {\n  if (typeof path !== 'string') path = path + '';\n  var startDot = -1;\n  var startPart = 0;\n  var end = -1;\n  var matchedSlash = true;\n  // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find\n  var preDotState = 0;\n  for (var i = path.length - 1; i >= 0; --i) {\n    var code = path.charCodeAt(i);\n    if (code === 47 /*/*/) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          startPart = i + 1;\n          break;\n        }\n        continue;\n      }\n    if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension\n      matchedSlash = false;\n      end = i + 1;\n    }\n    if (code === 46 /*.*/) {\n        // If this is our first dot, mark it as the start of our extension\n        if (startDot === -1)\n          startDot = i;\n        else if (preDotState !== 1)\n          preDotState = 1;\n    } else if (startDot !== -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension\n      preDotState = -1;\n    }\n  }\n\n  if (startDot === -1 || end === -1 ||\n      // We saw a non-dot character immediately before the dot\n      preDotState === 0 ||\n      // The (right-most) trimmed path component is exactly '..'\n      preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n    return '';\n  }\n  return path.slice(startDot, end);\n};\n\nfunction filter (xs, f) {\n    if (xs.filter) return xs.filter(f);\n    var res = [];\n    for (var i = 0; i < xs.length; i++) {\n        if (f(xs[i], i, xs)) res.push(xs[i]);\n    }\n    return res;\n}\n\n// String.prototype.substr - negative index don't work in IE8\nvar substr = 'ab'.substr(-1) === 'b'\n    ? function (str, start, len) { return str.substr(start, len) }\n    : function (str, start, len) {\n        if (start < 0) start = str.length + start;\n        return str.substr(start, len);\n    }\n;\n"],"sourceRoot":""}