{"version":3,"sources":["../node_modules/stacktrace-gps/node_modules/source-map/lib/util.js","../node_modules/stackframe/stackframe.js","../node_modules/stacktrace-gps/node_modules/source-map/lib/source-map-generator.js","../node_modules/stacktrace-gps/node_modules/source-map/lib/base64-vlq.js","../node_modules/stacktrace-gps/node_modules/source-map/lib/array-set.js","../node_modules/stacktrace-js/stacktrace.js","../node_modules/error-stack-parser/error-stack-parser.js","../node_modules/stack-generator/stack-generator.js","../node_modules/stacktrace-gps/stacktrace-gps.js","../node_modules/stacktrace-gps/node_modules/source-map/source-map.js","../node_modules/stacktrace-gps/node_modules/source-map/lib/base64.js","../node_modules/stacktrace-gps/node_modules/source-map/lib/mapping-list.js","../node_modules/stacktrace-gps/node_modules/source-map/lib/source-map-consumer.js","../node_modules/stacktrace-gps/node_modules/source-map/lib/binary-search.js","../node_modules/stacktrace-gps/node_modules/source-map/lib/quick-sort.js","../node_modules/stacktrace-gps/node_modules/source-map/lib/source-node.js"],"names":["exports","getArg","aArgs","aName","aDefaultValue","arguments","length","Error","urlRegexp","dataUrlRegexp","urlParse","aUrl","match","scheme","auth","host","port","path","urlGenerate","aParsedUrl","url","normalize","aPath","part","isAbsolute","parts","split","up","i","splice","join","aRoot","aPathUrl","aRootUrl","joined","charAt","replace","relative","level","indexOf","index","lastIndexOf","slice","Array","substr","supportsNullProto","Object","create","identity","s","isProtoString","charCodeAt","strcmp","aStr1","aStr2","toSetString","aStr","fromSetString","compareByOriginalPositions","mappingA","mappingB","onlyCompareOriginal","cmp","source","originalLine","originalColumn","generatedColumn","generatedLine","name","compareByGeneratedPositionsDeflated","onlyCompareGenerated","compareByGeneratedPositionsInflated","root","factory","define","_isNumber","n","isNaN","parseFloat","isFinite","_capitalize","str","toUpperCase","substring","_getter","p","this","booleanProps","numericProps","stringProps","arrayProps","objectProps","props","concat","StackFrame","obj","undefined","prototype","getArgs","args","setArgs","v","toString","call","TypeError","getEvalOrigin","evalOrigin","setEvalOrigin","fileName","getFileName","lineNumber","getLineNumber","columnNumber","getColumnNumber","functionName","getFunctionName","getIsEval","fromString","argsStartIndex","argsEndIndex","locationString","exec","Boolean","j","Number","k","String","base64VLQ","require","util","ArraySet","MappingList","SourceMapGenerator","_file","_sourceRoot","_skipValidation","_sources","_names","_mappings","_sourcesContents","_version","fromSourceMap","aSourceMapConsumer","sourceRoot","generator","file","eachMapping","mapping","newMapping","generated","line","column","original","addMapping","sources","forEach","sourceFile","content","sourceContentFor","setSourceContent","_validateMapping","has","add","aSourceFile","aSourceContent","keys","applySourceMap","aSourceMapPath","newSources","newNames","unsortedForEach","originalPositionFor","aGenerated","aOriginal","aSource","JSON","stringify","_serializeMappings","next","nameIdx","sourceIdx","previousGeneratedColumn","previousGeneratedLine","previousOriginalColumn","previousOriginalLine","previousName","previousSource","result","mappings","toArray","len","encode","_generateSourcesContent","aSources","aSourceRoot","map","key","hasOwnProperty","toJSON","version","names","sourcesContent","base64","aValue","digit","encoded","vlq","toVLQSigned","VLQ_BASE","decode","aIndex","aOutParam","continuation","strLen","shift","value","shifted","fromVLQSigned","rest","_array","_set","fromArray","aArray","aAllowDuplicates","set","size","getOwnPropertyNames","sStr","isDuplicate","idx","push","at","aIdx","ErrorStackParser","StackGenerator","StackTraceGPS","_options","filter","stackframe","sourceCache","_generateError","err","_merge","first","second","target","prop","_isShapedLikeParsableError","stack","_filtered","stackframes","get","opts","fromError","generateArtificially","getSync","parse","backtrace","error","gps","Promise","resolve","all","sf","resolveOriginal","pinpoint","then","bind","stackFrames","instrument","fn","callback","errback","thisArg","__stacktraceOriginalFn","instrumented","apply","e","deinstrument","report","errorMsg","requestOptions","reject","req","XMLHttpRequest","onerror","onreadystatechange","readyState","status","responseText","open","setRequestHeader","headers","header","reportPayload","message","send","FIREFOX_SAFARI_STACK_REGEXP","CHROME_IE_STACK_REGEXP","SAFARI_NATIVE_CODE_REGEXP","stacktrace","parseOpera","parseV8OrIE","parseFFOrSafari","extractLocation","urlLike","sanitizedLine","location","tokens","locationParts","pop","functionNameRegex","matches","parseOpera9","parseOpera11","parseOpera10","lineRE","lines","argsRaw","functionCall","maxStackSize","curr","callee","test","RegExp","$1","caller","SourceMap","_xdr","_atob","b64str","window","atob","_parseJson","string","_findFunctionName","syntaxes","code","maxLines","Math","min","commentPos","m","_ensureSupportedEnvironment","defineProperty","_ensureStackFrameIsLegit","_findSourceMappingURL","lastSourceMappingUrl","matchSourceMappingUrl","sourceMappingUrlRegExp","_extractLocationInfoFromSourceMapSource","sourceMapConsumer","loc","mappedSource","sourceMapConsumerCache","ajax","_get","isDataUrl","offline","supportedEncodingRegexp","sourceMapStart","encodedSource","xhrPromise","method","_getSourceMapConsumer","sourceMappingURL","defaultSourceRoot","sourceMapConsumerPromise","sourceMapSource","SourceMapConsumer","getMappedLocation","mappedStackFrame","resolveMappedStackFrame","findFunctionName","guessedFunctionName","SourceNode","intToCharMap","number","charCode","_sorted","_last","aCallback","aThisArg","aMapping","lineA","lineB","columnA","columnB","generatedPositionAfter","sort","binarySearch","quickSort","aSourceMap","sourceMap","sections","IndexedSourceMapConsumer","BasicSourceMapConsumer","Mapping","lastOffset","_sections","offset","offsetLine","offsetColumn","generatedOffset","consumer","__generatedMappings","_parseMappings","__originalMappings","_charIsMappingSeparator","c","GENERATED_ORDER","ORIGINAL_ORDER","GREATEST_LOWER_BOUND","LEAST_UPPER_BOUND","aContext","aOrder","context","_generatedMappings","_originalMappings","allGeneratedPositionsFor","needle","_findMapping","lastColumn","smc","generatedMappings","destGeneratedMappings","destOriginalMappings","srcMapping","destMapping","segment","end","cachedSegments","temp","originalMappings","aNeedle","aMappings","aLineName","aColumnName","aComparator","aBias","search","computeColumnSpans","nextMapping","lastGeneratedColumn","Infinity","hasContentsOfAllSources","some","sc","nullOnMissing","fileUriAbsPath","generatedPositionFor","constructor","sectionIndex","section","bias","every","generatedPosition","sectionMappings","adjustedMapping","recursiveSearch","aLow","aHigh","aHaystack","aCompare","mid","floor","swap","ary","x","y","doQuickSort","comparator","r","low","high","round","random","pivot","q","REGEX_NEWLINE","isSourceNode","aLine","aColumn","aChunks","children","sourceContents","fromStringWithSourceMap","aGeneratedCode","aRelativePath","node","remainingLines","shiftNextLine","lastGeneratedLine","lastMapping","nextLine","addMappingWithCode","aChunk","isArray","chunk","prepend","unshift","walk","aFn","aSep","newChildren","replaceRight","aPattern","aReplacement","lastChild","walkSourceContents","toStringWithSourceMap","sourceMappingActive","lastOriginalSource","lastOriginalLine","lastOriginalColumn","lastOriginalName","sourceContent"],"mappings":"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","file":"static/js/60.fdd7b1d1.chunk.js","sourcesContent":["/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\n/**\n * This is a helper function for getting values from parameter/options\n * objects.\n *\n * @param args The object we are extracting values from\n * @param name The name of the property we are getting.\n * @param defaultValue An optional value to return if the property is missing\n * from the object. If this is not specified and the property is missing, an\n * error will be thrown.\n */\nfunction getArg(aArgs, aName, aDefaultValue) {\n  if (aName in aArgs) {\n    return aArgs[aName];\n  } else if (arguments.length === 3) {\n    return aDefaultValue;\n  } else {\n    throw new Error('\"' + aName + '\" is a required argument.');\n  }\n}\nexports.getArg = getArg;\n\nvar urlRegexp = /^(?:([\\w+\\-.]+):)?\\/\\/(?:(\\w+:\\w+)@)?([\\w.]*)(?::(\\d+))?(\\S*)$/;\nvar dataUrlRegexp = /^data:.+\\,.+$/;\n\nfunction urlParse(aUrl) {\n  var match = aUrl.match(urlRegexp);\n  if (!match) {\n    return null;\n  }\n  return {\n    scheme: match[1],\n    auth: match[2],\n    host: match[3],\n    port: match[4],\n    path: match[5]\n  };\n}\nexports.urlParse = urlParse;\n\nfunction urlGenerate(aParsedUrl) {\n  var url = '';\n  if (aParsedUrl.scheme) {\n    url += aParsedUrl.scheme + ':';\n  }\n  url += '//';\n  if (aParsedUrl.auth) {\n    url += aParsedUrl.auth + '@';\n  }\n  if (aParsedUrl.host) {\n    url += aParsedUrl.host;\n  }\n  if (aParsedUrl.port) {\n    url += \":\" + aParsedUrl.port\n  }\n  if (aParsedUrl.path) {\n    url += aParsedUrl.path;\n  }\n  return url;\n}\nexports.urlGenerate = urlGenerate;\n\n/**\n * Normalizes a path, or the path portion of a URL:\n *\n * - Replaces consecutive slashes with one slash.\n * - Removes unnecessary '.' parts.\n * - Removes unnecessary '<dir>/..' parts.\n *\n * Based on code in the Node.js 'path' core module.\n *\n * @param aPath The path or url to normalize.\n */\nfunction normalize(aPath) {\n  var path = aPath;\n  var url = urlParse(aPath);\n  if (url) {\n    if (!url.path) {\n      return aPath;\n    }\n    path = url.path;\n  }\n  var isAbsolute = exports.isAbsolute(path);\n\n  var parts = path.split(/\\/+/);\n  for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {\n    part = parts[i];\n    if (part === '.') {\n      parts.splice(i, 1);\n    } else if (part === '..') {\n      up++;\n    } else if (up > 0) {\n      if (part === '') {\n        // The first part is blank if the path is absolute. Trying to go\n        // above the root is a no-op. Therefore we can remove all '..' parts\n        // directly after the root.\n        parts.splice(i + 1, up);\n        up = 0;\n      } else {\n        parts.splice(i, 2);\n        up--;\n      }\n    }\n  }\n  path = parts.join('/');\n\n  if (path === '') {\n    path = isAbsolute ? '/' : '.';\n  }\n\n  if (url) {\n    url.path = path;\n    return urlGenerate(url);\n  }\n  return path;\n}\nexports.normalize = normalize;\n\n/**\n * Joins two paths/URLs.\n *\n * @param aRoot The root path or URL.\n * @param aPath The path or URL to be joined with the root.\n *\n * - If aPath is a URL or a data URI, aPath is returned, unless aPath is a\n *   scheme-relative URL: Then the scheme of aRoot, if any, is prepended\n *   first.\n * - Otherwise aPath is a path. If aRoot is a URL, then its path portion\n *   is updated with the result and aRoot is returned. Otherwise the result\n *   is returned.\n *   - If aPath is absolute, the result is aPath.\n *   - Otherwise the two paths are joined with a slash.\n * - Joining for example 'http://' and 'www.example.com' is also supported.\n */\nfunction join(aRoot, aPath) {\n  if (aRoot === \"\") {\n    aRoot = \".\";\n  }\n  if (aPath === \"\") {\n    aPath = \".\";\n  }\n  var aPathUrl = urlParse(aPath);\n  var aRootUrl = urlParse(aRoot);\n  if (aRootUrl) {\n    aRoot = aRootUrl.path || '/';\n  }\n\n  // `join(foo, '//www.example.org')`\n  if (aPathUrl && !aPathUrl.scheme) {\n    if (aRootUrl) {\n      aPathUrl.scheme = aRootUrl.scheme;\n    }\n    return urlGenerate(aPathUrl);\n  }\n\n  if (aPathUrl || aPath.match(dataUrlRegexp)) {\n    return aPath;\n  }\n\n  // `join('http://', 'www.example.com')`\n  if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {\n    aRootUrl.host = aPath;\n    return urlGenerate(aRootUrl);\n  }\n\n  var joined = aPath.charAt(0) === '/'\n    ? aPath\n    : normalize(aRoot.replace(/\\/+$/, '') + '/' + aPath);\n\n  if (aRootUrl) {\n    aRootUrl.path = joined;\n    return urlGenerate(aRootUrl);\n  }\n  return joined;\n}\nexports.join = join;\n\nexports.isAbsolute = function (aPath) {\n  return aPath.charAt(0) === '/' || !!aPath.match(urlRegexp);\n};\n\n/**\n * Make a path relative to a URL or another path.\n *\n * @param aRoot The root path or URL.\n * @param aPath The path or URL to be made relative to aRoot.\n */\nfunction relative(aRoot, aPath) {\n  if (aRoot === \"\") {\n    aRoot = \".\";\n  }\n\n  aRoot = aRoot.replace(/\\/$/, '');\n\n  // It is possible for the path to be above the root. In this case, simply\n  // checking whether the root is a prefix of the path won't work. Instead, we\n  // need to remove components from the root one by one, until either we find\n  // a prefix that fits, or we run out of components to remove.\n  var level = 0;\n  while (aPath.indexOf(aRoot + '/') !== 0) {\n    var index = aRoot.lastIndexOf(\"/\");\n    if (index < 0) {\n      return aPath;\n    }\n\n    // If the only part of the root that is left is the scheme (i.e. http://,\n    // file:///, etc.), one or more slashes (/), or simply nothing at all, we\n    // have exhausted all components, so the path is not relative to the root.\n    aRoot = aRoot.slice(0, index);\n    if (aRoot.match(/^([^\\/]+:\\/)?\\/*$/)) {\n      return aPath;\n    }\n\n    ++level;\n  }\n\n  // Make sure we add a \"../\" for each component we removed from the root.\n  return Array(level + 1).join(\"../\") + aPath.substr(aRoot.length + 1);\n}\nexports.relative = relative;\n\nvar supportsNullProto = (function () {\n  var obj = Object.create(null);\n  return !('__proto__' in obj);\n}());\n\nfunction identity (s) {\n  return s;\n}\n\n/**\n * Because behavior goes wacky when you set `__proto__` on objects, we\n * have to prefix all the strings in our set with an arbitrary character.\n *\n * See https://github.com/mozilla/source-map/pull/31 and\n * https://github.com/mozilla/source-map/issues/30\n *\n * @param String aStr\n */\nfunction toSetString(aStr) {\n  if (isProtoString(aStr)) {\n    return '$' + aStr;\n  }\n\n  return aStr;\n}\nexports.toSetString = supportsNullProto ? identity : toSetString;\n\nfunction fromSetString(aStr) {\n  if (isProtoString(aStr)) {\n    return aStr.slice(1);\n  }\n\n  return aStr;\n}\nexports.fromSetString = supportsNullProto ? identity : fromSetString;\n\nfunction isProtoString(s) {\n  if (!s) {\n    return false;\n  }\n\n  var length = s.length;\n\n  if (length < 9 /* \"__proto__\".length */) {\n    return false;\n  }\n\n  if (s.charCodeAt(length - 1) !== 95  /* '_' */ ||\n      s.charCodeAt(length - 2) !== 95  /* '_' */ ||\n      s.charCodeAt(length - 3) !== 111 /* 'o' */ ||\n      s.charCodeAt(length - 4) !== 116 /* 't' */ ||\n      s.charCodeAt(length - 5) !== 111 /* 'o' */ ||\n      s.charCodeAt(length - 6) !== 114 /* 'r' */ ||\n      s.charCodeAt(length - 7) !== 112 /* 'p' */ ||\n      s.charCodeAt(length - 8) !== 95  /* '_' */ ||\n      s.charCodeAt(length - 9) !== 95  /* '_' */) {\n    return false;\n  }\n\n  for (var i = length - 10; i >= 0; i--) {\n    if (s.charCodeAt(i) !== 36 /* '$' */) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n/**\n * Comparator between two mappings where the original positions are compared.\n *\n * Optionally pass in `true` as `onlyCompareGenerated` to consider two\n * mappings with the same original source/line/column, but different generated\n * line and column the same. Useful when searching for a mapping with a\n * stubbed out mapping.\n */\nfunction compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {\n  var cmp = mappingA.source - mappingB.source;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.originalLine - mappingB.originalLine;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.originalColumn - mappingB.originalColumn;\n  if (cmp !== 0 || onlyCompareOriginal) {\n    return cmp;\n  }\n\n  cmp = mappingA.generatedColumn - mappingB.generatedColumn;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.generatedLine - mappingB.generatedLine;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  return mappingA.name - mappingB.name;\n}\nexports.compareByOriginalPositions = compareByOriginalPositions;\n\n/**\n * Comparator between two mappings with deflated source and name indices where\n * the generated positions are compared.\n *\n * Optionally pass in `true` as `onlyCompareGenerated` to consider two\n * mappings with the same generated line and column, but different\n * source/name/original line and column the same. Useful when searching for a\n * mapping with a stubbed out mapping.\n */\nfunction compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {\n  var cmp = mappingA.generatedLine - mappingB.generatedLine;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.generatedColumn - mappingB.generatedColumn;\n  if (cmp !== 0 || onlyCompareGenerated) {\n    return cmp;\n  }\n\n  cmp = mappingA.source - mappingB.source;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.originalLine - mappingB.originalLine;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.originalColumn - mappingB.originalColumn;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  return mappingA.name - mappingB.name;\n}\nexports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;\n\nfunction strcmp(aStr1, aStr2) {\n  if (aStr1 === aStr2) {\n    return 0;\n  }\n\n  if (aStr1 > aStr2) {\n    return 1;\n  }\n\n  return -1;\n}\n\n/**\n * Comparator between two mappings with inflated source and name strings where\n * the generated positions are compared.\n */\nfunction compareByGeneratedPositionsInflated(mappingA, mappingB) {\n  var cmp = mappingA.generatedLine - mappingB.generatedLine;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.generatedColumn - mappingB.generatedColumn;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = strcmp(mappingA.source, mappingB.source);\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.originalLine - mappingB.originalLine;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.originalColumn - mappingB.originalColumn;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  return strcmp(mappingA.name, mappingB.name);\n}\nexports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;\n","(function(root, factory) {\n    'use strict';\n    // Universal Module Definition (UMD) to support AMD, CommonJS/Node.js, Rhino, and browsers.\n\n    /* istanbul ignore next */\n    if (typeof define === 'function' && define.amd) {\n        define('stackframe', [], factory);\n    } else if (typeof exports === 'object') {\n        module.exports = factory();\n    } else {\n        root.StackFrame = factory();\n    }\n}(this, function() {\n    'use strict';\n    function _isNumber(n) {\n        return !isNaN(parseFloat(n)) && isFinite(n);\n    }\n\n    function _capitalize(str) {\n        return str.charAt(0).toUpperCase() + str.substring(1);\n    }\n\n    function _getter(p) {\n        return function() {\n            return this[p];\n        };\n    }\n\n    var booleanProps = ['isConstructor', 'isEval', 'isNative', 'isToplevel'];\n    var numericProps = ['columnNumber', 'lineNumber'];\n    var stringProps = ['fileName', 'functionName', 'source'];\n    var arrayProps = ['args'];\n    var objectProps = ['evalOrigin'];\n\n    var props = booleanProps.concat(numericProps, stringProps, arrayProps, objectProps);\n\n    function StackFrame(obj) {\n        if (!obj) return;\n        for (var i = 0; i < props.length; i++) {\n            if (obj[props[i]] !== undefined) {\n                this['set' + _capitalize(props[i])](obj[props[i]]);\n            }\n        }\n    }\n\n    StackFrame.prototype = {\n        getArgs: function() {\n            return this.args;\n        },\n        setArgs: function(v) {\n            if (Object.prototype.toString.call(v) !== '[object Array]') {\n                throw new TypeError('Args must be an Array');\n            }\n            this.args = v;\n        },\n\n        getEvalOrigin: function() {\n            return this.evalOrigin;\n        },\n        setEvalOrigin: function(v) {\n            if (v instanceof StackFrame) {\n                this.evalOrigin = v;\n            } else if (v instanceof Object) {\n                this.evalOrigin = new StackFrame(v);\n            } else {\n                throw new TypeError('Eval Origin must be an Object or StackFrame');\n            }\n        },\n\n        toString: function() {\n            var fileName = this.getFileName() || '';\n            var lineNumber = this.getLineNumber() || '';\n            var columnNumber = this.getColumnNumber() || '';\n            var functionName = this.getFunctionName() || '';\n            if (this.getIsEval()) {\n                if (fileName) {\n                    return '[eval] (' + fileName + ':' + lineNumber + ':' + columnNumber + ')';\n                }\n                return '[eval]:' + lineNumber + ':' + columnNumber;\n            }\n            if (functionName) {\n                return functionName + ' (' + fileName + ':' + lineNumber + ':' + columnNumber + ')';\n            }\n            return fileName + ':' + lineNumber + ':' + columnNumber;\n        }\n    };\n\n    StackFrame.fromString = function StackFrame$$fromString(str) {\n        var argsStartIndex = str.indexOf('(');\n        var argsEndIndex = str.lastIndexOf(')');\n\n        var functionName = str.substring(0, argsStartIndex);\n        var args = str.substring(argsStartIndex + 1, argsEndIndex).split(',');\n        var locationString = str.substring(argsEndIndex + 1);\n\n        if (locationString.indexOf('@') === 0) {\n            var parts = /@(.+?)(?::(\\d+))?(?::(\\d+))?$/.exec(locationString, '');\n            var fileName = parts[1];\n            var lineNumber = parts[2];\n            var columnNumber = parts[3];\n        }\n\n        return new StackFrame({\n            functionName: functionName,\n            args: args || undefined,\n            fileName: fileName,\n            lineNumber: lineNumber || undefined,\n            columnNumber: columnNumber || undefined\n        });\n    };\n\n    for (var i = 0; i < booleanProps.length; i++) {\n        StackFrame.prototype['get' + _capitalize(booleanProps[i])] = _getter(booleanProps[i]);\n        StackFrame.prototype['set' + _capitalize(booleanProps[i])] = (function(p) {\n            return function(v) {\n                this[p] = Boolean(v);\n            };\n        })(booleanProps[i]);\n    }\n\n    for (var j = 0; j < numericProps.length; j++) {\n        StackFrame.prototype['get' + _capitalize(numericProps[j])] = _getter(numericProps[j]);\n        StackFrame.prototype['set' + _capitalize(numericProps[j])] = (function(p) {\n            return function(v) {\n                if (!_isNumber(v)) {\n                    throw new TypeError(p + ' must be a Number');\n                }\n                this[p] = Number(v);\n            };\n        })(numericProps[j]);\n    }\n\n    for (var k = 0; k < stringProps.length; k++) {\n        StackFrame.prototype['get' + _capitalize(stringProps[k])] = _getter(stringProps[k]);\n        StackFrame.prototype['set' + _capitalize(stringProps[k])] = (function(p) {\n            return function(v) {\n                this[p] = String(v);\n            };\n        })(stringProps[k]);\n    }\n\n    return StackFrame;\n}));\n","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar base64VLQ = require('./base64-vlq');\nvar util = require('./util');\nvar ArraySet = require('./array-set').ArraySet;\nvar MappingList = require('./mapping-list').MappingList;\n\n/**\n * An instance of the SourceMapGenerator represents a source map which is\n * being built incrementally. You may pass an object with the following\n * properties:\n *\n *   - file: The filename of the generated source.\n *   - sourceRoot: A root for all relative URLs in this source map.\n */\nfunction SourceMapGenerator(aArgs) {\n  if (!aArgs) {\n    aArgs = {};\n  }\n  this._file = util.getArg(aArgs, 'file', null);\n  this._sourceRoot = util.getArg(aArgs, 'sourceRoot', null);\n  this._skipValidation = util.getArg(aArgs, 'skipValidation', false);\n  this._sources = new ArraySet();\n  this._names = new ArraySet();\n  this._mappings = new MappingList();\n  this._sourcesContents = null;\n}\n\nSourceMapGenerator.prototype._version = 3;\n\n/**\n * Creates a new SourceMapGenerator based on a SourceMapConsumer\n *\n * @param aSourceMapConsumer The SourceMap.\n */\nSourceMapGenerator.fromSourceMap =\n  function SourceMapGenerator_fromSourceMap(aSourceMapConsumer) {\n    var sourceRoot = aSourceMapConsumer.sourceRoot;\n    var generator = new SourceMapGenerator({\n      file: aSourceMapConsumer.file,\n      sourceRoot: sourceRoot\n    });\n    aSourceMapConsumer.eachMapping(function (mapping) {\n      var newMapping = {\n        generated: {\n          line: mapping.generatedLine,\n          column: mapping.generatedColumn\n        }\n      };\n\n      if (mapping.source != null) {\n        newMapping.source = mapping.source;\n        if (sourceRoot != null) {\n          newMapping.source = util.relative(sourceRoot, newMapping.source);\n        }\n\n        newMapping.original = {\n          line: mapping.originalLine,\n          column: mapping.originalColumn\n        };\n\n        if (mapping.name != null) {\n          newMapping.name = mapping.name;\n        }\n      }\n\n      generator.addMapping(newMapping);\n    });\n    aSourceMapConsumer.sources.forEach(function (sourceFile) {\n      var content = aSourceMapConsumer.sourceContentFor(sourceFile);\n      if (content != null) {\n        generator.setSourceContent(sourceFile, content);\n      }\n    });\n    return generator;\n  };\n\n/**\n * Add a single mapping from original source line and column to the generated\n * source's line and column for this source map being created. The mapping\n * object should have the following properties:\n *\n *   - generated: An object with the generated line and column positions.\n *   - original: An object with the original line and column positions.\n *   - source: The original source file (relative to the sourceRoot).\n *   - name: An optional original token name for this mapping.\n */\nSourceMapGenerator.prototype.addMapping =\n  function SourceMapGenerator_addMapping(aArgs) {\n    var generated = util.getArg(aArgs, 'generated');\n    var original = util.getArg(aArgs, 'original', null);\n    var source = util.getArg(aArgs, 'source', null);\n    var name = util.getArg(aArgs, 'name', null);\n\n    if (!this._skipValidation) {\n      this._validateMapping(generated, original, source, name);\n    }\n\n    if (source != null) {\n      source = String(source);\n      if (!this._sources.has(source)) {\n        this._sources.add(source);\n      }\n    }\n\n    if (name != null) {\n      name = String(name);\n      if (!this._names.has(name)) {\n        this._names.add(name);\n      }\n    }\n\n    this._mappings.add({\n      generatedLine: generated.line,\n      generatedColumn: generated.column,\n      originalLine: original != null && original.line,\n      originalColumn: original != null && original.column,\n      source: source,\n      name: name\n    });\n  };\n\n/**\n * Set the source content for a source file.\n */\nSourceMapGenerator.prototype.setSourceContent =\n  function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {\n    var source = aSourceFile;\n    if (this._sourceRoot != null) {\n      source = util.relative(this._sourceRoot, source);\n    }\n\n    if (aSourceContent != null) {\n      // Add the source content to the _sourcesContents map.\n      // Create a new _sourcesContents map if the property is null.\n      if (!this._sourcesContents) {\n        this._sourcesContents = Object.create(null);\n      }\n      this._sourcesContents[util.toSetString(source)] = aSourceContent;\n    } else if (this._sourcesContents) {\n      // Remove the source file from the _sourcesContents map.\n      // If the _sourcesContents map is empty, set the property to null.\n      delete this._sourcesContents[util.toSetString(source)];\n      if (Object.keys(this._sourcesContents).length === 0) {\n        this._sourcesContents = null;\n      }\n    }\n  };\n\n/**\n * Applies the mappings of a sub-source-map for a specific source file to the\n * source map being generated. Each mapping to the supplied source file is\n * rewritten using the supplied source map. Note: The resolution for the\n * resulting mappings is the minimium of this map and the supplied map.\n *\n * @param aSourceMapConsumer The source map to be applied.\n * @param aSourceFile Optional. The filename of the source file.\n *        If omitted, SourceMapConsumer's file property will be used.\n * @param aSourceMapPath Optional. The dirname of the path to the source map\n *        to be applied. If relative, it is relative to the SourceMapConsumer.\n *        This parameter is needed when the two source maps aren't in the same\n *        directory, and the source map to be applied contains relative source\n *        paths. If so, those relative source paths need to be rewritten\n *        relative to the SourceMapGenerator.\n */\nSourceMapGenerator.prototype.applySourceMap =\n  function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {\n    var sourceFile = aSourceFile;\n    // If aSourceFile is omitted, we will use the file property of the SourceMap\n    if (aSourceFile == null) {\n      if (aSourceMapConsumer.file == null) {\n        throw new Error(\n          'SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, ' +\n          'or the source map\\'s \"file\" property. Both were omitted.'\n        );\n      }\n      sourceFile = aSourceMapConsumer.file;\n    }\n    var sourceRoot = this._sourceRoot;\n    // Make \"sourceFile\" relative if an absolute Url is passed.\n    if (sourceRoot != null) {\n      sourceFile = util.relative(sourceRoot, sourceFile);\n    }\n    // Applying the SourceMap can add and remove items from the sources and\n    // the names array.\n    var newSources = new ArraySet();\n    var newNames = new ArraySet();\n\n    // Find mappings for the \"sourceFile\"\n    this._mappings.unsortedForEach(function (mapping) {\n      if (mapping.source === sourceFile && mapping.originalLine != null) {\n        // Check if it can be mapped by the source map, then update the mapping.\n        var original = aSourceMapConsumer.originalPositionFor({\n          line: mapping.originalLine,\n          column: mapping.originalColumn\n        });\n        if (original.source != null) {\n          // Copy mapping\n          mapping.source = original.source;\n          if (aSourceMapPath != null) {\n            mapping.source = util.join(aSourceMapPath, mapping.source)\n          }\n          if (sourceRoot != null) {\n            mapping.source = util.relative(sourceRoot, mapping.source);\n          }\n          mapping.originalLine = original.line;\n          mapping.originalColumn = original.column;\n          if (original.name != null) {\n            mapping.name = original.name;\n          }\n        }\n      }\n\n      var source = mapping.source;\n      if (source != null && !newSources.has(source)) {\n        newSources.add(source);\n      }\n\n      var name = mapping.name;\n      if (name != null && !newNames.has(name)) {\n        newNames.add(name);\n      }\n\n    }, this);\n    this._sources = newSources;\n    this._names = newNames;\n\n    // Copy sourcesContents of applied map.\n    aSourceMapConsumer.sources.forEach(function (sourceFile) {\n      var content = aSourceMapConsumer.sourceContentFor(sourceFile);\n      if (content != null) {\n        if (aSourceMapPath != null) {\n          sourceFile = util.join(aSourceMapPath, sourceFile);\n        }\n        if (sourceRoot != null) {\n          sourceFile = util.relative(sourceRoot, sourceFile);\n        }\n        this.setSourceContent(sourceFile, content);\n      }\n    }, this);\n  };\n\n/**\n * A mapping can have one of the three levels of data:\n *\n *   1. Just the generated position.\n *   2. The Generated position, original position, and original source.\n *   3. Generated and original position, original source, as well as a name\n *      token.\n *\n * To maintain consistency, we validate that any new mapping being added falls\n * in to one of these categories.\n */\nSourceMapGenerator.prototype._validateMapping =\n  function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource,\n                                              aName) {\n    if (aGenerated && 'line' in aGenerated && 'column' in aGenerated\n        && aGenerated.line > 0 && aGenerated.column >= 0\n        && !aOriginal && !aSource && !aName) {\n      // Case 1.\n      return;\n    }\n    else if (aGenerated && 'line' in aGenerated && 'column' in aGenerated\n             && aOriginal && 'line' in aOriginal && 'column' in aOriginal\n             && aGenerated.line > 0 && aGenerated.column >= 0\n             && aOriginal.line > 0 && aOriginal.column >= 0\n             && aSource) {\n      // Cases 2 and 3.\n      return;\n    }\n    else {\n      throw new Error('Invalid mapping: ' + JSON.stringify({\n        generated: aGenerated,\n        source: aSource,\n        original: aOriginal,\n        name: aName\n      }));\n    }\n  };\n\n/**\n * Serialize the accumulated mappings in to the stream of base 64 VLQs\n * specified by the source map format.\n */\nSourceMapGenerator.prototype._serializeMappings =\n  function SourceMapGenerator_serializeMappings() {\n    var previousGeneratedColumn = 0;\n    var previousGeneratedLine = 1;\n    var previousOriginalColumn = 0;\n    var previousOriginalLine = 0;\n    var previousName = 0;\n    var previousSource = 0;\n    var result = '';\n    var next;\n    var mapping;\n    var nameIdx;\n    var sourceIdx;\n\n    var mappings = this._mappings.toArray();\n    for (var i = 0, len = mappings.length; i < len; i++) {\n      mapping = mappings[i];\n      next = ''\n\n      if (mapping.generatedLine !== previousGeneratedLine) {\n        previousGeneratedColumn = 0;\n        while (mapping.generatedLine !== previousGeneratedLine) {\n          next += ';';\n          previousGeneratedLine++;\n        }\n      }\n      else {\n        if (i > 0) {\n          if (!util.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) {\n            continue;\n          }\n          next += ',';\n        }\n      }\n\n      next += base64VLQ.encode(mapping.generatedColumn\n                                 - previousGeneratedColumn);\n      previousGeneratedColumn = mapping.generatedColumn;\n\n      if (mapping.source != null) {\n        sourceIdx = this._sources.indexOf(mapping.source);\n        next += base64VLQ.encode(sourceIdx - previousSource);\n        previousSource = sourceIdx;\n\n        // lines are stored 0-based in SourceMap spec version 3\n        next += base64VLQ.encode(mapping.originalLine - 1\n                                   - previousOriginalLine);\n        previousOriginalLine = mapping.originalLine - 1;\n\n        next += base64VLQ.encode(mapping.originalColumn\n                                   - previousOriginalColumn);\n        previousOriginalColumn = mapping.originalColumn;\n\n        if (mapping.name != null) {\n          nameIdx = this._names.indexOf(mapping.name);\n          next += base64VLQ.encode(nameIdx - previousName);\n          previousName = nameIdx;\n        }\n      }\n\n      result += next;\n    }\n\n    return result;\n  };\n\nSourceMapGenerator.prototype._generateSourcesContent =\n  function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {\n    return aSources.map(function (source) {\n      if (!this._sourcesContents) {\n        return null;\n      }\n      if (aSourceRoot != null) {\n        source = util.relative(aSourceRoot, source);\n      }\n      var key = util.toSetString(source);\n      return Object.prototype.hasOwnProperty.call(this._sourcesContents, key)\n        ? this._sourcesContents[key]\n        : null;\n    }, this);\n  };\n\n/**\n * Externalize the source map.\n */\nSourceMapGenerator.prototype.toJSON =\n  function SourceMapGenerator_toJSON() {\n    var map = {\n      version: this._version,\n      sources: this._sources.toArray(),\n      names: this._names.toArray(),\n      mappings: this._serializeMappings()\n    };\n    if (this._file != null) {\n      map.file = this._file;\n    }\n    if (this._sourceRoot != null) {\n      map.sourceRoot = this._sourceRoot;\n    }\n    if (this._sourcesContents) {\n      map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);\n    }\n\n    return map;\n  };\n\n/**\n * Render the source map being generated to a string.\n */\nSourceMapGenerator.prototype.toString =\n  function SourceMapGenerator_toString() {\n    return JSON.stringify(this.toJSON());\n  };\n\nexports.SourceMapGenerator = SourceMapGenerator;\n","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n *\n * Based on the Base 64 VLQ implementation in Closure Compiler:\n * https://code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/debugging/sourcemap/Base64VLQ.java\n *\n * Copyright 2011 The Closure Compiler Authors. All rights reserved.\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are\n * met:\n *\n *  * Redistributions of source code must retain the above copyright\n *    notice, this list of conditions and the following disclaimer.\n *  * Redistributions in binary form must reproduce the above\n *    copyright notice, this list of conditions and the following\n *    disclaimer in the documentation and/or other materials provided\n *    with the distribution.\n *  * Neither the name of Google Inc. nor the names of its\n *    contributors may be used to endorse or promote products derived\n *    from this software without specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n * \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n\nvar base64 = require('./base64');\n\n// A single base 64 digit can contain 6 bits of data. For the base 64 variable\n// length quantities we use in the source map spec, the first bit is the sign,\n// the next four bits are the actual value, and the 6th bit is the\n// continuation bit. The continuation bit tells us whether there are more\n// digits in this value following this digit.\n//\n//   Continuation\n//   |    Sign\n//   |    |\n//   V    V\n//   101011\n\nvar VLQ_BASE_SHIFT = 5;\n\n// binary: 100000\nvar VLQ_BASE = 1 << VLQ_BASE_SHIFT;\n\n// binary: 011111\nvar VLQ_BASE_MASK = VLQ_BASE - 1;\n\n// binary: 100000\nvar VLQ_CONTINUATION_BIT = VLQ_BASE;\n\n/**\n * Converts from a two-complement value to a value where the sign bit is\n * placed in the least significant bit.  For example, as decimals:\n *   1 becomes 2 (10 binary), -1 becomes 3 (11 binary)\n *   2 becomes 4 (100 binary), -2 becomes 5 (101 binary)\n */\nfunction toVLQSigned(aValue) {\n  return aValue < 0\n    ? ((-aValue) << 1) + 1\n    : (aValue << 1) + 0;\n}\n\n/**\n * Converts to a two-complement value from a value where the sign bit is\n * placed in the least significant bit.  For example, as decimals:\n *   2 (10 binary) becomes 1, 3 (11 binary) becomes -1\n *   4 (100 binary) becomes 2, 5 (101 binary) becomes -2\n */\nfunction fromVLQSigned(aValue) {\n  var isNegative = (aValue & 1) === 1;\n  var shifted = aValue >> 1;\n  return isNegative\n    ? -shifted\n    : shifted;\n}\n\n/**\n * Returns the base 64 VLQ encoded value.\n */\nexports.encode = function base64VLQ_encode(aValue) {\n  var encoded = \"\";\n  var digit;\n\n  var vlq = toVLQSigned(aValue);\n\n  do {\n    digit = vlq & VLQ_BASE_MASK;\n    vlq >>>= VLQ_BASE_SHIFT;\n    if (vlq > 0) {\n      // There are still more digits in this value, so we must make sure the\n      // continuation bit is marked.\n      digit |= VLQ_CONTINUATION_BIT;\n    }\n    encoded += base64.encode(digit);\n  } while (vlq > 0);\n\n  return encoded;\n};\n\n/**\n * Decodes the next base 64 VLQ value from the given string and returns the\n * value and the rest of the string via the out parameter.\n */\nexports.decode = function base64VLQ_decode(aStr, aIndex, aOutParam) {\n  var strLen = aStr.length;\n  var result = 0;\n  var shift = 0;\n  var continuation, digit;\n\n  do {\n    if (aIndex >= strLen) {\n      throw new Error(\"Expected more digits in base 64 VLQ value.\");\n    }\n\n    digit = base64.decode(aStr.charCodeAt(aIndex++));\n    if (digit === -1) {\n      throw new Error(\"Invalid base64 digit: \" + aStr.charAt(aIndex - 1));\n    }\n\n    continuation = !!(digit & VLQ_CONTINUATION_BIT);\n    digit &= VLQ_BASE_MASK;\n    result = result + (digit << shift);\n    shift += VLQ_BASE_SHIFT;\n  } while (continuation);\n\n  aOutParam.value = fromVLQSigned(result);\n  aOutParam.rest = aIndex;\n};\n","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar util = require('./util');\nvar has = Object.prototype.hasOwnProperty;\n\n/**\n * A data structure which is a combination of an array and a set. Adding a new\n * member is O(1), testing for membership is O(1), and finding the index of an\n * element is O(1). Removing elements from the set is not supported. Only\n * strings are supported for membership.\n */\nfunction ArraySet() {\n  this._array = [];\n  this._set = Object.create(null);\n}\n\n/**\n * Static method for creating ArraySet instances from an existing array.\n */\nArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {\n  var set = new ArraySet();\n  for (var i = 0, len = aArray.length; i < len; i++) {\n    set.add(aArray[i], aAllowDuplicates);\n  }\n  return set;\n};\n\n/**\n * Return how many unique items are in this ArraySet. If duplicates have been\n * added, than those do not count towards the size.\n *\n * @returns Number\n */\nArraySet.prototype.size = function ArraySet_size() {\n  return Object.getOwnPropertyNames(this._set).length;\n};\n\n/**\n * Add the given string to this set.\n *\n * @param String aStr\n */\nArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {\n  var sStr = util.toSetString(aStr);\n  var isDuplicate = has.call(this._set, sStr);\n  var idx = this._array.length;\n  if (!isDuplicate || aAllowDuplicates) {\n    this._array.push(aStr);\n  }\n  if (!isDuplicate) {\n    this._set[sStr] = idx;\n  }\n};\n\n/**\n * Is the given string a member of this set?\n *\n * @param String aStr\n */\nArraySet.prototype.has = function ArraySet_has(aStr) {\n  var sStr = util.toSetString(aStr);\n  return has.call(this._set, sStr);\n};\n\n/**\n * What is the index of the given string in the array?\n *\n * @param String aStr\n */\nArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {\n  var sStr = util.toSetString(aStr);\n  if (has.call(this._set, sStr)) {\n    return this._set[sStr];\n  }\n  throw new Error('\"' + aStr + '\" is not in the set.');\n};\n\n/**\n * What is the element at the given index?\n *\n * @param Number aIdx\n */\nArraySet.prototype.at = function ArraySet_at(aIdx) {\n  if (aIdx >= 0 && aIdx < this._array.length) {\n    return this._array[aIdx];\n  }\n  throw new Error('No element indexed by ' + aIdx);\n};\n\n/**\n * Returns the array representation of this set (which has the proper indices\n * indicated by indexOf). Note that this is a copy of the internal array used\n * for storing the members so that no one can mess with internal state.\n */\nArraySet.prototype.toArray = function ArraySet_toArray() {\n  return this._array.slice();\n};\n\nexports.ArraySet = ArraySet;\n","(function(root, factory) {\n    'use strict';\n    // Universal Module Definition (UMD) to support AMD, CommonJS/Node.js, Rhino, and browsers.\n\n    /* istanbul ignore next */\n    if (typeof define === 'function' && define.amd) {\n        define('stacktrace', ['error-stack-parser', 'stack-generator', 'stacktrace-gps'], factory);\n    } else if (typeof exports === 'object') {\n        module.exports = factory(require('error-stack-parser'), require('stack-generator'), require('stacktrace-gps'));\n    } else {\n        root.StackTrace = factory(root.ErrorStackParser, root.StackGenerator, root.StackTraceGPS);\n    }\n}(this, function StackTrace(ErrorStackParser, StackGenerator, StackTraceGPS) {\n    var _options = {\n        filter: function(stackframe) {\n            // Filter out stackframes for this library by default\n            return (stackframe.functionName || '').indexOf('StackTrace$$') === -1 &&\n                (stackframe.functionName || '').indexOf('ErrorStackParser$$') === -1 &&\n                (stackframe.functionName || '').indexOf('StackTraceGPS$$') === -1 &&\n                (stackframe.functionName || '').indexOf('StackGenerator$$') === -1;\n        },\n        sourceCache: {}\n    };\n\n    var _generateError = function StackTrace$$GenerateError() {\n        try {\n            // Error must be thrown to get stack in IE\n            throw new Error();\n        } catch (err) {\n            return err;\n        }\n    };\n\n    /**\n     * Merge 2 given Objects. If a conflict occurs the second object wins.\n     * Does not do deep merges.\n     *\n     * @param {Object} first base object\n     * @param {Object} second overrides\n     * @returns {Object} merged first and second\n     * @private\n     */\n    function _merge(first, second) {\n        var target = {};\n\n        [first, second].forEach(function(obj) {\n            for (var prop in obj) {\n                if (Object.prototype.hasOwnProperty.call(obj, prop)) {\n                    target[prop] = obj[prop];\n                }\n            }\n            return target;\n        });\n\n        return target;\n    }\n\n    function _isShapedLikeParsableError(err) {\n        return err.stack || err['opera#sourceloc'];\n    }\n\n    function _filtered(stackframes, filter) {\n        if (typeof filter === 'function') {\n            return stackframes.filter(filter);\n        }\n        return stackframes;\n    }\n\n    return {\n        /**\n         * Get a backtrace from invocation point.\n         *\n         * @param {Object} opts\n         * @returns {Array} of StackFrame\n         */\n        get: function StackTrace$$get(opts) {\n            var err = _generateError();\n            return _isShapedLikeParsableError(err) ? this.fromError(err, opts) : this.generateArtificially(opts);\n        },\n\n        /**\n         * Get a backtrace from invocation point.\n         * IMPORTANT: Does not handle source maps or guess function names!\n         *\n         * @param {Object} opts\n         * @returns {Array} of StackFrame\n         */\n        getSync: function StackTrace$$getSync(opts) {\n            opts = _merge(_options, opts);\n            var err = _generateError();\n            var stack = _isShapedLikeParsableError(err) ? ErrorStackParser.parse(err) : StackGenerator.backtrace(opts);\n            return _filtered(stack, opts.filter);\n        },\n\n        /**\n         * Given an error object, parse it.\n         *\n         * @param {Error} error object\n         * @param {Object} opts\n         * @returns {Promise} for Array[StackFrame}\n         */\n        fromError: function StackTrace$$fromError(error, opts) {\n            opts = _merge(_options, opts);\n            var gps = new StackTraceGPS(opts);\n            return new Promise(function(resolve) {\n                var stackframes = _filtered(ErrorStackParser.parse(error), opts.filter);\n                resolve(Promise.all(stackframes.map(function(sf) {\n                    return new Promise(function(resolve) {\n                        function resolveOriginal() {\n                            resolve(sf);\n                        }\n\n                        gps.pinpoint(sf).then(resolve, resolveOriginal)['catch'](resolveOriginal);\n                    });\n                })));\n            }.bind(this));\n        },\n\n        /**\n         * Use StackGenerator to generate a backtrace.\n         *\n         * @param {Object} opts\n         * @returns {Promise} of Array[StackFrame]\n         */\n        generateArtificially: function StackTrace$$generateArtificially(opts) {\n            opts = _merge(_options, opts);\n            var stackFrames = StackGenerator.backtrace(opts);\n            if (typeof opts.filter === 'function') {\n                stackFrames = stackFrames.filter(opts.filter);\n            }\n            return Promise.resolve(stackFrames);\n        },\n\n        /**\n         * Given a function, wrap it such that invocations trigger a callback that\n         * is called with a stack trace.\n         *\n         * @param {Function} fn to be instrumented\n         * @param {Function} callback function to call with a stack trace on invocation\n         * @param {Function} errback optional function to call with error if unable to get stack trace.\n         * @param {Object} thisArg optional context object (e.g. window)\n         */\n        instrument: function StackTrace$$instrument(fn, callback, errback, thisArg) {\n            if (typeof fn !== 'function') {\n                throw new Error('Cannot instrument non-function object');\n            } else if (typeof fn.__stacktraceOriginalFn === 'function') {\n                // Already instrumented, return given Function\n                return fn;\n            }\n\n            var instrumented = function StackTrace$$instrumented() {\n                try {\n                    this.get().then(callback, errback)['catch'](errback);\n                    return fn.apply(thisArg || this, arguments);\n                } catch (e) {\n                    if (_isShapedLikeParsableError(e)) {\n                        this.fromError(e).then(callback, errback)['catch'](errback);\n                    }\n                    throw e;\n                }\n            }.bind(this);\n            instrumented.__stacktraceOriginalFn = fn;\n\n            return instrumented;\n        },\n\n        /**\n         * Given a function that has been instrumented,\n         * revert the function to it's original (non-instrumented) state.\n         *\n         * @param {Function} fn to de-instrument\n         */\n        deinstrument: function StackTrace$$deinstrument(fn) {\n            if (typeof fn !== 'function') {\n                throw new Error('Cannot de-instrument non-function object');\n            } else if (typeof fn.__stacktraceOriginalFn === 'function') {\n                return fn.__stacktraceOriginalFn;\n            } else {\n                // Function not instrumented, return original\n                return fn;\n            }\n        },\n\n        /**\n         * Given an error message and Array of StackFrames, serialize and POST to given URL.\n         *\n         * @param {Array} stackframes\n         * @param {String} url\n         * @param {String} errorMsg\n         * @param {Object} requestOptions\n         */\n        report: function StackTrace$$report(stackframes, url, errorMsg, requestOptions) {\n            return new Promise(function(resolve, reject) {\n                var req = new XMLHttpRequest();\n                req.onerror = reject;\n                req.onreadystatechange = function onreadystatechange() {\n                    if (req.readyState === 4) {\n                        if (req.status >= 200 && req.status < 400) {\n                            resolve(req.responseText);\n                        } else {\n                            reject(new Error('POST to ' + url + ' failed with status: ' + req.status));\n                        }\n                    }\n                };\n                req.open('post', url);\n\n                // Set request headers\n                req.setRequestHeader('Content-Type', 'application/json');\n                if (requestOptions && typeof requestOptions.headers === 'object') {\n                    var headers = requestOptions.headers;\n                    for (var header in headers) {\n                        if (Object.prototype.hasOwnProperty.call(headers, header)) {\n                            req.setRequestHeader(header, headers[header]);\n                        }\n                    }\n                }\n\n                var reportPayload = {stack: stackframes};\n                if (errorMsg !== undefined && errorMsg !== null) {\n                    reportPayload.message = errorMsg;\n                }\n\n                req.send(JSON.stringify(reportPayload));\n            });\n        }\n    };\n}));\n","(function(root, factory) {\n    'use strict';\n    // Universal Module Definition (UMD) to support AMD, CommonJS/Node.js, Rhino, and browsers.\n\n    /* istanbul ignore next */\n    if (typeof define === 'function' && define.amd) {\n        define('error-stack-parser', ['stackframe'], factory);\n    } else if (typeof exports === 'object') {\n        module.exports = factory(require('stackframe'));\n    } else {\n        root.ErrorStackParser = factory(root.StackFrame);\n    }\n}(this, function ErrorStackParser(StackFrame) {\n    'use strict';\n\n    var FIREFOX_SAFARI_STACK_REGEXP = /(^|@)\\S+:\\d+/;\n    var CHROME_IE_STACK_REGEXP = /^\\s*at .*(\\S+:\\d+|\\(native\\))/m;\n    var SAFARI_NATIVE_CODE_REGEXP = /^(eval@)?(\\[native code])?$/;\n\n    return {\n        /**\n         * Given an Error object, extract the most information from it.\n         *\n         * @param {Error} error object\n         * @return {Array} of StackFrames\n         */\n        parse: function ErrorStackParser$$parse(error) {\n            if (typeof error.stacktrace !== 'undefined' || typeof error['opera#sourceloc'] !== 'undefined') {\n                return this.parseOpera(error);\n            } else if (error.stack && error.stack.match(CHROME_IE_STACK_REGEXP)) {\n                return this.parseV8OrIE(error);\n            } else if (error.stack) {\n                return this.parseFFOrSafari(error);\n            } else {\n                throw new Error('Cannot parse given Error object');\n            }\n        },\n\n        // Separate line and column numbers from a string of the form: (URI:Line:Column)\n        extractLocation: function ErrorStackParser$$extractLocation(urlLike) {\n            // Fail-fast but return locations like \"(native)\"\n            if (urlLike.indexOf(':') === -1) {\n                return [urlLike];\n            }\n\n            var regExp = /(.+?)(?::(\\d+))?(?::(\\d+))?$/;\n            var parts = regExp.exec(urlLike.replace(/[()]/g, ''));\n            return [parts[1], parts[2] || undefined, parts[3] || undefined];\n        },\n\n        parseV8OrIE: function ErrorStackParser$$parseV8OrIE(error) {\n            var filtered = error.stack.split('\\n').filter(function(line) {\n                return !!line.match(CHROME_IE_STACK_REGEXP);\n            }, this);\n\n            return filtered.map(function(line) {\n                if (line.indexOf('(eval ') > -1) {\n                    // Throw away eval information until we implement stacktrace.js/stackframe#8\n                    line = line.replace(/eval code/g, 'eval').replace(/(\\(eval at [^()]*)|(\\),.*$)/g, '');\n                }\n                var sanitizedLine = line.replace(/^\\s+/, '').replace(/\\(eval code/g, '(');\n\n                // capture and preseve the parenthesized location \"(/foo/my bar.js:12:87)\" in\n                // case it has spaces in it, as the string is split on \\s+ later on\n                var location = sanitizedLine.match(/ (\\((.+):(\\d+):(\\d+)\\)$)/);\n\n                // remove the parenthesized location from the line, if it was matched\n                sanitizedLine = location ? sanitizedLine.replace(location[0], '') : sanitizedLine;\n\n                var tokens = sanitizedLine.split(/\\s+/).slice(1);\n                // if a location was matched, pass it to extractLocation() otherwise pop the last token\n                var locationParts = this.extractLocation(location ? location[1] : tokens.pop());\n                var functionName = tokens.join(' ') || undefined;\n                var fileName = ['eval', '<anonymous>'].indexOf(locationParts[0]) > -1 ? undefined : locationParts[0];\n\n                return new StackFrame({\n                    functionName: functionName,\n                    fileName: fileName,\n                    lineNumber: locationParts[1],\n                    columnNumber: locationParts[2],\n                    source: line\n                });\n            }, this);\n        },\n\n        parseFFOrSafari: function ErrorStackParser$$parseFFOrSafari(error) {\n            var filtered = error.stack.split('\\n').filter(function(line) {\n                return !line.match(SAFARI_NATIVE_CODE_REGEXP);\n            }, this);\n\n            return filtered.map(function(line) {\n                // Throw away eval information until we implement stacktrace.js/stackframe#8\n                if (line.indexOf(' > eval') > -1) {\n                    line = line.replace(/ line (\\d+)(?: > eval line \\d+)* > eval:\\d+:\\d+/g, ':$1');\n                }\n\n                if (line.indexOf('@') === -1 && line.indexOf(':') === -1) {\n                    // Safari eval frames only have function names and nothing else\n                    return new StackFrame({\n                        functionName: line\n                    });\n                } else {\n                    var functionNameRegex = /((.*\".+\"[^@]*)?[^@]*)(?:@)/;\n                    var matches = line.match(functionNameRegex);\n                    var functionName = matches && matches[1] ? matches[1] : undefined;\n                    var locationParts = this.extractLocation(line.replace(functionNameRegex, ''));\n\n                    return new StackFrame({\n                        functionName: functionName,\n                        fileName: locationParts[0],\n                        lineNumber: locationParts[1],\n                        columnNumber: locationParts[2],\n                        source: line\n                    });\n                }\n            }, this);\n        },\n\n        parseOpera: function ErrorStackParser$$parseOpera(e) {\n            if (!e.stacktrace || (e.message.indexOf('\\n') > -1 &&\n                e.message.split('\\n').length > e.stacktrace.split('\\n').length)) {\n                return this.parseOpera9(e);\n            } else if (!e.stack) {\n                return this.parseOpera10(e);\n            } else {\n                return this.parseOpera11(e);\n            }\n        },\n\n        parseOpera9: function ErrorStackParser$$parseOpera9(e) {\n            var lineRE = /Line (\\d+).*script (?:in )?(\\S+)/i;\n            var lines = e.message.split('\\n');\n            var result = [];\n\n            for (var i = 2, len = lines.length; i < len; i += 2) {\n                var match = lineRE.exec(lines[i]);\n                if (match) {\n                    result.push(new StackFrame({\n                        fileName: match[2],\n                        lineNumber: match[1],\n                        source: lines[i]\n                    }));\n                }\n            }\n\n            return result;\n        },\n\n        parseOpera10: function ErrorStackParser$$parseOpera10(e) {\n            var lineRE = /Line (\\d+).*script (?:in )?(\\S+)(?:: In function (\\S+))?$/i;\n            var lines = e.stacktrace.split('\\n');\n            var result = [];\n\n            for (var i = 0, len = lines.length; i < len; i += 2) {\n                var match = lineRE.exec(lines[i]);\n                if (match) {\n                    result.push(\n                        new StackFrame({\n                            functionName: match[3] || undefined,\n                            fileName: match[2],\n                            lineNumber: match[1],\n                            source: lines[i]\n                        })\n                    );\n                }\n            }\n\n            return result;\n        },\n\n        // Opera 10.65+ Error.stack very similar to FF/Safari\n        parseOpera11: function ErrorStackParser$$parseOpera11(error) {\n            var filtered = error.stack.split('\\n').filter(function(line) {\n                return !!line.match(FIREFOX_SAFARI_STACK_REGEXP) && !line.match(/^Error created at/);\n            }, this);\n\n            return filtered.map(function(line) {\n                var tokens = line.split('@');\n                var locationParts = this.extractLocation(tokens.pop());\n                var functionCall = (tokens.shift() || '');\n                var functionName = functionCall\n                    .replace(/<anonymous function(: (\\w+))?>/, '$2')\n                    .replace(/\\([^)]*\\)/g, '') || undefined;\n                var argsRaw;\n                if (functionCall.match(/\\(([^)]*)\\)/)) {\n                    argsRaw = functionCall.replace(/^[^(]+\\(([^)]*)\\)$/, '$1');\n                }\n                var args = (argsRaw === undefined || argsRaw === '[arguments not available]') ?\n                    undefined : argsRaw.split(',');\n\n                return new StackFrame({\n                    functionName: functionName,\n                    args: args,\n                    fileName: locationParts[0],\n                    lineNumber: locationParts[1],\n                    columnNumber: locationParts[2],\n                    source: line\n                });\n            }, this);\n        }\n    };\n}));\n","(function(root, factory) {\n    'use strict';\n    // Universal Module Definition (UMD) to support AMD, CommonJS/Node.js, Rhino, and browsers.\n\n    /* istanbul ignore next */\n    if (typeof define === 'function' && define.amd) {\n        define('stack-generator', ['stackframe'], factory);\n    } else if (typeof exports === 'object') {\n        module.exports = factory(require('stackframe'));\n    } else {\n        root.StackGenerator = factory(root.StackFrame);\n    }\n}(this, function(StackFrame) {\n    return {\n        backtrace: function StackGenerator$$backtrace(opts) {\n            var stack = [];\n            var maxStackSize = 10;\n\n            if (typeof opts === 'object' && typeof opts.maxStackSize === 'number') {\n                maxStackSize = opts.maxStackSize;\n            }\n\n            var curr = arguments.callee;\n            while (curr && stack.length < maxStackSize && curr['arguments']) {\n                // Allow V8 optimizations\n                var args = new Array(curr['arguments'].length);\n                for (var i = 0; i < args.length; ++i) {\n                    args[i] = curr['arguments'][i];\n                }\n                if (/function(?:\\s+([\\w$]+))+\\s*\\(/.test(curr.toString())) {\n                    stack.push(new StackFrame({functionName: RegExp.$1 || undefined, args: args}));\n                } else {\n                    stack.push(new StackFrame({args: args}));\n                }\n\n                try {\n                    curr = curr.caller;\n                } catch (e) {\n                    break;\n                }\n            }\n            return stack;\n        }\n    };\n}));\n","(function(root, factory) {\n    'use strict';\n    // Universal Module Definition (UMD) to support AMD, CommonJS/Node.js, Rhino, and browsers.\n\n    /* istanbul ignore next */\n    if (typeof define === 'function' && define.amd) {\n        define('stacktrace-gps', ['source-map', 'stackframe'], factory);\n    } else if (typeof exports === 'object') {\n        module.exports = factory(require('source-map/lib/source-map-consumer'), require('stackframe'));\n    } else {\n        root.StackTraceGPS = factory(root.SourceMap || root.sourceMap, root.StackFrame);\n    }\n}(this, function(SourceMap, StackFrame) {\n    'use strict';\n\n    /**\n     * Make a X-Domain request to url and callback.\n     *\n     * @param {String} url\n     * @returns {Promise} with response text if fulfilled\n     */\n    function _xdr(url) {\n        return new Promise(function(resolve, reject) {\n            var req = new XMLHttpRequest();\n            req.open('get', url);\n            req.onerror = reject;\n            req.onreadystatechange = function onreadystatechange() {\n                if (req.readyState === 4) {\n                    if ((req.status >= 200 && req.status < 300) ||\n                        (url.substr(0, 7) === 'file://' && req.responseText)) {\n                        resolve(req.responseText);\n                    } else {\n                        reject(new Error('HTTP status: ' + req.status + ' retrieving ' + url));\n                    }\n                }\n            };\n            req.send();\n        });\n\n    }\n\n    /**\n     * Convert a Base64-encoded string into its original representation.\n     * Used for inline sourcemaps.\n     *\n     * @param {String} b64str Base-64 encoded string\n     * @returns {String} original representation of the base64-encoded string.\n     */\n    function _atob(b64str) {\n        if (typeof window !== 'undefined' && window.atob) {\n            return window.atob(b64str);\n        } else {\n            throw new Error('You must supply a polyfill for window.atob in this environment');\n        }\n    }\n\n    function _parseJson(string) {\n        if (typeof JSON !== 'undefined' && JSON.parse) {\n            return JSON.parse(string);\n        } else {\n            throw new Error('You must supply a polyfill for JSON.parse in this environment');\n        }\n    }\n\n    function _findFunctionName(source, lineNumber/*, columnNumber*/) {\n        var syntaxes = [\n            // {name} = function ({args}) TODO args capture\n            /['\"]?([$_A-Za-z][$_A-Za-z0-9]*)['\"]?\\s*[:=]\\s*function\\b/,\n            // function {name}({args}) m[1]=name m[2]=args\n            /function\\s+([^('\"`]*?)\\s*\\(([^)]*)\\)/,\n            // {name} = eval()\n            /['\"]?([$_A-Za-z][$_A-Za-z0-9]*)['\"]?\\s*[:=]\\s*(?:eval|new Function)\\b/,\n            // fn_name() {\n            /\\b(?!(?:if|for|switch|while|with|catch)\\b)(?:(?:static)\\s+)?(\\S+)\\s*\\(.*?\\)\\s*\\{/,\n            // {name} = () => {\n            /['\"]?([$_A-Za-z][$_A-Za-z0-9]*)['\"]?\\s*[:=]\\s*\\(.*?\\)\\s*=>/\n        ];\n        var lines = source.split('\\n');\n\n        // Walk backwards in the source lines until we find the line which matches one of the patterns above\n        var code = '';\n        var maxLines = Math.min(lineNumber, 20);\n        for (var i = 0; i < maxLines; ++i) {\n            // lineNo is 1-based, source[] is 0-based\n            var line = lines[lineNumber - i - 1];\n            var commentPos = line.indexOf('//');\n            if (commentPos >= 0) {\n                line = line.substr(0, commentPos);\n            }\n\n            if (line) {\n                code = line + code;\n                var len = syntaxes.length;\n                for (var index = 0; index < len; index++) {\n                    var m = syntaxes[index].exec(code);\n                    if (m && m[1]) {\n                        return m[1];\n                    }\n                }\n            }\n        }\n        return undefined;\n    }\n\n    function _ensureSupportedEnvironment() {\n        if (typeof Object.defineProperty !== 'function' || typeof Object.create !== 'function') {\n            throw new Error('Unable to consume source maps in older browsers');\n        }\n    }\n\n    function _ensureStackFrameIsLegit(stackframe) {\n        if (typeof stackframe !== 'object') {\n            throw new TypeError('Given StackFrame is not an object');\n        } else if (typeof stackframe.fileName !== 'string') {\n            throw new TypeError('Given file name is not a String');\n        } else if (typeof stackframe.lineNumber !== 'number' ||\n            stackframe.lineNumber % 1 !== 0 ||\n            stackframe.lineNumber < 1) {\n            throw new TypeError('Given line number must be a positive integer');\n        } else if (typeof stackframe.columnNumber !== 'number' ||\n            stackframe.columnNumber % 1 !== 0 ||\n            stackframe.columnNumber < 0) {\n            throw new TypeError('Given column number must be a non-negative integer');\n        }\n        return true;\n    }\n\n    function _findSourceMappingURL(source) {\n        var sourceMappingUrlRegExp = /\\/\\/[#@] ?sourceMappingURL=([^\\s'\"]+)\\s*$/mg;\n        var lastSourceMappingUrl;\n        var matchSourceMappingUrl;\n        // eslint-disable-next-line no-cond-assign\n        while (matchSourceMappingUrl = sourceMappingUrlRegExp.exec(source)) {\n            lastSourceMappingUrl = matchSourceMappingUrl[1];\n        }\n        if (lastSourceMappingUrl) {\n            return lastSourceMappingUrl;\n        } else {\n            throw new Error('sourceMappingURL not found');\n        }\n    }\n\n    function _extractLocationInfoFromSourceMapSource(stackframe, sourceMapConsumer, sourceCache) {\n        return new Promise(function(resolve, reject) {\n            var loc = sourceMapConsumer.originalPositionFor({\n                line: stackframe.lineNumber,\n                column: stackframe.columnNumber\n            });\n\n            if (loc.source) {\n                // cache mapped sources\n                var mappedSource = sourceMapConsumer.sourceContentFor(loc.source);\n                if (mappedSource) {\n                    sourceCache[loc.source] = mappedSource;\n                }\n\n                resolve(\n                    // given stackframe and source location, update stackframe\n                    new StackFrame({\n                        functionName: loc.name || stackframe.functionName,\n                        args: stackframe.args,\n                        fileName: loc.source,\n                        lineNumber: loc.line,\n                        columnNumber: loc.column\n                    }));\n            } else {\n                reject(new Error('Could not get original source for given stackframe and source map'));\n            }\n        });\n    }\n\n    /**\n     * @constructor\n     * @param {Object} opts\n     *      opts.sourceCache = {url: \"Source String\"} => preload source cache\n     *      opts.sourceMapConsumerCache = {/path/file.js.map: SourceMapConsumer}\n     *      opts.offline = True to prevent network requests.\n     *              Best effort without sources or source maps.\n     *      opts.ajax = Promise returning function to make X-Domain requests\n     */\n    return function StackTraceGPS(opts) {\n        if (!(this instanceof StackTraceGPS)) {\n            return new StackTraceGPS(opts);\n        }\n        opts = opts || {};\n\n        this.sourceCache = opts.sourceCache || {};\n        this.sourceMapConsumerCache = opts.sourceMapConsumerCache || {};\n\n        this.ajax = opts.ajax || _xdr;\n\n        this._atob = opts.atob || _atob;\n\n        this._get = function _get(location) {\n            return new Promise(function(resolve, reject) {\n                var isDataUrl = location.substr(0, 5) === 'data:';\n                if (this.sourceCache[location]) {\n                    resolve(this.sourceCache[location]);\n                } else if (opts.offline && !isDataUrl) {\n                    reject(new Error('Cannot make network requests in offline mode'));\n                } else {\n                    if (isDataUrl) {\n                        // data URLs can have parameters.\n                        // see http://tools.ietf.org/html/rfc2397\n                        var supportedEncodingRegexp =\n                            /^data:application\\/json;([\\w=:\"-]+;)*base64,/;\n                        var match = location.match(supportedEncodingRegexp);\n                        if (match) {\n                            var sourceMapStart = match[0].length;\n                            var encodedSource = location.substr(sourceMapStart);\n                            var source = this._atob(encodedSource);\n                            this.sourceCache[location] = source;\n                            resolve(source);\n                        } else {\n                            reject(new Error('The encoding of the inline sourcemap is not supported'));\n                        }\n                    } else {\n                        var xhrPromise = this.ajax(location, {method: 'get'});\n                        // Cache the Promise to prevent duplicate in-flight requests\n                        this.sourceCache[location] = xhrPromise;\n                        xhrPromise.then(resolve, reject);\n                    }\n                }\n            }.bind(this));\n        };\n\n        /**\n         * Creating SourceMapConsumers is expensive, so this wraps the creation of a\n         * SourceMapConsumer in a per-instance cache.\n         *\n         * @param {String} sourceMappingURL = URL to fetch source map from\n         * @param {String} defaultSourceRoot = Default source root for source map if undefined\n         * @returns {Promise} that resolves a SourceMapConsumer\n         */\n        this._getSourceMapConsumer = function _getSourceMapConsumer(sourceMappingURL, defaultSourceRoot) {\n            return new Promise(function(resolve) {\n                if (this.sourceMapConsumerCache[sourceMappingURL]) {\n                    resolve(this.sourceMapConsumerCache[sourceMappingURL]);\n                } else {\n                    var sourceMapConsumerPromise = new Promise(function(resolve, reject) {\n                        return this._get(sourceMappingURL).then(function(sourceMapSource) {\n                            if (typeof sourceMapSource === 'string') {\n                                sourceMapSource = _parseJson(sourceMapSource.replace(/^\\)\\]\\}'/, ''));\n                            }\n                            if (typeof sourceMapSource.sourceRoot === 'undefined') {\n                                sourceMapSource.sourceRoot = defaultSourceRoot;\n                            }\n\n                            resolve(new SourceMap.SourceMapConsumer(sourceMapSource));\n                        }, reject);\n                    }.bind(this));\n                    this.sourceMapConsumerCache[sourceMappingURL] = sourceMapConsumerPromise;\n                    resolve(sourceMapConsumerPromise);\n                }\n            }.bind(this));\n        };\n\n        /**\n         * Given a StackFrame, enhance function name and use source maps for a\n         * better StackFrame.\n         *\n         * @param {StackFrame} stackframe object\n         * @returns {Promise} that resolves with with source-mapped StackFrame\n         */\n        this.pinpoint = function StackTraceGPS$$pinpoint(stackframe) {\n            return new Promise(function(resolve, reject) {\n                this.getMappedLocation(stackframe).then(function(mappedStackFrame) {\n                    function resolveMappedStackFrame() {\n                        resolve(mappedStackFrame);\n                    }\n\n                    this.findFunctionName(mappedStackFrame)\n                        .then(resolve, resolveMappedStackFrame)\n                        // eslint-disable-next-line no-unexpected-multiline\n                        ['catch'](resolveMappedStackFrame);\n                }.bind(this), reject);\n            }.bind(this));\n        };\n\n        /**\n         * Given a StackFrame, guess function name from location information.\n         *\n         * @param {StackFrame} stackframe\n         * @returns {Promise} that resolves with enhanced StackFrame.\n         */\n        this.findFunctionName = function StackTraceGPS$$findFunctionName(stackframe) {\n            return new Promise(function(resolve, reject) {\n                _ensureStackFrameIsLegit(stackframe);\n                this._get(stackframe.fileName).then(function getSourceCallback(source) {\n                    var lineNumber = stackframe.lineNumber;\n                    var columnNumber = stackframe.columnNumber;\n                    var guessedFunctionName = _findFunctionName(source, lineNumber, columnNumber);\n                    // Only replace functionName if we found something\n                    if (guessedFunctionName) {\n                        resolve(new StackFrame({\n                            functionName: guessedFunctionName,\n                            args: stackframe.args,\n                            fileName: stackframe.fileName,\n                            lineNumber: lineNumber,\n                            columnNumber: columnNumber\n                        }));\n                    } else {\n                        resolve(stackframe);\n                    }\n                }, reject)['catch'](reject);\n            }.bind(this));\n        };\n\n        /**\n         * Given a StackFrame, seek source-mapped location and return new enhanced StackFrame.\n         *\n         * @param {StackFrame} stackframe\n         * @returns {Promise} that resolves with enhanced StackFrame.\n         */\n        this.getMappedLocation = function StackTraceGPS$$getMappedLocation(stackframe) {\n            return new Promise(function(resolve, reject) {\n                _ensureSupportedEnvironment();\n                _ensureStackFrameIsLegit(stackframe);\n\n                var sourceCache = this.sourceCache;\n                var fileName = stackframe.fileName;\n                this._get(fileName).then(function(source) {\n                    var sourceMappingURL = _findSourceMappingURL(source);\n                    var isDataUrl = sourceMappingURL.substr(0, 5) === 'data:';\n                    var defaultSourceRoot = fileName.substring(0, fileName.lastIndexOf('/') + 1);\n\n                    if (sourceMappingURL[0] !== '/' && !isDataUrl && !(/^https?:\\/\\/|^\\/\\//i).test(sourceMappingURL)) {\n                        sourceMappingURL = defaultSourceRoot + sourceMappingURL;\n                    }\n\n                    return this._getSourceMapConsumer(sourceMappingURL, defaultSourceRoot)\n                        .then(function(sourceMapConsumer) {\n                            return _extractLocationInfoFromSourceMapSource(stackframe, sourceMapConsumer, sourceCache)\n                                .then(resolve)['catch'](function() {\n                                    resolve(stackframe);\n                                });\n                        });\n                }.bind(this), reject)['catch'](reject);\n            }.bind(this));\n        };\n    };\n}));\n","/*\n * Copyright 2009-2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE.txt or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\nexports.SourceMapGenerator = require('./lib/source-map-generator').SourceMapGenerator;\nexports.SourceMapConsumer = require('./lib/source-map-consumer').SourceMapConsumer;\nexports.SourceNode = require('./lib/source-node').SourceNode;\n","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar intToCharMap = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split('');\n\n/**\n * Encode an integer in the range of 0 to 63 to a single base 64 digit.\n */\nexports.encode = function (number) {\n  if (0 <= number && number < intToCharMap.length) {\n    return intToCharMap[number];\n  }\n  throw new TypeError(\"Must be between 0 and 63: \" + number);\n};\n\n/**\n * Decode a single base 64 character code digit to an integer. Returns -1 on\n * failure.\n */\nexports.decode = function (charCode) {\n  var bigA = 65;     // 'A'\n  var bigZ = 90;     // 'Z'\n\n  var littleA = 97;  // 'a'\n  var littleZ = 122; // 'z'\n\n  var zero = 48;     // '0'\n  var nine = 57;     // '9'\n\n  var plus = 43;     // '+'\n  var slash = 47;    // '/'\n\n  var littleOffset = 26;\n  var numberOffset = 52;\n\n  // 0 - 25: ABCDEFGHIJKLMNOPQRSTUVWXYZ\n  if (bigA <= charCode && charCode <= bigZ) {\n    return (charCode - bigA);\n  }\n\n  // 26 - 51: abcdefghijklmnopqrstuvwxyz\n  if (littleA <= charCode && charCode <= littleZ) {\n    return (charCode - littleA + littleOffset);\n  }\n\n  // 52 - 61: 0123456789\n  if (zero <= charCode && charCode <= nine) {\n    return (charCode - zero + numberOffset);\n  }\n\n  // 62: +\n  if (charCode == plus) {\n    return 62;\n  }\n\n  // 63: /\n  if (charCode == slash) {\n    return 63;\n  }\n\n  // Invalid base64 digit.\n  return -1;\n};\n","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2014 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar util = require('./util');\n\n/**\n * Determine whether mappingB is after mappingA with respect to generated\n * position.\n */\nfunction generatedPositionAfter(mappingA, mappingB) {\n  // Optimized for most common case\n  var lineA = mappingA.generatedLine;\n  var lineB = mappingB.generatedLine;\n  var columnA = mappingA.generatedColumn;\n  var columnB = mappingB.generatedColumn;\n  return lineB > lineA || lineB == lineA && columnB >= columnA ||\n         util.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0;\n}\n\n/**\n * A data structure to provide a sorted view of accumulated mappings in a\n * performance conscious manner. It trades a neglibable overhead in general\n * case for a large speedup in case of mappings being added in order.\n */\nfunction MappingList() {\n  this._array = [];\n  this._sorted = true;\n  // Serves as infimum\n  this._last = {generatedLine: -1, generatedColumn: 0};\n}\n\n/**\n * Iterate through internal items. This method takes the same arguments that\n * `Array.prototype.forEach` takes.\n *\n * NOTE: The order of the mappings is NOT guaranteed.\n */\nMappingList.prototype.unsortedForEach =\n  function MappingList_forEach(aCallback, aThisArg) {\n    this._array.forEach(aCallback, aThisArg);\n  };\n\n/**\n * Add the given source mapping.\n *\n * @param Object aMapping\n */\nMappingList.prototype.add = function MappingList_add(aMapping) {\n  if (generatedPositionAfter(this._last, aMapping)) {\n    this._last = aMapping;\n    this._array.push(aMapping);\n  } else {\n    this._sorted = false;\n    this._array.push(aMapping);\n  }\n};\n\n/**\n * Returns the flat, sorted array of mappings. The mappings are sorted by\n * generated position.\n *\n * WARNING: This method returns internal data without copying, for\n * performance. The return value must NOT be mutated, and should be treated as\n * an immutable borrow. If you want to take ownership, you must make your own\n * copy.\n */\nMappingList.prototype.toArray = function MappingList_toArray() {\n  if (!this._sorted) {\n    this._array.sort(util.compareByGeneratedPositionsInflated);\n    this._sorted = true;\n  }\n  return this._array;\n};\n\nexports.MappingList = MappingList;\n","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar util = require('./util');\nvar binarySearch = require('./binary-search');\nvar ArraySet = require('./array-set').ArraySet;\nvar base64VLQ = require('./base64-vlq');\nvar quickSort = require('./quick-sort').quickSort;\n\nfunction SourceMapConsumer(aSourceMap) {\n  var sourceMap = aSourceMap;\n  if (typeof aSourceMap === 'string') {\n    sourceMap = JSON.parse(aSourceMap.replace(/^\\)\\]\\}'/, ''));\n  }\n\n  return sourceMap.sections != null\n    ? new IndexedSourceMapConsumer(sourceMap)\n    : new BasicSourceMapConsumer(sourceMap);\n}\n\nSourceMapConsumer.fromSourceMap = function(aSourceMap) {\n  return BasicSourceMapConsumer.fromSourceMap(aSourceMap);\n}\n\n/**\n * The version of the source mapping spec that we are consuming.\n */\nSourceMapConsumer.prototype._version = 3;\n\n// `__generatedMappings` and `__originalMappings` are arrays that hold the\n// parsed mapping coordinates from the source map's \"mappings\" attribute. They\n// are lazily instantiated, accessed via the `_generatedMappings` and\n// `_originalMappings` getters respectively, and we only parse the mappings\n// and create these arrays once queried for a source location. We jump through\n// these hoops because there can be many thousands of mappings, and parsing\n// them is expensive, so we only want to do it if we must.\n//\n// Each object in the arrays is of the form:\n//\n//     {\n//       generatedLine: The line number in the generated code,\n//       generatedColumn: The column number in the generated code,\n//       source: The path to the original source file that generated this\n//               chunk of code,\n//       originalLine: The line number in the original source that\n//                     corresponds to this chunk of generated code,\n//       originalColumn: The column number in the original source that\n//                       corresponds to this chunk of generated code,\n//       name: The name of the original symbol which generated this chunk of\n//             code.\n//     }\n//\n// All properties except for `generatedLine` and `generatedColumn` can be\n// `null`.\n//\n// `_generatedMappings` is ordered by the generated positions.\n//\n// `_originalMappings` is ordered by the original positions.\n\nSourceMapConsumer.prototype.__generatedMappings = null;\nObject.defineProperty(SourceMapConsumer.prototype, '_generatedMappings', {\n  get: function () {\n    if (!this.__generatedMappings) {\n      this._parseMappings(this._mappings, this.sourceRoot);\n    }\n\n    return this.__generatedMappings;\n  }\n});\n\nSourceMapConsumer.prototype.__originalMappings = null;\nObject.defineProperty(SourceMapConsumer.prototype, '_originalMappings', {\n  get: function () {\n    if (!this.__originalMappings) {\n      this._parseMappings(this._mappings, this.sourceRoot);\n    }\n\n    return this.__originalMappings;\n  }\n});\n\nSourceMapConsumer.prototype._charIsMappingSeparator =\n  function SourceMapConsumer_charIsMappingSeparator(aStr, index) {\n    var c = aStr.charAt(index);\n    return c === \";\" || c === \",\";\n  };\n\n/**\n * Parse the mappings in a string in to a data structure which we can easily\n * query (the ordered arrays in the `this.__generatedMappings` and\n * `this.__originalMappings` properties).\n */\nSourceMapConsumer.prototype._parseMappings =\n  function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {\n    throw new Error(\"Subclasses must implement _parseMappings\");\n  };\n\nSourceMapConsumer.GENERATED_ORDER = 1;\nSourceMapConsumer.ORIGINAL_ORDER = 2;\n\nSourceMapConsumer.GREATEST_LOWER_BOUND = 1;\nSourceMapConsumer.LEAST_UPPER_BOUND = 2;\n\n/**\n * Iterate over each mapping between an original source/line/column and a\n * generated line/column in this source map.\n *\n * @param Function aCallback\n *        The function that is called with each mapping.\n * @param Object aContext\n *        Optional. If specified, this object will be the value of `this` every\n *        time that `aCallback` is called.\n * @param aOrder\n *        Either `SourceMapConsumer.GENERATED_ORDER` or\n *        `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to\n *        iterate over the mappings sorted by the generated file's line/column\n *        order or the original's source/line/column order, respectively. Defaults to\n *        `SourceMapConsumer.GENERATED_ORDER`.\n */\nSourceMapConsumer.prototype.eachMapping =\n  function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {\n    var context = aContext || null;\n    var order = aOrder || SourceMapConsumer.GENERATED_ORDER;\n\n    var mappings;\n    switch (order) {\n    case SourceMapConsumer.GENERATED_ORDER:\n      mappings = this._generatedMappings;\n      break;\n    case SourceMapConsumer.ORIGINAL_ORDER:\n      mappings = this._originalMappings;\n      break;\n    default:\n      throw new Error(\"Unknown order of iteration.\");\n    }\n\n    var sourceRoot = this.sourceRoot;\n    mappings.map(function (mapping) {\n      var source = mapping.source === null ? null : this._sources.at(mapping.source);\n      if (source != null && sourceRoot != null) {\n        source = util.join(sourceRoot, source);\n      }\n      return {\n        source: source,\n        generatedLine: mapping.generatedLine,\n        generatedColumn: mapping.generatedColumn,\n        originalLine: mapping.originalLine,\n        originalColumn: mapping.originalColumn,\n        name: mapping.name === null ? null : this._names.at(mapping.name)\n      };\n    }, this).forEach(aCallback, context);\n  };\n\n/**\n * Returns all generated line and column information for the original source,\n * line, and column provided. If no column is provided, returns all mappings\n * corresponding to a either the line we are searching for or the next\n * closest line that has any mappings. Otherwise, returns all mappings\n * corresponding to the given line and either the column we are searching for\n * or the next closest column that has any offsets.\n *\n * The only argument is an object with the following properties:\n *\n *   - source: The filename of the original source.\n *   - line: The line number in the original source.\n *   - column: Optional. the column number in the original source.\n *\n * and an array of objects is returned, each with the following properties:\n *\n *   - line: The line number in the generated source, or null.\n *   - column: The column number in the generated source, or null.\n */\nSourceMapConsumer.prototype.allGeneratedPositionsFor =\n  function SourceMapConsumer_allGeneratedPositionsFor(aArgs) {\n    var line = util.getArg(aArgs, 'line');\n\n    // When there is no exact match, BasicSourceMapConsumer.prototype._findMapping\n    // returns the index of the closest mapping less than the needle. By\n    // setting needle.originalColumn to 0, we thus find the last mapping for\n    // the given line, provided such a mapping exists.\n    var needle = {\n      source: util.getArg(aArgs, 'source'),\n      originalLine: line,\n      originalColumn: util.getArg(aArgs, 'column', 0)\n    };\n\n    if (this.sourceRoot != null) {\n      needle.source = util.relative(this.sourceRoot, needle.source);\n    }\n    if (!this._sources.has(needle.source)) {\n      return [];\n    }\n    needle.source = this._sources.indexOf(needle.source);\n\n    var mappings = [];\n\n    var index = this._findMapping(needle,\n                                  this._originalMappings,\n                                  \"originalLine\",\n                                  \"originalColumn\",\n                                  util.compareByOriginalPositions,\n                                  binarySearch.LEAST_UPPER_BOUND);\n    if (index >= 0) {\n      var mapping = this._originalMappings[index];\n\n      if (aArgs.column === undefined) {\n        var originalLine = mapping.originalLine;\n\n        // Iterate until either we run out of mappings, or we run into\n        // a mapping for a different line than the one we found. Since\n        // mappings are sorted, this is guaranteed to find all mappings for\n        // the line we found.\n        while (mapping && mapping.originalLine === originalLine) {\n          mappings.push({\n            line: util.getArg(mapping, 'generatedLine', null),\n            column: util.getArg(mapping, 'generatedColumn', null),\n            lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)\n          });\n\n          mapping = this._originalMappings[++index];\n        }\n      } else {\n        var originalColumn = mapping.originalColumn;\n\n        // Iterate until either we run out of mappings, or we run into\n        // a mapping for a different line than the one we were searching for.\n        // Since mappings are sorted, this is guaranteed to find all mappings for\n        // the line we are searching for.\n        while (mapping &&\n               mapping.originalLine === line &&\n               mapping.originalColumn == originalColumn) {\n          mappings.push({\n            line: util.getArg(mapping, 'generatedLine', null),\n            column: util.getArg(mapping, 'generatedColumn', null),\n            lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)\n          });\n\n          mapping = this._originalMappings[++index];\n        }\n      }\n    }\n\n    return mappings;\n  };\n\nexports.SourceMapConsumer = SourceMapConsumer;\n\n/**\n * A BasicSourceMapConsumer instance represents a parsed source map which we can\n * query for information about the original file positions by giving it a file\n * position in the generated source.\n *\n * The only parameter is the raw source map (either as a JSON string, or\n * already parsed to an object). According to the spec, source maps have the\n * following attributes:\n *\n *   - version: Which version of the source map spec this map is following.\n *   - sources: An array of URLs to the original source files.\n *   - names: An array of identifiers which can be referrenced by individual mappings.\n *   - sourceRoot: Optional. The URL root from which all sources are relative.\n *   - sourcesContent: Optional. An array of contents of the original source files.\n *   - mappings: A string of base64 VLQs which contain the actual mappings.\n *   - file: Optional. The generated file this source map is associated with.\n *\n * Here is an example source map, taken from the source map spec[0]:\n *\n *     {\n *       version : 3,\n *       file: \"out.js\",\n *       sourceRoot : \"\",\n *       sources: [\"foo.js\", \"bar.js\"],\n *       names: [\"src\", \"maps\", \"are\", \"fun\"],\n *       mappings: \"AA,AB;;ABCDE;\"\n *     }\n *\n * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit?pli=1#\n */\nfunction BasicSourceMapConsumer(aSourceMap) {\n  var sourceMap = aSourceMap;\n  if (typeof aSourceMap === 'string') {\n    sourceMap = JSON.parse(aSourceMap.replace(/^\\)\\]\\}'/, ''));\n  }\n\n  var version = util.getArg(sourceMap, 'version');\n  var sources = util.getArg(sourceMap, 'sources');\n  // Sass 3.3 leaves out the 'names' array, so we deviate from the spec (which\n  // requires the array) to play nice here.\n  var names = util.getArg(sourceMap, 'names', []);\n  var sourceRoot = util.getArg(sourceMap, 'sourceRoot', null);\n  var sourcesContent = util.getArg(sourceMap, 'sourcesContent', null);\n  var mappings = util.getArg(sourceMap, 'mappings');\n  var file = util.getArg(sourceMap, 'file', null);\n\n  // Once again, Sass deviates from the spec and supplies the version as a\n  // string rather than a number, so we use loose equality checking here.\n  if (version != this._version) {\n    throw new Error('Unsupported version: ' + version);\n  }\n\n  sources = sources\n    .map(String)\n    // Some source maps produce relative source paths like \"./foo.js\" instead of\n    // \"foo.js\".  Normalize these first so that future comparisons will succeed.\n    // See bugzil.la/1090768.\n    .map(util.normalize)\n    // Always ensure that absolute sources are internally stored relative to\n    // the source root, if the source root is absolute. Not doing this would\n    // be particularly problematic when the source root is a prefix of the\n    // source (valid, but why??). See github issue #199 and bugzil.la/1188982.\n    .map(function (source) {\n      return sourceRoot && util.isAbsolute(sourceRoot) && util.isAbsolute(source)\n        ? util.relative(sourceRoot, source)\n        : source;\n    });\n\n  // Pass `true` below to allow duplicate names and sources. While source maps\n  // are intended to be compressed and deduplicated, the TypeScript compiler\n  // sometimes generates source maps with duplicates in them. See Github issue\n  // #72 and bugzil.la/889492.\n  this._names = ArraySet.fromArray(names.map(String), true);\n  this._sources = ArraySet.fromArray(sources, true);\n\n  this.sourceRoot = sourceRoot;\n  this.sourcesContent = sourcesContent;\n  this._mappings = mappings;\n  this.file = file;\n}\n\nBasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);\nBasicSourceMapConsumer.prototype.consumer = SourceMapConsumer;\n\n/**\n * Create a BasicSourceMapConsumer from a SourceMapGenerator.\n *\n * @param SourceMapGenerator aSourceMap\n *        The source map that will be consumed.\n * @returns BasicSourceMapConsumer\n */\nBasicSourceMapConsumer.fromSourceMap =\n  function SourceMapConsumer_fromSourceMap(aSourceMap) {\n    var smc = Object.create(BasicSourceMapConsumer.prototype);\n\n    var names = smc._names = ArraySet.fromArray(aSourceMap._names.toArray(), true);\n    var sources = smc._sources = ArraySet.fromArray(aSourceMap._sources.toArray(), true);\n    smc.sourceRoot = aSourceMap._sourceRoot;\n    smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(),\n                                                            smc.sourceRoot);\n    smc.file = aSourceMap._file;\n\n    // Because we are modifying the entries (by converting string sources and\n    // names to indices into the sources and names ArraySets), we have to make\n    // a copy of the entry or else bad things happen. Shared mutable state\n    // strikes again! See github issue #191.\n\n    var generatedMappings = aSourceMap._mappings.toArray().slice();\n    var destGeneratedMappings = smc.__generatedMappings = [];\n    var destOriginalMappings = smc.__originalMappings = [];\n\n    for (var i = 0, length = generatedMappings.length; i < length; i++) {\n      var srcMapping = generatedMappings[i];\n      var destMapping = new Mapping;\n      destMapping.generatedLine = srcMapping.generatedLine;\n      destMapping.generatedColumn = srcMapping.generatedColumn;\n\n      if (srcMapping.source) {\n        destMapping.source = sources.indexOf(srcMapping.source);\n        destMapping.originalLine = srcMapping.originalLine;\n        destMapping.originalColumn = srcMapping.originalColumn;\n\n        if (srcMapping.name) {\n          destMapping.name = names.indexOf(srcMapping.name);\n        }\n\n        destOriginalMappings.push(destMapping);\n      }\n\n      destGeneratedMappings.push(destMapping);\n    }\n\n    quickSort(smc.__originalMappings, util.compareByOriginalPositions);\n\n    return smc;\n  };\n\n/**\n * The version of the source mapping spec that we are consuming.\n */\nBasicSourceMapConsumer.prototype._version = 3;\n\n/**\n * The list of original sources.\n */\nObject.defineProperty(BasicSourceMapConsumer.prototype, 'sources', {\n  get: function () {\n    return this._sources.toArray().map(function (s) {\n      return this.sourceRoot != null ? util.join(this.sourceRoot, s) : s;\n    }, this);\n  }\n});\n\n/**\n * Provide the JIT with a nice shape / hidden class.\n */\nfunction Mapping() {\n  this.generatedLine = 0;\n  this.generatedColumn = 0;\n  this.source = null;\n  this.originalLine = null;\n  this.originalColumn = null;\n  this.name = null;\n}\n\n/**\n * Parse the mappings in a string in to a data structure which we can easily\n * query (the ordered arrays in the `this.__generatedMappings` and\n * `this.__originalMappings` properties).\n */\nBasicSourceMapConsumer.prototype._parseMappings =\n  function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {\n    var generatedLine = 1;\n    var previousGeneratedColumn = 0;\n    var previousOriginalLine = 0;\n    var previousOriginalColumn = 0;\n    var previousSource = 0;\n    var previousName = 0;\n    var length = aStr.length;\n    var index = 0;\n    var cachedSegments = {};\n    var temp = {};\n    var originalMappings = [];\n    var generatedMappings = [];\n    var mapping, str, segment, end, value;\n\n    while (index < length) {\n      if (aStr.charAt(index) === ';') {\n        generatedLine++;\n        index++;\n        previousGeneratedColumn = 0;\n      }\n      else if (aStr.charAt(index) === ',') {\n        index++;\n      }\n      else {\n        mapping = new Mapping();\n        mapping.generatedLine = generatedLine;\n\n        // Because each offset is encoded relative to the previous one,\n        // many segments often have the same encoding. We can exploit this\n        // fact by caching the parsed variable length fields of each segment,\n        // allowing us to avoid a second parse if we encounter the same\n        // segment again.\n        for (end = index; end < length; end++) {\n          if (this._charIsMappingSeparator(aStr, end)) {\n            break;\n          }\n        }\n        str = aStr.slice(index, end);\n\n        segment = cachedSegments[str];\n        if (segment) {\n          index += str.length;\n        } else {\n          segment = [];\n          while (index < end) {\n            base64VLQ.decode(aStr, index, temp);\n            value = temp.value;\n            index = temp.rest;\n            segment.push(value);\n          }\n\n          if (segment.length === 2) {\n            throw new Error('Found a source, but no line and column');\n          }\n\n          if (segment.length === 3) {\n            throw new Error('Found a source and line, but no column');\n          }\n\n          cachedSegments[str] = segment;\n        }\n\n        // Generated column.\n        mapping.generatedColumn = previousGeneratedColumn + segment[0];\n        previousGeneratedColumn = mapping.generatedColumn;\n\n        if (segment.length > 1) {\n          // Original source.\n          mapping.source = previousSource + segment[1];\n          previousSource += segment[1];\n\n          // Original line.\n          mapping.originalLine = previousOriginalLine + segment[2];\n          previousOriginalLine = mapping.originalLine;\n          // Lines are stored 0-based\n          mapping.originalLine += 1;\n\n          // Original column.\n          mapping.originalColumn = previousOriginalColumn + segment[3];\n          previousOriginalColumn = mapping.originalColumn;\n\n          if (segment.length > 4) {\n            // Original name.\n            mapping.name = previousName + segment[4];\n            previousName += segment[4];\n          }\n        }\n\n        generatedMappings.push(mapping);\n        if (typeof mapping.originalLine === 'number') {\n          originalMappings.push(mapping);\n        }\n      }\n    }\n\n    quickSort(generatedMappings, util.compareByGeneratedPositionsDeflated);\n    this.__generatedMappings = generatedMappings;\n\n    quickSort(originalMappings, util.compareByOriginalPositions);\n    this.__originalMappings = originalMappings;\n  };\n\n/**\n * Find the mapping that best matches the hypothetical \"needle\" mapping that\n * we are searching for in the given \"haystack\" of mappings.\n */\nBasicSourceMapConsumer.prototype._findMapping =\n  function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName,\n                                         aColumnName, aComparator, aBias) {\n    // To return the position we are searching for, we must first find the\n    // mapping for the given position and then return the opposite position it\n    // points to. Because the mappings are sorted, we can use binary search to\n    // find the best mapping.\n\n    if (aNeedle[aLineName] <= 0) {\n      throw new TypeError('Line must be greater than or equal to 1, got '\n                          + aNeedle[aLineName]);\n    }\n    if (aNeedle[aColumnName] < 0) {\n      throw new TypeError('Column must be greater than or equal to 0, got '\n                          + aNeedle[aColumnName]);\n    }\n\n    return binarySearch.search(aNeedle, aMappings, aComparator, aBias);\n  };\n\n/**\n * Compute the last column for each generated mapping. The last column is\n * inclusive.\n */\nBasicSourceMapConsumer.prototype.computeColumnSpans =\n  function SourceMapConsumer_computeColumnSpans() {\n    for (var index = 0; index < this._generatedMappings.length; ++index) {\n      var mapping = this._generatedMappings[index];\n\n      // Mappings do not contain a field for the last generated columnt. We\n      // can come up with an optimistic estimate, however, by assuming that\n      // mappings are contiguous (i.e. given two consecutive mappings, the\n      // first mapping ends where the second one starts).\n      if (index + 1 < this._generatedMappings.length) {\n        var nextMapping = this._generatedMappings[index + 1];\n\n        if (mapping.generatedLine === nextMapping.generatedLine) {\n          mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1;\n          continue;\n        }\n      }\n\n      // The last mapping for each line spans the entire line.\n      mapping.lastGeneratedColumn = Infinity;\n    }\n  };\n\n/**\n * Returns the original source, line, and column information for the generated\n * source's line and column positions provided. The only argument is an object\n * with the following properties:\n *\n *   - line: The line number in the generated source.\n *   - column: The column number in the generated source.\n *   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or\n *     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the\n *     closest element that is smaller than or greater than the one we are\n *     searching for, respectively, if the exact element cannot be found.\n *     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.\n *\n * and an object is returned with the following properties:\n *\n *   - source: The original source file, or null.\n *   - line: The line number in the original source, or null.\n *   - column: The column number in the original source, or null.\n *   - name: The original identifier, or null.\n */\nBasicSourceMapConsumer.prototype.originalPositionFor =\n  function SourceMapConsumer_originalPositionFor(aArgs) {\n    var needle = {\n      generatedLine: util.getArg(aArgs, 'line'),\n      generatedColumn: util.getArg(aArgs, 'column')\n    };\n\n    var index = this._findMapping(\n      needle,\n      this._generatedMappings,\n      \"generatedLine\",\n      \"generatedColumn\",\n      util.compareByGeneratedPositionsDeflated,\n      util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)\n    );\n\n    if (index >= 0) {\n      var mapping = this._generatedMappings[index];\n\n      if (mapping.generatedLine === needle.generatedLine) {\n        var source = util.getArg(mapping, 'source', null);\n        if (source !== null) {\n          source = this._sources.at(source);\n          if (this.sourceRoot != null) {\n            source = util.join(this.sourceRoot, source);\n          }\n        }\n        var name = util.getArg(mapping, 'name', null);\n        if (name !== null) {\n          name = this._names.at(name);\n        }\n        return {\n          source: source,\n          line: util.getArg(mapping, 'originalLine', null),\n          column: util.getArg(mapping, 'originalColumn', null),\n          name: name\n        };\n      }\n    }\n\n    return {\n      source: null,\n      line: null,\n      column: null,\n      name: null\n    };\n  };\n\n/**\n * Return true if we have the source content for every source in the source\n * map, false otherwise.\n */\nBasicSourceMapConsumer.prototype.hasContentsOfAllSources =\n  function BasicSourceMapConsumer_hasContentsOfAllSources() {\n    if (!this.sourcesContent) {\n      return false;\n    }\n    return this.sourcesContent.length >= this._sources.size() &&\n      !this.sourcesContent.some(function (sc) { return sc == null; });\n  };\n\n/**\n * Returns the original source content. The only argument is the url of the\n * original source file. Returns null if no original source content is\n * available.\n */\nBasicSourceMapConsumer.prototype.sourceContentFor =\n  function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {\n    if (!this.sourcesContent) {\n      return null;\n    }\n\n    if (this.sourceRoot != null) {\n      aSource = util.relative(this.sourceRoot, aSource);\n    }\n\n    if (this._sources.has(aSource)) {\n      return this.sourcesContent[this._sources.indexOf(aSource)];\n    }\n\n    var url;\n    if (this.sourceRoot != null\n        && (url = util.urlParse(this.sourceRoot))) {\n      // XXX: file:// URIs and absolute paths lead to unexpected behavior for\n      // many users. We can help them out when they expect file:// URIs to\n      // behave like it would if they were running a local HTTP server. See\n      // https://bugzilla.mozilla.org/show_bug.cgi?id=885597.\n      var fileUriAbsPath = aSource.replace(/^file:\\/\\//, \"\");\n      if (url.scheme == \"file\"\n          && this._sources.has(fileUriAbsPath)) {\n        return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)]\n      }\n\n      if ((!url.path || url.path == \"/\")\n          && this._sources.has(\"/\" + aSource)) {\n        return this.sourcesContent[this._sources.indexOf(\"/\" + aSource)];\n      }\n    }\n\n    // This function is used recursively from\n    // IndexedSourceMapConsumer.prototype.sourceContentFor. In that case, we\n    // don't want to throw if we can't find the source - we just want to\n    // return null, so we provide a flag to exit gracefully.\n    if (nullOnMissing) {\n      return null;\n    }\n    else {\n      throw new Error('\"' + aSource + '\" is not in the SourceMap.');\n    }\n  };\n\n/**\n * Returns the generated line and column information for the original source,\n * line, and column positions provided. The only argument is an object with\n * the following properties:\n *\n *   - source: The filename of the original source.\n *   - line: The line number in the original source.\n *   - column: The column number in the original source.\n *   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or\n *     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the\n *     closest element that is smaller than or greater than the one we are\n *     searching for, respectively, if the exact element cannot be found.\n *     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.\n *\n * and an object is returned with the following properties:\n *\n *   - line: The line number in the generated source, or null.\n *   - column: The column number in the generated source, or null.\n */\nBasicSourceMapConsumer.prototype.generatedPositionFor =\n  function SourceMapConsumer_generatedPositionFor(aArgs) {\n    var source = util.getArg(aArgs, 'source');\n    if (this.sourceRoot != null) {\n      source = util.relative(this.sourceRoot, source);\n    }\n    if (!this._sources.has(source)) {\n      return {\n        line: null,\n        column: null,\n        lastColumn: null\n      };\n    }\n    source = this._sources.indexOf(source);\n\n    var needle = {\n      source: source,\n      originalLine: util.getArg(aArgs, 'line'),\n      originalColumn: util.getArg(aArgs, 'column')\n    };\n\n    var index = this._findMapping(\n      needle,\n      this._originalMappings,\n      \"originalLine\",\n      \"originalColumn\",\n      util.compareByOriginalPositions,\n      util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)\n    );\n\n    if (index >= 0) {\n      var mapping = this._originalMappings[index];\n\n      if (mapping.source === needle.source) {\n        return {\n          line: util.getArg(mapping, 'generatedLine', null),\n          column: util.getArg(mapping, 'generatedColumn', null),\n          lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)\n        };\n      }\n    }\n\n    return {\n      line: null,\n      column: null,\n      lastColumn: null\n    };\n  };\n\nexports.BasicSourceMapConsumer = BasicSourceMapConsumer;\n\n/**\n * An IndexedSourceMapConsumer instance represents a parsed source map which\n * we can query for information. It differs from BasicSourceMapConsumer in\n * that it takes \"indexed\" source maps (i.e. ones with a \"sections\" field) as\n * input.\n *\n * The only parameter is a raw source map (either as a JSON string, or already\n * parsed to an object). According to the spec for indexed source maps, they\n * have the following attributes:\n *\n *   - version: Which version of the source map spec this map is following.\n *   - file: Optional. The generated file this source map is associated with.\n *   - sections: A list of section definitions.\n *\n * Each value under the \"sections\" field has two fields:\n *   - offset: The offset into the original specified at which this section\n *       begins to apply, defined as an object with a \"line\" and \"column\"\n *       field.\n *   - map: A source map definition. This source map could also be indexed,\n *       but doesn't have to be.\n *\n * Instead of the \"map\" field, it's also possible to have a \"url\" field\n * specifying a URL to retrieve a source map from, but that's currently\n * unsupported.\n *\n * Here's an example source map, taken from the source map spec[0], but\n * modified to omit a section which uses the \"url\" field.\n *\n *  {\n *    version : 3,\n *    file: \"app.js\",\n *    sections: [{\n *      offset: {line:100, column:10},\n *      map: {\n *        version : 3,\n *        file: \"section.js\",\n *        sources: [\"foo.js\", \"bar.js\"],\n *        names: [\"src\", \"maps\", \"are\", \"fun\"],\n *        mappings: \"AAAA,E;;ABCDE;\"\n *      }\n *    }],\n *  }\n *\n * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit#heading=h.535es3xeprgt\n */\nfunction IndexedSourceMapConsumer(aSourceMap) {\n  var sourceMap = aSourceMap;\n  if (typeof aSourceMap === 'string') {\n    sourceMap = JSON.parse(aSourceMap.replace(/^\\)\\]\\}'/, ''));\n  }\n\n  var version = util.getArg(sourceMap, 'version');\n  var sections = util.getArg(sourceMap, 'sections');\n\n  if (version != this._version) {\n    throw new Error('Unsupported version: ' + version);\n  }\n\n  this._sources = new ArraySet();\n  this._names = new ArraySet();\n\n  var lastOffset = {\n    line: -1,\n    column: 0\n  };\n  this._sections = sections.map(function (s) {\n    if (s.url) {\n      // The url field will require support for asynchronicity.\n      // See https://github.com/mozilla/source-map/issues/16\n      throw new Error('Support for url field in sections not implemented.');\n    }\n    var offset = util.getArg(s, 'offset');\n    var offsetLine = util.getArg(offset, 'line');\n    var offsetColumn = util.getArg(offset, 'column');\n\n    if (offsetLine < lastOffset.line ||\n        (offsetLine === lastOffset.line && offsetColumn < lastOffset.column)) {\n      throw new Error('Section offsets must be ordered and non-overlapping.');\n    }\n    lastOffset = offset;\n\n    return {\n      generatedOffset: {\n        // The offset fields are 0-based, but we use 1-based indices when\n        // encoding/decoding from VLQ.\n        generatedLine: offsetLine + 1,\n        generatedColumn: offsetColumn + 1\n      },\n      consumer: new SourceMapConsumer(util.getArg(s, 'map'))\n    }\n  });\n}\n\nIndexedSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);\nIndexedSourceMapConsumer.prototype.constructor = SourceMapConsumer;\n\n/**\n * The version of the source mapping spec that we are consuming.\n */\nIndexedSourceMapConsumer.prototype._version = 3;\n\n/**\n * The list of original sources.\n */\nObject.defineProperty(IndexedSourceMapConsumer.prototype, 'sources', {\n  get: function () {\n    var sources = [];\n    for (var i = 0; i < this._sections.length; i++) {\n      for (var j = 0; j < this._sections[i].consumer.sources.length; j++) {\n        sources.push(this._sections[i].consumer.sources[j]);\n      }\n    }\n    return sources;\n  }\n});\n\n/**\n * Returns the original source, line, and column information for the generated\n * source's line and column positions provided. The only argument is an object\n * with the following properties:\n *\n *   - line: The line number in the generated source.\n *   - column: The column number in the generated source.\n *\n * and an object is returned with the following properties:\n *\n *   - source: The original source file, or null.\n *   - line: The line number in the original source, or null.\n *   - column: The column number in the original source, or null.\n *   - name: The original identifier, or null.\n */\nIndexedSourceMapConsumer.prototype.originalPositionFor =\n  function IndexedSourceMapConsumer_originalPositionFor(aArgs) {\n    var needle = {\n      generatedLine: util.getArg(aArgs, 'line'),\n      generatedColumn: util.getArg(aArgs, 'column')\n    };\n\n    // Find the section containing the generated position we're trying to map\n    // to an original position.\n    var sectionIndex = binarySearch.search(needle, this._sections,\n      function(needle, section) {\n        var cmp = needle.generatedLine - section.generatedOffset.generatedLine;\n        if (cmp) {\n          return cmp;\n        }\n\n        return (needle.generatedColumn -\n                section.generatedOffset.generatedColumn);\n      });\n    var section = this._sections[sectionIndex];\n\n    if (!section) {\n      return {\n        source: null,\n        line: null,\n        column: null,\n        name: null\n      };\n    }\n\n    return section.consumer.originalPositionFor({\n      line: needle.generatedLine -\n        (section.generatedOffset.generatedLine - 1),\n      column: needle.generatedColumn -\n        (section.generatedOffset.generatedLine === needle.generatedLine\n         ? section.generatedOffset.generatedColumn - 1\n         : 0),\n      bias: aArgs.bias\n    });\n  };\n\n/**\n * Return true if we have the source content for every source in the source\n * map, false otherwise.\n */\nIndexedSourceMapConsumer.prototype.hasContentsOfAllSources =\n  function IndexedSourceMapConsumer_hasContentsOfAllSources() {\n    return this._sections.every(function (s) {\n      return s.consumer.hasContentsOfAllSources();\n    });\n  };\n\n/**\n * Returns the original source content. The only argument is the url of the\n * original source file. Returns null if no original source content is\n * available.\n */\nIndexedSourceMapConsumer.prototype.sourceContentFor =\n  function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {\n    for (var i = 0; i < this._sections.length; i++) {\n      var section = this._sections[i];\n\n      var content = section.consumer.sourceContentFor(aSource, true);\n      if (content) {\n        return content;\n      }\n    }\n    if (nullOnMissing) {\n      return null;\n    }\n    else {\n      throw new Error('\"' + aSource + '\" is not in the SourceMap.');\n    }\n  };\n\n/**\n * Returns the generated line and column information for the original source,\n * line, and column positions provided. The only argument is an object with\n * the following properties:\n *\n *   - source: The filename of the original source.\n *   - line: The line number in the original source.\n *   - column: The column number in the original source.\n *\n * and an object is returned with the following properties:\n *\n *   - line: The line number in the generated source, or null.\n *   - column: The column number in the generated source, or null.\n */\nIndexedSourceMapConsumer.prototype.generatedPositionFor =\n  function IndexedSourceMapConsumer_generatedPositionFor(aArgs) {\n    for (var i = 0; i < this._sections.length; i++) {\n      var section = this._sections[i];\n\n      // Only consider this section if the requested source is in the list of\n      // sources of the consumer.\n      if (section.consumer.sources.indexOf(util.getArg(aArgs, 'source')) === -1) {\n        continue;\n      }\n      var generatedPosition = section.consumer.generatedPositionFor(aArgs);\n      if (generatedPosition) {\n        var ret = {\n          line: generatedPosition.line +\n            (section.generatedOffset.generatedLine - 1),\n          column: generatedPosition.column +\n            (section.generatedOffset.generatedLine === generatedPosition.line\n             ? section.generatedOffset.generatedColumn - 1\n             : 0)\n        };\n        return ret;\n      }\n    }\n\n    return {\n      line: null,\n      column: null\n    };\n  };\n\n/**\n * Parse the mappings in a string in to a data structure which we can easily\n * query (the ordered arrays in the `this.__generatedMappings` and\n * `this.__originalMappings` properties).\n */\nIndexedSourceMapConsumer.prototype._parseMappings =\n  function IndexedSourceMapConsumer_parseMappings(aStr, aSourceRoot) {\n    this.__generatedMappings = [];\n    this.__originalMappings = [];\n    for (var i = 0; i < this._sections.length; i++) {\n      var section = this._sections[i];\n      var sectionMappings = section.consumer._generatedMappings;\n      for (var j = 0; j < sectionMappings.length; j++) {\n        var mapping = sectionMappings[j];\n\n        var source = section.consumer._sources.at(mapping.source);\n        if (section.consumer.sourceRoot !== null) {\n          source = util.join(section.consumer.sourceRoot, source);\n        }\n        this._sources.add(source);\n        source = this._sources.indexOf(source);\n\n        var name = section.consumer._names.at(mapping.name);\n        this._names.add(name);\n        name = this._names.indexOf(name);\n\n        // The mappings coming from the consumer for the section have\n        // generated positions relative to the start of the section, so we\n        // need to offset them to be relative to the start of the concatenated\n        // generated file.\n        var adjustedMapping = {\n          source: source,\n          generatedLine: mapping.generatedLine +\n            (section.generatedOffset.generatedLine - 1),\n          generatedColumn: mapping.generatedColumn +\n            (section.generatedOffset.generatedLine === mapping.generatedLine\n            ? section.generatedOffset.generatedColumn - 1\n            : 0),\n          originalLine: mapping.originalLine,\n          originalColumn: mapping.originalColumn,\n          name: name\n        };\n\n        this.__generatedMappings.push(adjustedMapping);\n        if (typeof adjustedMapping.originalLine === 'number') {\n          this.__originalMappings.push(adjustedMapping);\n        }\n      }\n    }\n\n    quickSort(this.__generatedMappings, util.compareByGeneratedPositionsDeflated);\n    quickSort(this.__originalMappings, util.compareByOriginalPositions);\n  };\n\nexports.IndexedSourceMapConsumer = IndexedSourceMapConsumer;\n","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nexports.GREATEST_LOWER_BOUND = 1;\nexports.LEAST_UPPER_BOUND = 2;\n\n/**\n * Recursive implementation of binary search.\n *\n * @param aLow Indices here and lower do not contain the needle.\n * @param aHigh Indices here and higher do not contain the needle.\n * @param aNeedle The element being searched for.\n * @param aHaystack The non-empty array being searched.\n * @param aCompare Function which takes two elements and returns -1, 0, or 1.\n * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or\n *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the\n *     closest element that is smaller than or greater than the one we are\n *     searching for, respectively, if the exact element cannot be found.\n */\nfunction recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare, aBias) {\n  // This function terminates when one of the following is true:\n  //\n  //   1. We find the exact element we are looking for.\n  //\n  //   2. We did not find the exact element, but we can return the index of\n  //      the next-closest element.\n  //\n  //   3. We did not find the exact element, and there is no next-closest\n  //      element than the one we are searching for, so we return -1.\n  var mid = Math.floor((aHigh - aLow) / 2) + aLow;\n  var cmp = aCompare(aNeedle, aHaystack[mid], true);\n  if (cmp === 0) {\n    // Found the element we are looking for.\n    return mid;\n  }\n  else if (cmp > 0) {\n    // Our needle is greater than aHaystack[mid].\n    if (aHigh - mid > 1) {\n      // The element is in the upper half.\n      return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias);\n    }\n\n    // The exact needle element was not found in this haystack. Determine if\n    // we are in termination case (3) or (2) and return the appropriate thing.\n    if (aBias == exports.LEAST_UPPER_BOUND) {\n      return aHigh < aHaystack.length ? aHigh : -1;\n    } else {\n      return mid;\n    }\n  }\n  else {\n    // Our needle is less than aHaystack[mid].\n    if (mid - aLow > 1) {\n      // The element is in the lower half.\n      return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias);\n    }\n\n    // we are in termination case (3) or (2) and return the appropriate thing.\n    if (aBias == exports.LEAST_UPPER_BOUND) {\n      return mid;\n    } else {\n      return aLow < 0 ? -1 : aLow;\n    }\n  }\n}\n\n/**\n * This is an implementation of binary search which will always try and return\n * the index of the closest element if there is no exact hit. This is because\n * mappings between original and generated line/col pairs are single points,\n * and there is an implicit region between each of them, so a miss just means\n * that you aren't on the very start of a region.\n *\n * @param aNeedle The element you are looking for.\n * @param aHaystack The array that is being searched.\n * @param aCompare A function which takes the needle and an element in the\n *     array and returns -1, 0, or 1 depending on whether the needle is less\n *     than, equal to, or greater than the element, respectively.\n * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or\n *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the\n *     closest element that is smaller than or greater than the one we are\n *     searching for, respectively, if the exact element cannot be found.\n *     Defaults to 'binarySearch.GREATEST_LOWER_BOUND'.\n */\nexports.search = function search(aNeedle, aHaystack, aCompare, aBias) {\n  if (aHaystack.length === 0) {\n    return -1;\n  }\n\n  var index = recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack,\n                              aCompare, aBias || exports.GREATEST_LOWER_BOUND);\n  if (index < 0) {\n    return -1;\n  }\n\n  // We have found either the exact element, or the next-closest element than\n  // the one we are searching for. However, there may be more than one such\n  // element. Make sure we always return the smallest of these.\n  while (index - 1 >= 0) {\n    if (aCompare(aHaystack[index], aHaystack[index - 1], true) !== 0) {\n      break;\n    }\n    --index;\n  }\n\n  return index;\n};\n","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\n// It turns out that some (most?) JavaScript engines don't self-host\n// `Array.prototype.sort`. This makes sense because C++ will likely remain\n// faster than JS when doing raw CPU-intensive sorting. However, when using a\n// custom comparator function, calling back and forth between the VM's C++ and\n// JIT'd JS is rather slow *and* loses JIT type information, resulting in\n// worse generated code for the comparator function than would be optimal. In\n// fact, when sorting with a comparator, these costs outweigh the benefits of\n// sorting in C++. By using our own JS-implemented Quick Sort (below), we get\n// a ~3500ms mean speed-up in `bench/bench.html`.\n\n/**\n * Swap the elements indexed by `x` and `y` in the array `ary`.\n *\n * @param {Array} ary\n *        The array.\n * @param {Number} x\n *        The index of the first item.\n * @param {Number} y\n *        The index of the second item.\n */\nfunction swap(ary, x, y) {\n  var temp = ary[x];\n  ary[x] = ary[y];\n  ary[y] = temp;\n}\n\n/**\n * Returns a random integer within the range `low .. high` inclusive.\n *\n * @param {Number} low\n *        The lower bound on the range.\n * @param {Number} high\n *        The upper bound on the range.\n */\nfunction randomIntInRange(low, high) {\n  return Math.round(low + (Math.random() * (high - low)));\n}\n\n/**\n * The Quick Sort algorithm.\n *\n * @param {Array} ary\n *        An array to sort.\n * @param {function} comparator\n *        Function to use to compare two items.\n * @param {Number} p\n *        Start index of the array\n * @param {Number} r\n *        End index of the array\n */\nfunction doQuickSort(ary, comparator, p, r) {\n  // If our lower bound is less than our upper bound, we (1) partition the\n  // array into two pieces and (2) recurse on each half. If it is not, this is\n  // the empty array and our base case.\n\n  if (p < r) {\n    // (1) Partitioning.\n    //\n    // The partitioning chooses a pivot between `p` and `r` and moves all\n    // elements that are less than or equal to the pivot to the before it, and\n    // all the elements that are greater than it after it. The effect is that\n    // once partition is done, the pivot is in the exact place it will be when\n    // the array is put in sorted order, and it will not need to be moved\n    // again. This runs in O(n) time.\n\n    // Always choose a random pivot so that an input array which is reverse\n    // sorted does not cause O(n^2) running time.\n    var pivotIndex = randomIntInRange(p, r);\n    var i = p - 1;\n\n    swap(ary, pivotIndex, r);\n    var pivot = ary[r];\n\n    // Immediately after `j` is incremented in this loop, the following hold\n    // true:\n    //\n    //   * Every element in `ary[p .. i]` is less than or equal to the pivot.\n    //\n    //   * Every element in `ary[i+1 .. j-1]` is greater than the pivot.\n    for (var j = p; j < r; j++) {\n      if (comparator(ary[j], pivot) <= 0) {\n        i += 1;\n        swap(ary, i, j);\n      }\n    }\n\n    swap(ary, i + 1, j);\n    var q = i + 1;\n\n    // (2) Recurse on each half.\n\n    doQuickSort(ary, comparator, p, q - 1);\n    doQuickSort(ary, comparator, q + 1, r);\n  }\n}\n\n/**\n * Sort the given array in-place with the given comparator function.\n *\n * @param {Array} ary\n *        An array to sort.\n * @param {function} comparator\n *        Function to use to compare two items.\n */\nexports.quickSort = function (ary, comparator) {\n  doQuickSort(ary, comparator, 0, ary.length - 1);\n};\n","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar SourceMapGenerator = require('./source-map-generator').SourceMapGenerator;\nvar util = require('./util');\n\n// Matches a Windows-style `\\r\\n` newline or a `\\n` newline used by all other\n// operating systems these days (capturing the result).\nvar REGEX_NEWLINE = /(\\r?\\n)/;\n\n// Newline character code for charCodeAt() comparisons\nvar NEWLINE_CODE = 10;\n\n// Private symbol for identifying `SourceNode`s when multiple versions of\n// the source-map library are loaded. This MUST NOT CHANGE across\n// versions!\nvar isSourceNode = \"$$$isSourceNode$$$\";\n\n/**\n * SourceNodes provide a way to abstract over interpolating/concatenating\n * snippets of generated JavaScript source code while maintaining the line and\n * column information associated with the original source code.\n *\n * @param aLine The original line number.\n * @param aColumn The original column number.\n * @param aSource The original source's filename.\n * @param aChunks Optional. An array of strings which are snippets of\n *        generated JS, or other SourceNodes.\n * @param aName The original identifier.\n */\nfunction SourceNode(aLine, aColumn, aSource, aChunks, aName) {\n  this.children = [];\n  this.sourceContents = {};\n  this.line = aLine == null ? null : aLine;\n  this.column = aColumn == null ? null : aColumn;\n  this.source = aSource == null ? null : aSource;\n  this.name = aName == null ? null : aName;\n  this[isSourceNode] = true;\n  if (aChunks != null) this.add(aChunks);\n}\n\n/**\n * Creates a SourceNode from generated code and a SourceMapConsumer.\n *\n * @param aGeneratedCode The generated code\n * @param aSourceMapConsumer The SourceMap for the generated code\n * @param aRelativePath Optional. The path that relative sources in the\n *        SourceMapConsumer should be relative to.\n */\nSourceNode.fromStringWithSourceMap =\n  function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {\n    // The SourceNode we want to fill with the generated code\n    // and the SourceMap\n    var node = new SourceNode();\n\n    // All even indices of this array are one line of the generated code,\n    // while all odd indices are the newlines between two adjacent lines\n    // (since `REGEX_NEWLINE` captures its match).\n    // Processed fragments are removed from this array, by calling `shiftNextLine`.\n    var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);\n    var shiftNextLine = function() {\n      var lineContents = remainingLines.shift();\n      // The last line of a file might not have a newline.\n      var newLine = remainingLines.shift() || \"\";\n      return lineContents + newLine;\n    };\n\n    // We need to remember the position of \"remainingLines\"\n    var lastGeneratedLine = 1, lastGeneratedColumn = 0;\n\n    // The generate SourceNodes we need a code range.\n    // To extract it current and last mapping is used.\n    // Here we store the last mapping.\n    var lastMapping = null;\n\n    aSourceMapConsumer.eachMapping(function (mapping) {\n      if (lastMapping !== null) {\n        // We add the code from \"lastMapping\" to \"mapping\":\n        // First check if there is a new line in between.\n        if (lastGeneratedLine < mapping.generatedLine) {\n          // Associate first line with \"lastMapping\"\n          addMappingWithCode(lastMapping, shiftNextLine());\n          lastGeneratedLine++;\n          lastGeneratedColumn = 0;\n          // The remaining code is added without mapping\n        } else {\n          // There is no new line in between.\n          // Associate the code between \"lastGeneratedColumn\" and\n          // \"mapping.generatedColumn\" with \"lastMapping\"\n          var nextLine = remainingLines[0];\n          var code = nextLine.substr(0, mapping.generatedColumn -\n                                        lastGeneratedColumn);\n          remainingLines[0] = nextLine.substr(mapping.generatedColumn -\n                                              lastGeneratedColumn);\n          lastGeneratedColumn = mapping.generatedColumn;\n          addMappingWithCode(lastMapping, code);\n          // No more remaining code, continue\n          lastMapping = mapping;\n          return;\n        }\n      }\n      // We add the generated code until the first mapping\n      // to the SourceNode without any mapping.\n      // Each line is added as separate string.\n      while (lastGeneratedLine < mapping.generatedLine) {\n        node.add(shiftNextLine());\n        lastGeneratedLine++;\n      }\n      if (lastGeneratedColumn < mapping.generatedColumn) {\n        var nextLine = remainingLines[0];\n        node.add(nextLine.substr(0, mapping.generatedColumn));\n        remainingLines[0] = nextLine.substr(mapping.generatedColumn);\n        lastGeneratedColumn = mapping.generatedColumn;\n      }\n      lastMapping = mapping;\n    }, this);\n    // We have processed all mappings.\n    if (remainingLines.length > 0) {\n      if (lastMapping) {\n        // Associate the remaining code in the current line with \"lastMapping\"\n        addMappingWithCode(lastMapping, shiftNextLine());\n      }\n      // and add the remaining lines without any mapping\n      node.add(remainingLines.join(\"\"));\n    }\n\n    // Copy sourcesContent into SourceNode\n    aSourceMapConsumer.sources.forEach(function (sourceFile) {\n      var content = aSourceMapConsumer.sourceContentFor(sourceFile);\n      if (content != null) {\n        if (aRelativePath != null) {\n          sourceFile = util.join(aRelativePath, sourceFile);\n        }\n        node.setSourceContent(sourceFile, content);\n      }\n    });\n\n    return node;\n\n    function addMappingWithCode(mapping, code) {\n      if (mapping === null || mapping.source === undefined) {\n        node.add(code);\n      } else {\n        var source = aRelativePath\n          ? util.join(aRelativePath, mapping.source)\n          : mapping.source;\n        node.add(new SourceNode(mapping.originalLine,\n                                mapping.originalColumn,\n                                source,\n                                code,\n                                mapping.name));\n      }\n    }\n  };\n\n/**\n * Add a chunk of generated JS to this source node.\n *\n * @param aChunk A string snippet of generated JS code, another instance of\n *        SourceNode, or an array where each member is one of those things.\n */\nSourceNode.prototype.add = function SourceNode_add(aChunk) {\n  if (Array.isArray(aChunk)) {\n    aChunk.forEach(function (chunk) {\n      this.add(chunk);\n    }, this);\n  }\n  else if (aChunk[isSourceNode] || typeof aChunk === \"string\") {\n    if (aChunk) {\n      this.children.push(aChunk);\n    }\n  }\n  else {\n    throw new TypeError(\n      \"Expected a SourceNode, string, or an array of SourceNodes and strings. Got \" + aChunk\n    );\n  }\n  return this;\n};\n\n/**\n * Add a chunk of generated JS to the beginning of this source node.\n *\n * @param aChunk A string snippet of generated JS code, another instance of\n *        SourceNode, or an array where each member is one of those things.\n */\nSourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {\n  if (Array.isArray(aChunk)) {\n    for (var i = aChunk.length-1; i >= 0; i--) {\n      this.prepend(aChunk[i]);\n    }\n  }\n  else if (aChunk[isSourceNode] || typeof aChunk === \"string\") {\n    this.children.unshift(aChunk);\n  }\n  else {\n    throw new TypeError(\n      \"Expected a SourceNode, string, or an array of SourceNodes and strings. Got \" + aChunk\n    );\n  }\n  return this;\n};\n\n/**\n * Walk over the tree of JS snippets in this node and its children. The\n * walking function is called once for each snippet of JS and is passed that\n * snippet and the its original associated source's line/column location.\n *\n * @param aFn The traversal function.\n */\nSourceNode.prototype.walk = function SourceNode_walk(aFn) {\n  var chunk;\n  for (var i = 0, len = this.children.length; i < len; i++) {\n    chunk = this.children[i];\n    if (chunk[isSourceNode]) {\n      chunk.walk(aFn);\n    }\n    else {\n      if (chunk !== '') {\n        aFn(chunk, { source: this.source,\n                     line: this.line,\n                     column: this.column,\n                     name: this.name });\n      }\n    }\n  }\n};\n\n/**\n * Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between\n * each of `this.children`.\n *\n * @param aSep The separator.\n */\nSourceNode.prototype.join = function SourceNode_join(aSep) {\n  var newChildren;\n  var i;\n  var len = this.children.length;\n  if (len > 0) {\n    newChildren = [];\n    for (i = 0; i < len-1; i++) {\n      newChildren.push(this.children[i]);\n      newChildren.push(aSep);\n    }\n    newChildren.push(this.children[i]);\n    this.children = newChildren;\n  }\n  return this;\n};\n\n/**\n * Call String.prototype.replace on the very right-most source snippet. Useful\n * for trimming whitespace from the end of a source node, etc.\n *\n * @param aPattern The pattern to replace.\n * @param aReplacement The thing to replace the pattern with.\n */\nSourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {\n  var lastChild = this.children[this.children.length - 1];\n  if (lastChild[isSourceNode]) {\n    lastChild.replaceRight(aPattern, aReplacement);\n  }\n  else if (typeof lastChild === 'string') {\n    this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);\n  }\n  else {\n    this.children.push(''.replace(aPattern, aReplacement));\n  }\n  return this;\n};\n\n/**\n * Set the source content for a source file. This will be added to the SourceMapGenerator\n * in the sourcesContent field.\n *\n * @param aSourceFile The filename of the source file\n * @param aSourceContent The content of the source file\n */\nSourceNode.prototype.setSourceContent =\n  function SourceNode_setSourceContent(aSourceFile, aSourceContent) {\n    this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;\n  };\n\n/**\n * Walk over the tree of SourceNodes. The walking function is called for each\n * source file content and is passed the filename and source content.\n *\n * @param aFn The traversal function.\n */\nSourceNode.prototype.walkSourceContents =\n  function SourceNode_walkSourceContents(aFn) {\n    for (var i = 0, len = this.children.length; i < len; i++) {\n      if (this.children[i][isSourceNode]) {\n        this.children[i].walkSourceContents(aFn);\n      }\n    }\n\n    var sources = Object.keys(this.sourceContents);\n    for (var i = 0, len = sources.length; i < len; i++) {\n      aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);\n    }\n  };\n\n/**\n * Return the string representation of this source node. Walks over the tree\n * and concatenates all the various snippets together to one string.\n */\nSourceNode.prototype.toString = function SourceNode_toString() {\n  var str = \"\";\n  this.walk(function (chunk) {\n    str += chunk;\n  });\n  return str;\n};\n\n/**\n * Returns the string representation of this source node along with a source\n * map.\n */\nSourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {\n  var generated = {\n    code: \"\",\n    line: 1,\n    column: 0\n  };\n  var map = new SourceMapGenerator(aArgs);\n  var sourceMappingActive = false;\n  var lastOriginalSource = null;\n  var lastOriginalLine = null;\n  var lastOriginalColumn = null;\n  var lastOriginalName = null;\n  this.walk(function (chunk, original) {\n    generated.code += chunk;\n    if (original.source !== null\n        && original.line !== null\n        && original.column !== null) {\n      if(lastOriginalSource !== original.source\n         || lastOriginalLine !== original.line\n         || lastOriginalColumn !== original.column\n         || lastOriginalName !== original.name) {\n        map.addMapping({\n          source: original.source,\n          original: {\n            line: original.line,\n            column: original.column\n          },\n          generated: {\n            line: generated.line,\n            column: generated.column\n          },\n          name: original.name\n        });\n      }\n      lastOriginalSource = original.source;\n      lastOriginalLine = original.line;\n      lastOriginalColumn = original.column;\n      lastOriginalName = original.name;\n      sourceMappingActive = true;\n    } else if (sourceMappingActive) {\n      map.addMapping({\n        generated: {\n          line: generated.line,\n          column: generated.column\n        }\n      });\n      lastOriginalSource = null;\n      sourceMappingActive = false;\n    }\n    for (var idx = 0, length = chunk.length; idx < length; idx++) {\n      if (chunk.charCodeAt(idx) === NEWLINE_CODE) {\n        generated.line++;\n        generated.column = 0;\n        // Mappings end at eol\n        if (idx + 1 === length) {\n          lastOriginalSource = null;\n          sourceMappingActive = false;\n        } else if (sourceMappingActive) {\n          map.addMapping({\n            source: original.source,\n            original: {\n              line: original.line,\n              column: original.column\n            },\n            generated: {\n              line: generated.line,\n              column: generated.column\n            },\n            name: original.name\n          });\n        }\n      } else {\n        generated.column++;\n      }\n    }\n  });\n  this.walkSourceContents(function (sourceFile, sourceContent) {\n    map.setSourceContent(sourceFile, sourceContent);\n  });\n\n  return { code: generated.code, map: map };\n};\n\nexports.SourceNode = SourceNode;\n"],"sourceRoot":""}