{"version":3,"sources":["webpack:///./node_modules/redbox-react/lib/style.js","webpack:///./node_modules/stackframe/stackframe.js","webpack:///./node_modules/@babel/runtime/helpers/slicedToArray.js","webpack:///./node_modules/error-stack-parser/error-stack-parser.js","webpack:///./node_modules/redbox-react/lib/index.js","webpack:///./node_modules/sourcemapped-stacktrace/dist/sourcemapped-stacktrace.js","webpack:///./node_modules/@babel/runtime/helpers/arrayLikeToArray.js","webpack:///./node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js","webpack:///./node_modules/@babel/runtime/helpers/iterableToArrayLimit.js","webpack:///./node_modules/redbox-react/lib/lib.js","webpack:///./node_modules/@babel/runtime/helpers/arrayWithHoles.js","webpack:///./node_modules/@babel/runtime/helpers/nonIterableRest.js"],"names":["Object","defineProperty","exports","value","default","redbox","boxSizing","fontFamily","position","padding","top","left","bottom","right","width","background","color","zIndex","textAlign","fontSize","lineHeight","overflow","message","fontWeight","stack","marginTop","frame","file","linkToFile","textDecoration","__WEBPACK_AMD_DEFINE_FACTORY__","__WEBPACK_AMD_DEFINE_ARRAY__","__WEBPACK_AMD_DEFINE_RESULT__","root","factory","_isNumber","n","isNaN","parseFloat","isFinite","StackFrame","functionName","args","fileName","lineNumber","columnNumber","source","undefined","this","setFunctionName","setArgs","setFileName","setLineNumber","setColumnNumber","setSource","prototype","getFunctionName","v","String","getArgs","toString","call","TypeError","getFileName","getLineNumber","Number","getColumnNumber","getSource","join","apply","module","arrayWithHoles","__webpack_require__","iterableToArrayLimit","unsupportedIterableToArray","nonIterableRest","arr","i","FIREFOX_SAFARI_STACK_REGEXP","CHROME_IE_STACK_REGEXP","SAFARI_NATIVE_CODE_REGEXP","_map","array","fn","thisArg","Array","map","output","length","_filter","filter","push","parse","error","stacktrace","parseOpera","match","parseV8OrIE","parseFFOrSafari","Error","extractLocation","urlLike","indexOf","parts","exec","replace","filtered","split","line","tokens","slice","locationParts","pop","target","_indexOf","e","parseOpera9","parseOpera11","parseOpera10","lineRE","lines","result","len","argsRaw","functionCall","shift","__RewireAPI__","__ResetDependency__","__set__","__Rewire__","__GetDependency__","__get__","RedBoxError","_typeof","Symbol","iterator","obj","constructor","_slicedToArray","isArray","_arr","_n","_d","_e","_s","_i","next","done","err","sliceIterator","_createClass","defineProperties","props","descriptor","enumerable","configurable","writable","key","Constructor","protoProps","staticProps","_propTypes","_propTypes2","_interopRequireDefault","_react","_react2","_reactDom","_reactDom2","_style","_style2","_errorStackParser","_errorStackParser2","_objectAssign","_objectAssign2","_lib","_sourcemappedStacktrace","__esModule","_classCallCheck","instance","_possibleConstructorReturn","self","ReferenceError","_inherits","subClass","superClass","create","setPrototypeOf","__proto__","_get__2","_this","getPrototypeOf","state","mapped","mapOnConstruction","mapError","stackLines","isWebpackEval","search","isEval","fixedLines","_iteratorNormalCompletion","_didIteratorError","_iteratorError","_step","_iterator","stackLine","evalStackLine","_evalStackLine","atSomething","rowColumn","return","_this2","_get__","mappedStack","setState","frames","_props","filename","editorScheme","useLines","useColumns","_get__3","style","f","index","text","url","columns","createElement","href","className","_get__4","parseError","renderFrames","name","propTypes","instanceOf","isRequired","string","bool","object","displayName","defaultProps","RedBox","_get__5","arguments","el","document","body","appendChild","renderRedBoxError","unmountComponentAtNode","removeChild","render","_RewiredData__","INTENTIONAL_UNDEFINED","_RewireAPI__","variableName","mapStackTrace","isFilenameAbsolute","makeUrl","makeLinkText","Component","_get_original__","_set__","_reset__","keys","forEach","_with__","rewiredVariableNames","previousValues","reset","callback","then","catch","addPropertyToAPIObject","_typeOfOriginalExport","addNonEnumerableProperty","isExtensible","modules","installedModules","moduleId","id","loaded","m","c","p","source_map_consumer","global_mapForUri","isChromeOrEdge","navigator","userAgent","toLowerCase","isFirefox","isSafari","isIE11Plus","documentMode","Fetcher","opts","sem","mapForUri","cacheGlobally","fetchScript","uri","xhr","createXMLHTTPObject","that","onreadystatechange","onScriptLoad","open","send","absUrlRegex","RegExp","readyState","status","responseText","mapUri","embeddedSourceMap","SourceMapConsumer","atob","test","origin","lastSlash","lastIndexOf","xhrMap","processSourceMaps","rows","row","parseInt","column","origPos","originalPositionFor","formatOriginalPosition","origName","origLine","XMLHttpFactories","XMLHttpRequest","ActiveXObject","xmlhttp","fields","expected_fields","regex","skip_lines","fetcher","util","binarySearch","ArraySet","base64VLQ","quickSort","aSourceMap","sourceMap","JSON","sections","IndexedSourceMapConsumer","BasicSourceMapConsumer","version","getArg","sources","names","sourceRoot","sourcesContent","mappings","_version","normalize","isAbsolute","relative","_names","fromArray","_sources","_mappings","Mapping","generatedLine","generatedColumn","originalLine","originalColumn","lastOffset","_sections","s","offset","offsetLine","offsetColumn","generatedOffset","consumer","fromSourceMap","__generatedMappings","get","_parseMappings","__originalMappings","_charIsMappingSeparator","aStr","charAt","aSourceRoot","GENERATED_ORDER","ORIGINAL_ORDER","GREATEST_LOWER_BOUND","LEAST_UPPER_BOUND","eachMapping","aCallback","aContext","aOrder","context","order","_generatedMappings","_originalMappings","mapping","at","allGeneratedPositionsFor","aArgs","needle","has","_findMapping","compareByOriginalPositions","lastColumn","smc","toArray","_sourceRoot","_generateSourcesContent","_file","generatedMappings","destGeneratedMappings","destOriginalMappings","srcMapping","destMapping","str","segment","end","previousGeneratedColumn","previousOriginalLine","previousOriginalColumn","previousSource","previousName","cachedSegments","temp","originalMappings","decode","rest","compareByGeneratedPositionsDeflated","aNeedle","aMappings","aLineName","aColumnName","aComparator","aBias","computeColumnSpans","nextMapping","lastGeneratedColumn","Infinity","hasContentsOfAllSources","size","some","sc","sourceContentFor","aSource","nullOnMissing","urlParse","fileUriAbsPath","scheme","path","generatedPositionFor","j","sectionIndex","section","cmp","bias","every","content","generatedPosition","ret","sectionMappings","add","adjustedMapping","aName","aDefaultValue","urlRegexp","dataUrlRegexp","aUrl","auth","host","port","urlGenerate","aParsedUrl","aPath","part","up","splice","aRoot","aPathUrl","aRootUrl","joined","level","substr","supportsNullProto","identity","isProtoString","charCodeAt","strcmp","aStr1","aStr2","toSetString","fromSetString","mappingA","mappingB","onlyCompareOriginal","onlyCompareGenerated","compareByGeneratedPositionsInflated","aHaystack","aCompare","recursiveSearch","aLow","aHigh","mid","Math","floor","hasOwnProperty","_array","_set","aArray","aAllowDuplicates","set","getOwnPropertyNames","sStr","isDuplicate","idx","aIdx","base64","encode","aValue","digit","encoded","vlq","toVLQSigned","VLQ_BASE","aIndex","aOutParam","continuation","isNegative","shifted","strLen","intToCharMap","number","charCode","swap","ary","x","y","doQuickSort","comparator","r","pivotIndex","low","high","round","random","pivot","q","arr2","arrayLikeToArray","o","minLen","from","filenameWithoutLoaders","filenameHasSchema","filenameHasLoaders","actualFilename"],"mappings":";6FAEAA,OAAAC,eAAAC,EAAA,cACAC,OAAA,IAwCAD,EAAAE,SArCAC,QACAC,UAAA,aACAC,WAAA,aACAC,SAAA,QACAC,QAAA,GACAC,IAAA,MACAC,KAAA,MACAC,OAAA,MACAC,MAAA,MACAC,MAAA,OACAC,WAAA,iBACAC,MAAA,QACAC,OAAA,WACAC,UAAA,OACAC,SAAA,OACAC,WAAA,IACAC,SAAA,QAEAC,SACAC,WAAA,QAEAC,OACAjB,WAAA,YACAkB,UAAA,OAEAC,OACAD,UAAA,OAEAE,MACAR,SAAA,QACAH,MAAA,4BAEAY,YACAC,eAAA,OACAb,MAAA,qDCxCA,IAAAc,EAAAC,EAAAC,GAAA,SAAAC,EAAAC,GACA,aAKQH,KAAuBD,EAM9B,WAED,SAAAK,EAAAC,GACA,OAAAC,MAAAC,WAAAF,KAAAG,SAAAH,GAGA,SAAAI,EAAAC,EAAAC,EAAAC,EAAAC,EAAAC,EAAAC,QACAC,IAAAN,GACAO,KAAAC,gBAAAR,QAEAM,IAAAL,GACAM,KAAAE,QAAAR,QAEAK,IAAAJ,GACAK,KAAAG,YAAAR,QAEAI,IAAAH,GACAI,KAAAI,cAAAR,QAEAG,IAAAF,GACAG,KAAAK,gBAAAR,QAEAE,IAAAD,GACAE,KAAAM,UAAAR,GAsEA,OAlEAN,EAAAe,WACAC,gBAAA,WACA,OAAAR,KAAAP,cAEAQ,gBAAA,SAAAQ,GACAT,KAAAP,aAAAiB,OAAAD,IAGAE,QAAA,WACA,OAAAX,KAAAN,MAEAQ,QAAA,SAAAO,GACA,sBAAAzD,OAAAuD,UAAAK,SAAAC,KAAAJ,GACA,UAAAK,UAAA,yBAEAd,KAAAN,KAAAe,GAOAM,YAAA,WACA,OAAAf,KAAAL,UAEAQ,YAAA,SAAAM,GACAT,KAAAL,SAAAe,OAAAD,IAGAO,cAAA,WACA,OAAAhB,KAAAJ,YAEAQ,cAAA,SAAAK,GACA,IAAAtB,EAAAsB,GACA,UAAAK,UAAA,gCAEAd,KAAAJ,WAAAqB,OAAAR,IAGAS,gBAAA,WACA,OAAAlB,KAAAH,cAEAQ,gBAAA,SAAAI,GACA,IAAAtB,EAAAsB,GACA,UAAAK,UAAA,kCAEAd,KAAAH,aAAAoB,OAAAR,IAGAU,UAAA,WACA,OAAAnB,KAAAF,QAEAQ,UAAA,SAAAG,GACAT,KAAAF,OAAAY,OAAAD,IAGAG,SAAA,WACA,IAAAnB,EAAAO,KAAAQ,mBAAA,cACAd,EAAA,KAAAM,KAAAW,eAAAS,KAAA,SACAzB,EAAAK,KAAAe,cAAA,IAAAf,KAAAe,cAAA,GACAnB,EAAAT,EAAAa,KAAAgB,iBAAA,IAAAhB,KAAAgB,gBAAA,GACAnB,EAAAV,EAAAa,KAAAkB,mBAAA,IAAAlB,KAAAkB,kBAAA,GACA,OAAAzB,EAAAC,EAAAC,EAAAC,EAAAC,IAIAL,GAnGwCR,EAAA,mBAAAF,IAAAuC,MAAAnE,EAAA6B,GAAAD,OAAAiB,IAAAf,IAAAsC,EAAApE,QAAA8B,GANxC,yBCAA,IAAAuC,EAAqBC,EAAQ,QAE7BC,EAA2BD,EAAQ,QAEnCE,EAAiCF,EAAQ,QAEzCG,EAAsBH,EAAQ,QAM9BF,EAAApE,QAJA,SAAA0E,EAAAC,GACA,OAAAN,EAAAK,IAAAH,EAAAG,EAAAC,IAAAH,EAAAE,EAAAC,IAAAF,2BCTA,IAAA7C,EAAAC,EAAAC,GAAA,SAAAC,EAAAC,GACA,aAKQH,GAA8ByC,EAAA,SAAa1C,EAMlD,SAAAU,GAGD,IAAAsC,EAAA,gBACAC,EAAA,kCACAC,EAAA,+BAEA,SAAAC,EAAAC,EAAAC,EAAAC,GACA,sBAAAC,MAAA9B,UAAA+B,IACA,OAAAJ,EAAAI,IAAAH,EAAAC,GAGA,IADA,IAAAG,EAAA,IAAAF,MAAAH,EAAAM,QACAX,EAAA,EAA2BA,EAAAK,EAAAM,OAAkBX,IAC7CU,EAAAV,GAAAM,EAAAtB,KAAAuB,EAAAF,EAAAL,IAEA,OAAAU,EAIA,SAAAE,EAAAP,EAAAC,EAAAC,GACA,sBAAAC,MAAA9B,UAAAmC,OACA,OAAAR,EAAAQ,OAAAP,EAAAC,GAGA,IADA,IAAAG,KACAV,EAAA,EAA2BA,EAAAK,EAAAM,OAAkBX,IAC7CM,EAAAtB,KAAAuB,EAAAF,EAAAL,KACAU,EAAAI,KAAAT,EAAAL,IAGA,OAAAU,EAiBA,OAOAK,MAAA,SAAAC,GACA,YAAAA,EAAAC,iBAAA,IAAAD,EAAA,mBACA,OAAA7C,KAAA+C,WAAAF,GACa,GAAAA,EAAArE,OAAAqE,EAAArE,MAAAwE,MAAAjB,GACb,OAAA/B,KAAAiD,YAAAJ,GACa,GAAAA,EAAArE,MACb,OAAAwB,KAAAkD,gBAAAL,GAEA,UAAAM,MAAA,oCAKAC,gBAAA,SAAAC,GAEA,QAAAA,EAAAC,QAAA,KACA,OAAAD,GAGA,IACAE,EADA,iCACAC,KAAAH,EAAAI,QAAA,eACA,OAAAF,EAAA,GAAAA,EAAA,SAAAxD,EAAAwD,EAAA,SAAAxD,IAGAkD,YAAA,SAAAJ,GACA,IAAAa,EAAAjB,EAAAI,EAAArE,MAAAmF,MAAA,eAAAC,GACA,QAAAA,EAAAZ,MAAAjB,IACa/B,MAEb,OAAAiC,EAAAyB,EAAA,SAAAE,GACAA,EAAAN,QAAA,eAEAM,IAAAH,QAAA,qBAAAA,QAAA,sCAEA,IAAAI,EAAAD,EAAAH,QAAA,WAAAA,QAAA,oBAAAE,MAAA,OAAAG,MAAA,GACAC,EAAA/D,KAAAoD,gBAAAS,EAAAG,OACAvE,EAAAoE,EAAAzC,KAAA,WAAArB,EACAJ,EAzDA,SAAAuC,EAAA+B,GACA,sBAAA5B,MAAA9B,UAAA+C,QACA,OAAApB,EAAAoB,QAAAW,GAEA,QAAApC,EAAA,EAA2BA,EAAAK,EAAAM,OAAkBX,IAC7C,GAAAK,EAAAL,KAAAoC,EACA,OAAApC,EAGA,SAgDAqC,EAAA,sBAAAH,EAAA,YAAAhE,EAAAgE,EAAA,GAEA,WAAAvE,EAAAC,OAAAM,EAAAJ,EAAAoE,EAAA,GAAAA,EAAA,GAAAH,IACa5D,OAGbkD,gBAAA,SAAAL,GACA,IAAAa,EAAAjB,EAAAI,EAAArE,MAAAmF,MAAA,eAAAC,GACA,OAAAA,EAAAZ,MAAAhB,IACahC,MAEb,OAAAiC,EAAAyB,EAAA,SAAAE,GAMA,GAJAA,EAAAN,QAAA,gBACAM,IAAAH,QAAA,8DAGA,IAAAG,EAAAN,QAAA,WAAAM,EAAAN,QAAA,KAEA,WAAA9D,EAAAoE,GAEA,IAAAC,EAAAD,EAAAD,MAAA,KACAI,EAAA/D,KAAAoD,gBAAAS,EAAAG,OACAvE,EAAAoE,EAAAzC,KAAA,WAAArB,EACA,WAAAP,EAAAC,OACAM,EACAgE,EAAA,GACAA,EAAA,GACAA,EAAA,GACAH,IAEa5D,OAGb+C,WAAA,SAAAoB,GACA,OAAAA,EAAArB,YAAAqB,EAAA7F,QAAAgF,QAAA,UACAa,EAAA7F,QAAAqF,MAAA,MAAAnB,OAAA2B,EAAArB,WAAAa,MAAA,MAAAnB,OACAxC,KAAAoE,YAAAD,GACaA,EAAA3F,MAGbwB,KAAAqE,aAAAF,GAFAnE,KAAAsE,aAAAH,IAMAC,YAAA,SAAAD,GAKA,IAJA,IAAAI,EAAA,oCACAC,EAAAL,EAAA7F,QAAAqF,MAAA,MACAc,KAEA5C,EAAA,EAAA6C,EAAAF,EAAAhC,OAA+CX,EAAA6C,EAAS7C,GAAA,GACxD,IAAAmB,EAAAuB,EAAAf,KAAAgB,EAAA3C,IACAmB,GACAyB,EAAA9B,KAAA,IAAAnD,OAAAO,SAAAiD,EAAA,GAAAA,EAAA,QAAAjD,EAAAyE,EAAA3C,KAIA,OAAA4C,GAGAH,aAAA,SAAAH,GAKA,IAJA,IAAAI,EAAA,6DACAC,EAAAL,EAAArB,WAAAa,MAAA,MACAc,KAEA5C,EAAA,EAAA6C,EAAAF,EAAAhC,OAA+CX,EAAA6C,EAAS7C,GAAA,GACxD,IAAAmB,EAAAuB,EAAAf,KAAAgB,EAAA3C,IACAmB,GACAyB,EAAA9B,KACA,IAAAnD,EACAwD,EAAA,SAAAjD,OACAA,EACAiD,EAAA,GACAA,EAAA,QACAjD,EACAyE,EAAA3C,KAMA,OAAA4C,GAIAJ,aAAA,SAAAxB,GACA,IAAAa,EAAAjB,EAAAI,EAAArE,MAAAmF,MAAA,eAAAC,GACA,QAAAA,EAAAZ,MAAAlB,KAAA8B,EAAAZ,MAAA,sBACahD,MAEb,OAAAiC,EAAAyB,EAAA,SAAAE,GACA,IAMAe,EANAd,EAAAD,EAAAD,MAAA,KACAI,EAAA/D,KAAAoD,gBAAAS,EAAAG,OACAY,EAAAf,EAAAgB,SAAA,GACApF,EAAAmF,EACAnB,QAAA,uCACAA,QAAA,wBAAA1D,EAEA6E,EAAA5B,MAAA,kBACA2B,EAAAC,EAAAnB,QAAA,8BAEA,IAAA/D,OAAAK,IAAA4E,GAAA,8BAAAA,OACA5E,EAAA4E,EAAAhB,MAAA,KACA,WAAAnE,EACAC,EACAC,EACAqE,EAAA,GACAA,EAAA,GACAA,EAAA,GACAH,IACa5D,SA9M+ChB,EAAA,mBAAAF,IAAAuC,MAAAnE,EAAA6B,GAAAD,OAAAiB,IAAAf,IAAAsC,EAAApE,QAAA8B,GAN5D,sCCEAhC,OAAAC,eAAAC,EAAA,cACAC,OAAA,IAEAD,EAAA4H,cAAA5H,EAAA6H,oBAAA7H,EAAA8H,QAAA9H,EAAA+H,WAAA/H,EAAAgI,kBAAAhI,EAAAiI,QAAAjI,EAAAkI,iBAAArF,EAEA,IAAAsF,EAAA,mBAAAC,QAAA,iBAAAA,OAAAC,SAAA,SAAAC,GAAoG,cAAAA,GAAqB,SAAAA,GAAmB,OAAAA,GAAA,mBAAAF,QAAAE,EAAAC,cAAAH,QAAAE,IAAAF,OAAA/E,UAAA,gBAAAiF,GAE5IE,EAAA,WAA4a,gBAAA9D,EAAAC,GAA2B,GAAAQ,MAAAsD,QAAA/D,GAA0B,OAAAA,EAAc,GAAA0D,OAAAC,YAAAvI,OAAA4E,GAA2C,OAAxf,SAAAA,EAAAC,GAAiC,IAAA+D,KAAeC,GAAA,EAAeC,GAAA,EAAgBC,OAAAhG,EAAoB,IAAM,QAAAiG,EAAAC,EAAArE,EAAA0D,OAAAC,cAA0CM,GAAAG,EAAAC,EAAAC,QAAAC,QAA4CP,EAAAjD,KAAAqD,EAAA7I,QAAqB0E,GAAA+D,EAAApD,SAAAX,GAAlCgE,GAAA,IAAyE,MAAAO,GAAcN,GAAA,EAAWC,EAAAK,EAAY,QAAU,KAAMP,GAAAI,EAAA,QAAAA,EAAA,SAA2C,QAAU,GAAAH,EAAA,MAAAC,GAAsB,OAAAH,EAA6HS,CAAAzE,EAAAC,GAAuC,UAAAf,UAAA,yDAAjkB,GAEAwF,EAAA,WAAgC,SAAAC,EAAAtC,EAAAuC,GAA2C,QAAA3E,EAAA,EAAgBA,EAAA2E,EAAAhE,OAAkBX,IAAA,CAAO,IAAA4E,EAAAD,EAAA3E,GAA2B4E,EAAAC,WAAAD,EAAAC,aAAA,EAAwDD,EAAAE,cAAA,EAAgC,UAAAF,MAAAG,UAAA,GAAuD5J,OAAAC,eAAAgH,EAAAwC,EAAAI,IAAAJ,IAA+D,gBAAAK,EAAAC,EAAAC,GAA2L,OAAlID,GAAAR,EAAAO,EAAAvG,UAAAwG,GAAqEC,GAAAT,EAAAO,EAAAE,GAA6DF,GAAxhB,GAEAG,EAAiBzF,EAAQ,QAEzB0F,EAAAC,EAAAF,GAEAG,EAAa5F,EAAQ,QAErB6F,EAAAF,EAAAC,GAEAE,EAAgB9F,EAAQ,QAExB+F,EAAAJ,EAAAG,GAEAE,EAAahG,EAAQ,QAErBiG,EAAAN,EAAAK,GAEAE,EAAwBlG,EAAQ,QAEhCmG,EAAAR,EAAAO,GAEAE,EAAoBpG,EAAQ,QAE5BqG,EAAAV,EAAAS,GAEAE,EAAWtG,EAAQ,QAEnBuG,EAA8BvG,EAAQ,QAEtC,SAAA2F,EAAA3B,GAAsC,OAAAA,KAAAwC,WAAAxC,GAAuCpI,QAAAoI,GAE7E,SAAAyC,EAAAC,EAAApB,GAAiD,KAAAoB,aAAApB,GAA0C,UAAAhG,UAAA,qCAE3F,SAAAqH,EAAAC,EAAAvH,GAAiD,IAAAuH,EAAa,UAAAC,eAAA,6DAAyF,OAAAxH,GAAA,iBAAAA,GAAA,mBAAAA,EAAAuH,EAAAvH,EAEvJ,SAAAyH,EAAAC,EAAAC,GAA0C,sBAAAA,GAAA,OAAAA,EAA+D,UAAA1H,UAAA,kEAAA0H,GAAuGD,EAAAhI,UAAAvD,OAAAyL,OAAAD,KAAAjI,WAAyEkF,aAAetI,MAAAoL,EAAA7B,YAAA,EAAAE,UAAA,EAAAD,cAAA,KAA6E6B,IAAAxL,OAAA0L,eAAA1L,OAAA0L,eAAAH,EAAAC,GAAAD,EAAAI,UAAAH,GAErX,IAAApD,EAAAlI,EAAAkI,YAAA,SAAAwD,GAGA,SAAAxD,EAAAoB,GACAyB,EAAAjI,KAAAoF,GAEA,IAAAyD,EAAAV,EAAAnI,MAAAoF,EAAAuD,WAAA3L,OAAA8L,eAAA1D,IAAAvE,KAAAb,KAAAwG,IAQA,OANAqC,EAAAE,OACAlG,MAAA,KACAmG,QAAA,GAGAH,EAAAI,kBAAAzC,EAAA3D,OACAgG,EAqMA,OAlNAP,EAAAlD,EAAAwD,GAmBAtC,EAAAlB,IACAyB,IAAA,oBACA1J,MAAA,WACA6C,KAAA+I,MAAAC,QAAAhJ,KAAAkJ,SAAAlJ,KAAAwG,MAAA3D,UAOAgE,IAAA,oBACA1J,MAAA,SAAA0F,GACA,IAAAsG,EAAAtG,EAAArE,MAAAmF,MAAA,MAGA,GAAAwF,EAAA3G,OAAA,EACAxC,KAAA+I,OAAsBlG,QAAAmG,QAAA,OADtB,CAMA,IAAAI,GAA+D,IAA/DD,EAAA,GAAAE,OAAA,mBACA,GAAAD,EAEApJ,KAAA+I,OAAsBlG,QAAAmG,QAAA,OAFtB,CAOA,IAAAM,GAAA,IAAAH,EAAA,GAAAE,OAAA,aACA,GAAAC,EAAA,CAOA,IAAAC,GAAAJ,EAAAtE,SAEA2E,GAAA,EACAC,GAAA,EACAC,OAAA3J,EAEA,IACA,QAAA4J,EAAAC,EAAAT,EAAA7D,OAAAC,cAAkEiE,GAAAG,EAAAC,EAAA1D,QAAAC,MAAgEqD,GAAA,GAClI,IAAAK,EAAAF,EAAAxM,MAEA2M,EAAAD,EAAA7G,MAAA,sDACA,GAAA8G,EAAA,CACA,IAAAC,EAAArE,EAAAoE,EAAA,GACAE,EAAAD,EAAA,GACApL,EAAAoL,EAAA,GACAE,EAAAF,EAAA,GAEAR,EAAA5G,KAAAqH,EAAA,KAAArL,EAAAsL,EAAA,UAGAV,EAAA5G,KAAAkH,IAGO,MAAAzD,GACPqD,GAAA,EACAC,EAAAtD,EACO,QACP,KACAoD,GAAAI,EAAAM,QACAN,EAAAM,SAES,QACT,GAAAT,EACA,MAAAC,GAKA7G,EAAArE,MAAA+K,EAAAnI,KAAA,MACApB,KAAA+I,OAAoBlG,QAAAmG,QAAA,QA5CpBhJ,KAAA+I,OAAsBlG,QAAAmG,QAAA,QA+CtBnC,IAAA,WACA1J,MAAA,SAAA0F,GACA,IAAAsH,EAAAnK,KAEAoK,EAAA,gBAAAA,CAAAvH,EAAArE,MAAA,SAAA6L,GACAxH,EAAArE,MAAA6L,EAAAjJ,KAAA,MACA+I,EAAAG,UAAyBzH,QAAAmG,QAAA,SAIzBnC,IAAA,eACA1J,MAAA,SAAAoN,GACA,IAAAC,EAAAxK,KAAAwG,MACAiE,EAAAD,EAAAC,SACAC,EAAAF,EAAAE,aACAC,EAAAH,EAAAG,SACAC,EAAAJ,EAAAI,WAEAC,EAAAT,EAAA,SAAAA,IAAuCA,EAAA,SAAApK,KAAAwG,MAAAsE,OACvCpM,EAAAmM,EAAAnM,MACAC,EAAAkM,EAAAlM,KACAC,EAAAiM,EAAAjM,WAEA,OAAA2L,EAAAjI,IAAA,SAAAyI,EAAAC,GACA,IAAAC,OAAA,EACAC,OAAA,EAEA,OAAAF,GAAAP,IAAAL,EAAA,qBAAAA,CAAAW,EAAApL,UACAuL,EAAAd,EAAA,UAAAA,CAAAK,EAAAC,GACAO,EAAAb,EAAA,eAAAA,CAAAK,OACS,CACT,IAAAjG,EAAAmG,EAAAI,EAAAnL,WAAA,KACAuL,EAAAP,EAAAG,EAAAlL,aAAA,KACAqL,EAAAd,EAAA,UAAAA,CAAAW,EAAApL,SAAA+K,EAAAlG,EAAA2G,GACAF,EAAAb,EAAA,eAAAA,CAAAW,EAAApL,SAAA6E,EAAA2G,GAGA,OAAAf,EAAA,SAAAgB,cACA,OACWN,MAAApM,EAAAmI,IAAAmE,GACXZ,EAAA,SAAAgB,cACA,MACA,KACAL,EAAAtL,cAEA2K,EAAA,SAAAgB,cACA,OACaN,MAAAnM,GACbyL,EAAA,SAAAgB,cACA,KACeC,KAAAH,EAAAJ,MAAAlM,GACfqM,UAOApE,IAAA,SACA1J,MAAA,WAGA,IAAA0F,EAAA7C,KAAA+I,MAAAlG,MACAyI,EAAAtL,KAAAwG,MAAA8E,UAEAC,EAAAnB,EAAA,SAAAA,IAAuCA,EAAA,SAAApK,KAAAwG,MAAAsE,OACvCzN,EAAAkO,EAAAlO,OACAiB,EAAAiN,EAAAjN,QACAE,EAAA+M,EAAA/M,MACAE,EAAA6M,EAAA7M,MAEA6L,OAAA,EACAiB,OAAA,EACA,IACAjB,EAAAH,EAAA,oBAAAxH,MAAAC,GACO,MAAAsB,GACPqH,EAAA,IAAArI,MAAA,qEAiBA,OAbAoH,EADAiB,EACApB,EAAA,SAAAgB,cACA,OACWN,MAAApM,EAAAmI,IAAA,GACXuD,EAAA,SAAAgB,cACA,MACA,KACAI,EAAAlN,UAIA0B,KAAAyL,aAAAlB,GAGAH,EAAA,SAAAgB,cACA,OACSN,MAAAzN,EAAAiO,aACTlB,EAAA,SAAAgB,cACA,OACWN,MAAAxM,GACXuE,EAAA6I,KACA,KACA7I,EAAAvE,SAEA8L,EAAA,SAAAgB,cACA,OACWN,MAAAtM,GACX+L,QAMAnF,EAnNA,CAoNCgF,EAAA,cAMDhF,EAAAuG,WACA9I,MAAAuH,EAAA,aAAAwB,WAAAzI,OAAA0I,WACApB,SAAAL,EAAA,aAAA0B,OACApB,aAAAN,EAAA,aAAA0B,OACAnB,SAAAP,EAAA,aAAA2B,KACAnB,WAAAR,EAAA,aAAA2B,KACAjB,MAAAV,EAAA,aAAA4B,OACAV,UAAAlB,EAAA,aAAA0B,QAEA1G,EAAA6G,YAAA,cACA7G,EAAA8G,cACAvB,UAAA,EACAC,YAAA,GAEA,IAAAuB,EAAA,SAAAC,GAGA,SAAAD,IAGA,OAFAlE,EAAAjI,KAAAmM,GAEAhE,EAAAnI,MAAAmM,EAAAxD,WAAA3L,OAAA8L,eAAAqD,IAAA9K,MAAArB,KAAAqM,YAkCA,OAvCA/D,EAAA6D,EAAAC,GAQA9F,EAAA6F,IACAtF,IAAA,oBACA1J,MAAA,WACA6C,KAAAsM,GAAAC,SAAAnB,cAAA,OACAmB,SAAAC,KAAAC,YAAAzM,KAAAsM,IACAtM,KAAA0M,uBAGA7F,IAAA,qBACA1J,MAAA,WACA6C,KAAA0M,uBAGA7F,IAAA,uBACA1J,MAAA,WACAiN,EAAA,YAAAuC,uBAAA3M,KAAAsM,IACAC,SAAAC,KAAAI,YAAA5M,KAAAsM,IACAtM,KAAAsM,GAAA,QAGAzF,IAAA,oBACA1J,MAAA,WACAiN,EAAA,YAAAyC,OAAAzC,EAAA,SAAAgB,cAAAhB,EAAA,eAAApK,KAAAwG,OAAAxG,KAAAsM,OAGAzF,IAAA,SACA1J,MAAA,WACA,gBAIAgP,EAxCA,CAyCC/B,EAAA,cAED+B,EAAAR,WACA9I,MAAAuH,EAAA,aAAAwB,WAAAzI,OAAA0I,YAEAM,EAAAF,YAAA,SACA/O,EAAAE,QAAA+O,EAEA,IAAAW,EAAA9P,OAAAyL,OAAA,MAEAsE,EAAA,4BACAC,KAoBA,SAAA5C,EAAA6C,GACA,QAAAlN,IAAA+M,QAAA/M,IAAA+M,EAAAG,GACA,OAYA,SAAAA,GACA,OAAAA,GACA,gBACA,OAAA/F,EAAA9J,QAEA,oBACA,OAAA2K,EAAAmF,cAEA,aACA,OAAArF,EAAAzK,QAEA,YACA,OAAAqK,EAAArK,QAEA,yBACA,OAAA0K,EAAAqF,mBAEA,cACA,OAAArF,EAAAsF,QAEA,mBACA,OAAAtF,EAAAuF,aAEA,uBACA,OAAA1F,EAAAvK,QAEA,gBACA,OAAAgK,EAAAkG,UAEA,eACA,OAAA/F,EAAAnK,QAEA,YACA,OAAAiK,EAAAjK,QAEA,kBACA,OAAAgI,EAGA,OAnDAmI,CAAAN,GAEA,IAAA9P,EAAA2P,EAAAG,GAEA,OAAA9P,IAAA4P,OACA,EAEA5P,EAuEA,SAAAqQ,EAAAP,EAAA9P,GACA,wBAAA8P,EAAA,YAAA5H,EAAA4H,IAWA,OALAH,EAAAG,QADAlN,IAAA5C,EACA4P,EAEA5P,EAGA,WACAsQ,EAAAR,IAXAjQ,OAAA0Q,KAAAT,GAAAU,QAAA,SAAAjC,GACAoB,EAAApB,GAAAuB,EAAAvB,KAeA,SAAA+B,EAAAR,UACAH,EAAAG,GAGA,SAAAW,EAAA5B,GACA,IAAA6B,EAAA7Q,OAAA0Q,KAAA1B,GACA8B,KAEA,SAAAC,IACAF,EAAAF,QAAA,SAAAV,GACAH,EAAAG,GAAAa,EAAAb,KAIA,gBAAAe,GACAH,EAAAF,QAAA,SAAAV,GACAa,EAAAb,GAAAH,EAAAG,GACAH,EAAAG,GAAAjB,EAAAiB,KAEA,IAAAxI,EAAAuJ,IAQA,OANAvJ,GAAA,mBAAAA,EAAAwJ,KACAxJ,EAAAwJ,KAAAF,GAAAG,MAAAH,GAEAA,IAGAtJ,IA/IA,WACA,SAAA0J,EAAAzC,EAAAvO,GACAH,OAAAC,eAAA+P,EAAAtB,GACAvO,QACAuJ,YAAA,EACAC,cAAA,IAIAwH,EAAA,UAAA/D,GACA+D,EAAA,oBAAA/D,GACA+D,EAAA,aAAAX,GACAW,EAAA,UAAAX,GACAW,EAAA,YAAAV,GACAU,EAAA,sBAAAV,GACAU,EAAA,WAAAP,GAfA,GAmJA,IAAAQ,OAAA,IAAAjC,EAAA,YAAA9G,EAAA8G,GAEA,SAAAkC,EAAA3C,EAAAvO,GACAH,OAAAC,eAAAkP,EAAAT,GACAvO,QACAuJ,YAAA,EACAC,cAAA,IAIA,WAAAyH,GAAA,aAAAA,IAAApR,OAAAsR,aAAAnC,KACAkC,EAAA,UAAAjE,GACAiE,EAAA,oBAAAjE,GACAiE,EAAA,aAAAb,GACAa,EAAA,UAAAb,GACAa,EAAA,YAAAZ,GACAY,EAAA,sBAAAZ,GACAY,EAAA,WAAAT,GACAS,EAAA,gBAAArB,IAGA9P,EAAAiI,QAAAiF,EACAlN,EAAAgI,kBAAAkF,EACAlN,EAAA+H,WAAAuI,EACAtQ,EAAA8H,QAAAwI,EACAtQ,EAAA6H,oBAAA0I,EACAvQ,EAAA4H,cAAAkI,wBC5fA,IAAA9N,IASC,WACD,gBAAAqP,GAEA,IAAAC,KAGA,SAAAhN,EAAAiN,GAGA,GAAAD,EAAAC,GACA,OAAAD,EAAAC,GAAAvR,QAGA,IAAAoE,EAAAkN,EAAAC,IACAvR,WACAwR,GAAAD,EACAE,QAAA,GAUA,OANAJ,EAAAE,GAAA5N,KAAAS,EAAApE,QAAAoE,IAAApE,QAAAsE,GAGAF,EAAAqN,QAAA,EAGArN,EAAApE,QAcA,OATAsE,EAAAoN,EAAAL,EAGA/M,EAAAqN,EAAAL,EAGAhN,EAAAsN,EAAA,GAGAtN,EAAA,GAvCA,EA4CA,SAAAF,EAAApE,EAAAsE,GAEA,IAAAzC,EAAAC,EAcAD,GAAAyC,EAAA,IAAAxC,EAAA,SAAA+P,GAEA,IAAAC,KAoEAC,EAAA,WACA,OAAAC,UAAAC,UAAAC,cAAA9L,QAAA,cAGA+L,EAAA,WACA,OAAAH,UAAAC,UAAAC,cAAA9L,QAAA,eAGAgM,EAAA,WACA,OAAAJ,UAAAC,UAAAC,cAAA9L,QAAA,cAGAiM,EAAA,WACA,OAAAhD,SAAAiD,cAAAjD,SAAAiD,cAAA,IAGAC,EAAA,SAAAtJ,EAAAuJ,GACA1P,KAAA2P,IAAA,EACA3P,KAAA4P,UAAAF,KAAAG,cAAAb,KACAhP,KAAAmG,QAGAsJ,EAAAlP,UAAAuP,YAAA,SAAAC,GACA,KAAAA,KAAA/P,KAAA4P,WAAA,CACA5P,KAAA2P,MACA3P,KAAA4P,UAAAG,GAAA,KAKA,IAAAC,EAAAC,IACAC,EAAAlQ,KACAgQ,EAAAG,mBAAA,SAAAhM,GACA+L,EAAAE,aAAAvP,KAAAqP,EAAA/L,EAAA4L,IAEAC,EAAAK,KAAA,MAAAN,GAAA,GACAC,EAAAM,SAGA,IAAAC,EAAA,IAAAC,OAAA,uBAEAf,EAAAlP,UAAA6P,aAAA,SAAAjM,EAAA4L,GACA,OAAA5L,EAAAF,OAAAwM,WAAA,CAIA,SAAAtM,EAAAF,OAAAyM,QACA,YAAAX,EAAAjM,MAAA,UAAAK,EAAAF,OAAAyM,OACA,CAKA,IAAA1N,EAAAmB,EAAAF,OAAA0M,aAAA3N,MAAA,0CACA,GAAAA,GAAA,IAAAA,EAAAR,OAAA,CAEA,IAAAoO,EAAA5N,EAAA,GAEA6N,EAAAD,EAAA5N,MAAA,sDAEA,GAAA6N,KAAA,GACA7Q,KAAA4P,UAAAG,GAAA,IAAAhB,EAAA+B,kBAAAC,KAAAF,EAAA,KACA7Q,KAAAmG,KAAAnG,KAAA4P,eACU,CACV,IAAAW,EAAAS,KAAAJ,GAAA,CAEA,IAAAK,EACAC,EAAAnB,EAAAoB,YAAA,MACA,IAAAD,IACAD,EAAAlB,EAAAjM,MAAA,EAAAoN,EAAA,GACAN,EAAAK,EAAAL,GAOA,IAAAQ,EAAAnB,IACAC,EAAAlQ,KACAoR,EAAAjB,mBAAA,WACA,IAAAiB,EAAAX,aACAP,EAAAP,OACA,MAAAyB,EAAAV,QACA,YAAAE,EAAA9M,MAAA,UAAAsN,EAAAV,UACAR,EAAAN,UAAAG,GAAA,IAAAhB,EAAA+B,kBAAAM,EAAAT,eAEA,IAAAT,EAAAP,KACAO,EAAA/J,KAAA+J,EAAAN,aAKAwB,EAAAf,KAAA,MAAAO,GAAA,GACAQ,EAAAd,aAIAtQ,KAAA2P,WAIA3P,KAAA2P,MAGA,IAAA3P,KAAA2P,KACA3P,KAAAmG,KAAAnG,KAAA4P,aAIA,IAAAyB,EAAA,SAAA7M,EAAA8M,EAAA1B,GAGA,IAFA,IACAtN,EADAmC,KAEA5C,EAAA,EAAkBA,EAAA2C,EAAAhC,OAAkBX,IAAA,CACpC,IAAA0P,EAAAD,EAAAzP,GACA,GAAA0P,EAAA,CACA,IAAAxB,EAAAwB,EAAA,GACA3N,EAAA4N,SAAAD,EAAA,OACAE,EAAAD,SAAAD,EAAA,OAGA,GAFAjP,EAAAsN,EAAAG,GAEAzN,EAAA,CAEA,IAAAoP,EAAApP,EAAAqP,qBACc/N,OAAA6N,WACdhN,EAAA9B,KAAAiP,EAAAF,EAAA5R,OACA4R,EAAA9N,KAAA8N,EAAAD,OAAAC,EAAAhG,MAAAmG,EAAArN,EAAA3C,WAKA4C,EAAA9B,KAAAiP,EAAA7B,EAAAnM,EAAA6N,EAAAI,EAAArN,EAAA3C,WAIA4C,EAAA9B,KAAA6B,EAAA3C,IAIA,OAAA4C,GAGA,SAAAoN,EAAAC,GACA,IAAA9O,EAAAtC,OAAAoR,GAAA9O,MAAAiM,KAAAM,IACA,kBACA,cACA,OAAAvM,KAAA,GAGA,IAAA4O,EAAA,SAAA9R,EAAA8D,EAAA6N,EAAA/F,GAEA,iBAAAA,GAAA,aACA,KAAA5L,EAAA,IAAA8D,EAAA,IAAA6N,EAAA,KAIAM,GACA,WAAe,WAAAC,gBACf,WAAe,WAAAC,cAAA,mBACf,WAAe,WAAAA,cAAA,mBACf,WAAe,WAAAA,cAAA,uBAGf,SAAAhC,IAEA,IADA,IAAAiC,GAAA,EACArQ,EAAA,EAAoBA,EAAAkQ,EAAAvP,OAA0BX,IAAA,CAC9C,IACAqQ,EAAAH,EAAAlQ,KAEA,MAAAsC,GACA,SAEA,MAEA,OAAA+N,EAGA,OACAhF,cArOA,SAAA1O,EAAA2H,EAAAuJ,GACA,IAAAlL,EACAZ,EAGAuO,EACApC,EACAqC,EACAC,EACAC,EALAhB,KAOAiB,EAAA,IAAA9C,EAAA,WACA,IAAAhL,EAAA4M,EAAA7M,EAAA8M,EAAAiB,EAAA3C,WACAzJ,EAAA1B,IACMiL,GAEN,GAAAT,KAAAM,IACA8C,EAAA,kCACAD,EAAA,EAEAE,EAAA,MACM,KAAAjD,MAAAC,IAKN,UAAAnM,MAAA,sBAJAkP,EAAA,0BACAD,EAAA,EACAE,EAAA,EAKA9N,EAAAhG,EAAAmF,MAAA,MAAAG,MAAAwO,GAEA,QAAAzQ,EAAA,EAAkBA,EAAA2C,EAAAhC,OAAkBX,IACpC+B,EAAAY,EAAA3C,GACA6N,KAAAhN,SAAAgN,EAAAhN,OAAAkB,KAEAuO,EAAAvO,EAAAZ,MAAAqP,GACAF,KAAA3P,SAAA4P,IACAd,EAAAzP,GAAAsQ,EACApC,EAAAoC,EAAA,GACApC,EAAA/M,MAAA,gBACAuP,EAAAzC,YAAAC,KAOA,IAAAwC,EAAA5C,KACA4C,EAAApM,KAAAoM,EAAA3C,cAuLEvO,MAAAnE,EAAA6B,QAAAgB,IAAAf,IAAAsC,EAAApE,QAAA8B,IAKF,SAAAsC,EAAApE,EAAAsE,GASA,IAAAgR,EAAAhR,EAAA,GACAiR,EAAAjR,EAAA,GACAkR,EAAAlR,EAAA,GAAAkR,SACAC,EAAAnR,EAAA,GACAoR,EAAApR,EAAA,GAAAoR,UAEA,SAAA9B,EAAA+B,GACA,IAAAC,EAAAD,EAKA,MAJA,iBAAAA,IACAC,EAAAC,KAAAnQ,MAAAiQ,EAAApP,QAAA,WAAuD,MAGvD,MAAAqP,EAAAE,SACA,IAAAC,EAAAH,GACA,IAAAI,EAAAJ,GAoQA,SAAAI,EAAAL,GACA,IAAAC,EAAAD,EACA,iBAAAA,IACAC,EAAAC,KAAAnQ,MAAAiQ,EAAApP,QAAA,WAAuD,MAGvD,IAAA0P,EAAAX,EAAAY,OAAAN,EAAA,WACAO,EAAAb,EAAAY,OAAAN,EAAA,WAGAQ,EAAAd,EAAAY,OAAAN,EAAA,YACAS,EAAAf,EAAAY,OAAAN,EAAA,mBACAU,EAAAhB,EAAAY,OAAAN,EAAA,uBACAW,EAAAjB,EAAAY,OAAAN,EAAA,YACAnU,EAAA6T,EAAAY,OAAAN,EAAA,aAIA,GAAAK,GAAAnT,KAAA0T,SACA,UAAAvQ,MAAA,wBAAAgQ,GAGAE,IACA/Q,IAAA5B,QAIA4B,IAAAkQ,EAAAmB,WAKArR,IAAA,SAAAxC,GACA,OAAAyT,GAAAf,EAAAoB,WAAAL,IAAAf,EAAAoB,WAAA9T,GACA0S,EAAAqB,SAAAN,EAAAzT,GACAA,IAOAE,KAAA8T,OAAApB,EAAAqB,UAAAT,EAAAhR,IAAA5B,SAAA,GACAV,KAAAgU,SAAAtB,EAAAqB,UAAAV,GAAA,GAEArT,KAAAuT,aACAvT,KAAAwT,iBACAxT,KAAAiU,UAAAR,EACAzT,KAAArB,OA8EA,SAAAuV,IACAlU,KAAAmU,cAAA,EACAnU,KAAAoU,gBAAA,EACApU,KAAAF,OAAA,KACAE,KAAAqU,aAAA,KACArU,KAAAsU,eAAA,KACAtU,KAAA0L,KAAA,KAyZA,SAAAuH,EAAAJ,GACA,IAAAC,EAAAD,EACA,iBAAAA,IACAC,EAAAC,KAAAnQ,MAAAiQ,EAAApP,QAAA,WAAuD,MAGvD,IAAA0P,EAAAX,EAAAY,OAAAN,EAAA,WACAE,EAAAR,EAAAY,OAAAN,EAAA,YAEA,GAAAK,GAAAnT,KAAA0T,SACA,UAAAvQ,MAAA,wBAAAgQ,GAGAnT,KAAAgU,SAAA,IAAAtB,EACA1S,KAAA8T,OAAA,IAAApB,EAEA,IAAA6B,GACA3Q,MAAA,EACA6N,OAAA,GAEAzR,KAAAwU,UAAAxB,EAAA1Q,IAAA,SAAAmS,GACA,GAAAA,EAAAvJ,IAGA,UAAA/H,MAAA,sDAEA,IAAAuR,EAAAlC,EAAAY,OAAAqB,EAAA,UACAE,EAAAnC,EAAAY,OAAAsB,EAAA,QACAE,EAAApC,EAAAY,OAAAsB,EAAA,UAEA,GAAAC,EAAAJ,EAAA3Q,MACA+Q,IAAAJ,EAAA3Q,MAAAgR,EAAAL,EAAA9C,OACA,UAAAtO,MAAA,wDAIA,OAFAoR,EAAAG,GAGAG,iBAGAV,cAAAQ,EAAA,EACAP,gBAAAQ,EAAA,GAEAE,SAAA,IAAAhE,EAAA0B,EAAAY,OAAAqB,EAAA,WAz0BA3D,EAAAiE,cAAA,SAAAlC,GACA,OAAAK,EAAA6B,cAAAlC,IAMA/B,EAAAvQ,UAAAmT,SAAA,EAgCA5C,EAAAvQ,UAAAyU,oBAAA,KACAhY,OAAAC,eAAA6T,EAAAvQ,UAAA,sBACA0U,IAAA,WAKA,OAJAjV,KAAAgV,qBACAhV,KAAAkV,eAAAlV,KAAAiU,UAAAjU,KAAAuT,YAGAvT,KAAAgV,uBAIAlE,EAAAvQ,UAAA4U,mBAAA,KACAnY,OAAAC,eAAA6T,EAAAvQ,UAAA,qBACA0U,IAAA,WAKA,OAJAjV,KAAAmV,oBACAnV,KAAAkV,eAAAlV,KAAAiU,UAAAjU,KAAAuT,YAGAvT,KAAAmV,sBAIArE,EAAAvQ,UAAA6U,wBACA,SAAAC,EAAArK,GACA,IAAA6D,EAAAwG,EAAAC,OAAAtK,GACA,YAAA6D,GAAoB,MAAAA,GAQpBiC,EAAAvQ,UAAA2U,eACA,SAAAG,EAAAE,GACA,UAAApS,MAAA,6CAGA2N,EAAA0E,gBAAA,EACA1E,EAAA2E,eAAA,EAEA3E,EAAA4E,qBAAA,EACA5E,EAAA6E,kBAAA,EAkBA7E,EAAAvQ,UAAAqV,YACA,SAAAC,EAAAC,EAAAC,GACA,IAGAtC,EAHAuC,EAAAF,GAAA,KACAG,EAAAF,GAAAjF,EAAA0E,gBAGA,OAAAS,GACA,KAAAnF,EAAA0E,gBACA/B,EAAAzT,KAAAkW,mBACA,MACA,KAAApF,EAAA2E,eACAhC,EAAAzT,KAAAmW,kBACA,MACA,QACA,UAAAhT,MAAA,+BAGA,IAAAoQ,EAAAvT,KAAAuT,WACAE,EAAAnR,IAAA,SAAA8T,GACA,IAAAtW,EAAA,OAAAsW,EAAAtW,OAAA,KAAAE,KAAAgU,SAAAqC,GAAAD,EAAAtW,QAIA,OAHA,MAAAA,GAAA,MAAAyT,IACAzT,EAAA0S,EAAApR,KAAAmS,EAAAzT,KAGAA,SACAqU,cAAAiC,EAAAjC,cACAC,gBAAAgC,EAAAhC,gBACAC,aAAA+B,EAAA/B,aACAC,eAAA8B,EAAA9B,eACA5I,KAAA,OAAA0K,EAAA1K,KAAA,KAAA1L,KAAA8T,OAAAuC,GAAAD,EAAA1K,QAEM1L,MAAA2N,QAAAkI,EAAAG,IAsBNlF,EAAAvQ,UAAA+V,yBACA,SAAAC,GACA,IAAA3S,EAAA4O,EAAAY,OAAAmD,EAAA,QAMAC,GACA1W,OAAA0S,EAAAY,OAAAmD,EAAA,UACAlC,aAAAzQ,EACA0Q,eAAA9B,EAAAY,OAAAmD,EAAA,aAMA,GAHA,MAAAvW,KAAAuT,aACAiD,EAAA1W,OAAA0S,EAAAqB,SAAA7T,KAAAuT,WAAAiD,EAAA1W,UAEAE,KAAAgU,SAAAyC,IAAAD,EAAA1W,QACA,SAEA0W,EAAA1W,OAAAE,KAAAgU,SAAA1Q,QAAAkT,EAAA1W,QAEA,IAAA2T,KAEAzI,EAAAhL,KAAA0W,aAAAF,EACAxW,KAAAmW,kBACA,eACA,iBACA3D,EAAAmE,2BACAlE,EAAAkD,mBACA,GAAA3K,GAAA,GACA,IAAAoL,EAAApW,KAAAmW,kBAAAnL,GAEA,QAAAjL,IAAAwW,EAAA9E,OAOA,IANA,IAAA4C,EAAA+B,EAAA/B,aAMA+B,KAAA/B,kBACAZ,EAAA9Q,MACAiB,KAAA4O,EAAAY,OAAAgD,EAAA,sBACA3E,OAAAe,EAAAY,OAAAgD,EAAA,wBACAQ,WAAApE,EAAAY,OAAAgD,EAAA,8BAGAA,EAAApW,KAAAmW,oBAAAnL,QASA,IANA,IAAAsJ,EAAA8B,EAAA9B,eAMA8B,GACAA,EAAA/B,eAAAzQ,GACAwS,EAAA9B,mBACAb,EAAA9Q,MACAiB,KAAA4O,EAAAY,OAAAgD,EAAA,sBACA3E,OAAAe,EAAAY,OAAAgD,EAAA,wBACAQ,WAAApE,EAAAY,OAAAgD,EAAA,8BAGAA,EAAApW,KAAAmW,oBAAAnL,GAKA,OAAAyI,GAGAvW,EAAA4T,oBAmFAoC,EAAA3S,UAAAvD,OAAAyL,OAAAqI,EAAAvQ,WACA2S,EAAA3S,UAAAuU,SAAAhE,EASAoC,EAAA6B,cACA,SAAAlC,GACA,IAAAgE,EAAA7Z,OAAAyL,OAAAyK,EAAA3S,WAEA+S,EAAAuD,EAAA/C,OAAApB,EAAAqB,UAAAlB,EAAAiB,OAAAgD,WAAA,GACAzD,EAAAwD,EAAA7C,SAAAtB,EAAAqB,UAAAlB,EAAAmB,SAAA8C,WAAA,GACAD,EAAAtD,WAAAV,EAAAkE,YACAF,EAAArD,eAAAX,EAAAmE,wBAAAH,EAAA7C,SAAA8C,UACAD,EAAAtD,YACAsD,EAAAlY,KAAAkU,EAAAoE,MAWA,IAJA,IAAAC,EAAArE,EAAAoB,UAAA6C,UAAAhT,QACAqT,EAAAN,EAAA7B,uBACAoC,EAAAP,EAAA1B,sBAEAtT,EAAA,EAAAW,EAAA0U,EAAA1U,OAAuDX,EAAAW,EAAYX,IAAA,CACnE,IAAAwV,EAAAH,EAAArV,GACAyV,EAAA,IAAApD,EACAoD,EAAAnD,cAAAkD,EAAAlD,cACAmD,EAAAlD,gBAAAiD,EAAAjD,gBAEAiD,EAAAvX,SACAwX,EAAAxX,OAAAuT,EAAA/P,QAAA+T,EAAAvX,QACAwX,EAAAjD,aAAAgD,EAAAhD,aACAiD,EAAAhD,eAAA+C,EAAA/C,eAEA+C,EAAA3L,OACA4L,EAAA5L,KAAA4H,EAAAhQ,QAAA+T,EAAA3L,OAGA0L,EAAAzU,KAAA2U,IAGAH,EAAAxU,KAAA2U,GAKA,OAFA1E,EAAAiE,EAAA1B,mBAAA3C,EAAAmE,4BAEAE,GAMA3D,EAAA3S,UAAAmT,SAAA,EAKA1W,OAAAC,eAAAiW,EAAA3S,UAAA,WACA0U,IAAA,WACA,OAAAjV,KAAAgU,SAAA8C,UAAAxU,IAAA,SAAAmS,GACA,aAAAzU,KAAAuT,WAAAf,EAAApR,KAAApB,KAAAuT,WAAAkB,MACMzU,SAqBNkT,EAAA3S,UAAA2U,eACA,SAAAG,EAAAE,GAeA,IAdA,IAYAa,EAAAmB,EAAAC,EAAAC,EAAAta,EAZAgX,EAAA,EACAuD,EAAA,EACAC,EAAA,EACAC,EAAA,EACAC,EAAA,EACAC,EAAA,EACAtV,EAAA6S,EAAA7S,OACAwI,EAAA,EACA+M,KACAC,KACAC,KACAf,KAGAlM,EAAAxI,GACA,SAAA6S,EAAAC,OAAAtK,GACAmJ,IACAnJ,IACA0M,EAAA,OAEA,SAAArC,EAAAC,OAAAtK,GACAA,QAEA,CASA,IARAoL,EAAA,IAAAlC,EACAkC,EAAAjC,gBAOAsD,EAAAzM,EAA0ByM,EAAAjV,IAC1BxC,KAAAoV,wBAAAC,EAAAoC,GADwCA,KAQxC,GAHAF,EAAAlC,EAAAvR,MAAAkH,EAAAyM,GAEAD,EAAAO,EAAAR,GACAC,EACAxM,GAAAuM,EAAA/U,WACU,CAEV,IADAgV,KACAxM,EAAAyM,GACA9E,EAAAuF,OAAA7C,EAAArK,EAAAgN,GACA7a,EAAA6a,EAAA7a,MACA6N,EAAAgN,EAAAG,KACAX,EAAA7U,KAAAxF,GAGA,OAAAqa,EAAAhV,OACA,UAAAW,MAAA,0CAGA,OAAAqU,EAAAhV,OACA,UAAAW,MAAA,0CAGA4U,EAAAR,GAAAC,EAIApB,EAAAhC,gBAAAsD,EAAAF,EAAA,GACAE,EAAAtB,EAAAhC,gBAEAoD,EAAAhV,OAAA,IAEA4T,EAAAtW,OAAA+X,EAAAL,EAAA,GACAK,GAAAL,EAAA,GAGApB,EAAA/B,aAAAsD,EAAAH,EAAA,GACAG,EAAAvB,EAAA/B,aAEA+B,EAAA/B,cAAA,EAGA+B,EAAA9B,eAAAsD,EAAAJ,EAAA,GACAI,EAAAxB,EAAA9B,eAEAkD,EAAAhV,OAAA,IAEA4T,EAAA1K,KAAAoM,EAAAN,EAAA,GACAM,GAAAN,EAAA,KAIAN,EAAAvU,KAAAyT,GACA,iBAAAA,EAAA/B,cACA4D,EAAAtV,KAAAyT,GAKAxD,EAAAsE,EAAA1E,EAAA4F,qCACApY,KAAAgV,oBAAAkC,EAEAtE,EAAAqF,EAAAzF,EAAAmE,4BACA3W,KAAAmV,mBAAA8C,GAOA/E,EAAA3S,UAAAmW,aACA,SAAA2B,EAAAC,EAAAC,EACAC,EAAAC,EAAAC,GAMA,GAAAL,EAAAE,IAAA,EACA,UAAAzX,UAAA,gDACAuX,EAAAE,IAEA,GAAAF,EAAAG,GAAA,EACA,UAAA1X,UAAA,kDACAuX,EAAAG,IAGA,OAAA/F,EAAApJ,OAAAgP,EAAAC,EAAAG,EAAAC,IAOAxF,EAAA3S,UAAAoY,mBACA,WACA,QAAA3N,EAAA,EAAwBA,EAAAhL,KAAAkW,mBAAA1T,SAAwCwI,EAAA,CAChE,IAAAoL,EAAApW,KAAAkW,mBAAAlL,GAMA,GAAAA,EAAA,EAAAhL,KAAAkW,mBAAA1T,OAAA,CACA,IAAAoW,EAAA5Y,KAAAkW,mBAAAlL,EAAA,GAEA,GAAAoL,EAAAjC,gBAAAyE,EAAAzE,cAAA,CACAiC,EAAAyC,oBAAAD,EAAAxE,gBAAA,EACA,UAKAgC,EAAAyC,oBAAAC,MAwBA5F,EAAA3S,UAAAoR,oBACA,SAAA4E,GACA,IAAAC,GACArC,cAAA3B,EAAAY,OAAAmD,EAAA,QACAnC,gBAAA5B,EAAAY,OAAAmD,EAAA,WAGAvL,EAAAhL,KAAA0W,aACAF,EACAxW,KAAAkW,mBACA,gBACA,kBACA1D,EAAA4F,oCACA5F,EAAAY,OAAAmD,EAAA,OAAAzF,EAAA4E,uBAGA,GAAA1K,GAAA,GACA,IAAAoL,EAAApW,KAAAkW,mBAAAlL,GAEA,GAAAoL,EAAAjC,gBAAAqC,EAAArC,cAAA,CACA,IAAArU,EAAA0S,EAAAY,OAAAgD,EAAA,eACA,OAAAtW,IACAA,EAAAE,KAAAgU,SAAAqC,GAAAvW,GACA,MAAAE,KAAAuT,aACAzT,EAAA0S,EAAApR,KAAApB,KAAAuT,WAAAzT,KAGA,IAAA4L,EAAA8G,EAAAY,OAAAgD,EAAA,aAIA,OAHA,OAAA1K,IACAA,EAAA1L,KAAA8T,OAAAuC,GAAA3K,KAGA5L,SACA8D,KAAA4O,EAAAY,OAAAgD,EAAA,qBACA3E,OAAAe,EAAAY,OAAAgD,EAAA,uBACA1K,SAKA,OACA5L,OAAA,KACA8D,KAAA,KACA6N,OAAA,KACA/F,KAAA,OAQAwH,EAAA3S,UAAAwY,wBACA,WACA,QAAA/Y,KAAAwT,iBAGAxT,KAAAwT,eAAAhR,QAAAxC,KAAAgU,SAAAgF,SACAhZ,KAAAwT,eAAAyF,KAAA,SAAAC,GAAgD,aAAAA,MAQhDhG,EAAA3S,UAAA4Y,iBACA,SAAAC,EAAAC,GACA,IAAArZ,KAAAwT,eACA,YAOA,GAJA,MAAAxT,KAAAuT,aACA6F,EAAA5G,EAAAqB,SAAA7T,KAAAuT,WAAA6F,IAGApZ,KAAAgU,SAAAyC,IAAA2C,GACA,OAAApZ,KAAAwT,eAAAxT,KAAAgU,SAAA1Q,QAAA8V,IAGA,IAAAlO,EACA,SAAAlL,KAAAuT,aACArI,EAAAsH,EAAA8G,SAAAtZ,KAAAuT,aAAA,CAKA,IAAAgG,EAAAH,EAAA3V,QAAA,iBACA,WAAAyH,EAAAsO,QACAxZ,KAAAgU,SAAAyC,IAAA8C,GACA,OAAAvZ,KAAAwT,eAAAxT,KAAAgU,SAAA1Q,QAAAiW,IAGA,KAAArO,EAAAuO,MAAA,KAAAvO,EAAAuO,OACAzZ,KAAAgU,SAAAyC,IAAA,IAAA2C,GACA,OAAApZ,KAAAwT,eAAAxT,KAAAgU,SAAA1Q,QAAA,IAAA8V,IAQA,GAAAC,EACA,YAGA,UAAAlW,MAAA,IAAAiW,EAAA,+BAuBAlG,EAAA3S,UAAAmZ,qBACA,SAAAnD,GACA,IAAAzW,EAAA0S,EAAAY,OAAAmD,EAAA,UAIA,GAHA,MAAAvW,KAAAuT,aACAzT,EAAA0S,EAAAqB,SAAA7T,KAAAuT,WAAAzT,KAEAE,KAAAgU,SAAAyC,IAAA3W,GACA,OACA8D,KAAA,KACA6N,OAAA,KACAmF,WAAA,MAGA9W,EAAAE,KAAAgU,SAAA1Q,QAAAxD,GAEA,IAAA0W,GACA1W,SACAuU,aAAA7B,EAAAY,OAAAmD,EAAA,QACAjC,eAAA9B,EAAAY,OAAAmD,EAAA,WAGAvL,EAAAhL,KAAA0W,aACAF,EACAxW,KAAAmW,kBACA,eACA,iBACA3D,EAAAmE,2BACAnE,EAAAY,OAAAmD,EAAA,OAAAzF,EAAA4E,uBAGA,GAAA1K,GAAA,GACA,IAAAoL,EAAApW,KAAAmW,kBAAAnL,GAEA,GAAAoL,EAAAtW,SAAA0W,EAAA1W,OACA,OACA8D,KAAA4O,EAAAY,OAAAgD,EAAA,sBACA3E,OAAAe,EAAAY,OAAAgD,EAAA,wBACAQ,WAAApE,EAAAY,OAAAgD,EAAA,6BAKA,OACAxS,KAAA,KACA6N,OAAA,KACAmF,WAAA,OAIA1Z,EAAAgW,yBA+FAD,EAAA1S,UAAAvD,OAAAyL,OAAAqI,EAAAvQ,WACA0S,EAAA1S,UAAAkF,YAAAqL,EAKAmC,EAAA1S,UAAAmT,SAAA,EAKA1W,OAAAC,eAAAgW,EAAA1S,UAAA,WACA0U,IAAA,WAEA,IADA,IAAA5B,KACAxR,EAAA,EAAoBA,EAAA7B,KAAAwU,UAAAhS,OAA2BX,IAC/C,QAAA8X,EAAA,EAAsBA,EAAA3Z,KAAAwU,UAAA3S,GAAAiT,SAAAzB,QAAA7Q,OAA+CmX,IACrEtG,EAAA1Q,KAAA3C,KAAAwU,UAAA3S,GAAAiT,SAAAzB,QAAAsG,IAGA,OAAAtG,KAmBAJ,EAAA1S,UAAAoR,oBACA,SAAA4E,GACA,IAAAC,GACArC,cAAA3B,EAAAY,OAAAmD,EAAA,QACAnC,gBAAA5B,EAAAY,OAAAmD,EAAA,WAKAqD,EAAAnH,EAAApJ,OAAAmN,EAAAxW,KAAAwU,UACA,SAAAgC,EAAAqD,GACA,IAAAC,EAAAtD,EAAArC,cAAA0F,EAAAhF,gBAAAV,cACA,OAAA2F,GAIAtD,EAAApC,gBACAyF,EAAAhF,gBAAAT,kBAEAyF,EAAA7Z,KAAAwU,UAAAoF,GAEA,OAAAC,EASAA,EAAA/E,SAAAnD,qBACA/N,KAAA4S,EAAArC,eACA0F,EAAAhF,gBAAAV,cAAA,GACA1C,OAAA+E,EAAApC,iBACAyF,EAAAhF,gBAAAV,gBAAAqC,EAAArC,cACA0F,EAAAhF,gBAAAT,gBAAA,EACA,GACA2F,KAAAxD,EAAAwD,QAdAja,OAAA,KACA8D,KAAA,KACA6N,OAAA,KACA/F,KAAA,OAmBAuH,EAAA1S,UAAAwY,wBACA,WACA,OAAA/Y,KAAAwU,UAAAwF,MAAA,SAAAvF,GACA,OAAAA,EAAAK,SAAAiE,6BASA9F,EAAA1S,UAAA4Y,iBACA,SAAAC,EAAAC,GACA,QAAAxX,EAAA,EAAoBA,EAAA7B,KAAAwU,UAAAhS,OAA2BX,IAAA,CAC/C,IAAAgY,EAAA7Z,KAAAwU,UAAA3S,GAEAoY,EAAAJ,EAAA/E,SAAAqE,iBAAAC,GAAA,GACA,GAAAa,EACA,OAAAA,EAGA,GAAAZ,EACA,YAGA,UAAAlW,MAAA,IAAAiW,EAAA,+BAkBAnG,EAAA1S,UAAAmZ,qBACA,SAAAnD,GACA,QAAA1U,EAAA,EAAoBA,EAAA7B,KAAAwU,UAAAhS,OAA2BX,IAAA,CAC/C,IAAAgY,EAAA7Z,KAAAwU,UAAA3S,GAIA,QAAAgY,EAAA/E,SAAAzB,QAAA/P,QAAAkP,EAAAY,OAAAmD,EAAA,YAGA,IAAA2D,EAAAL,EAAA/E,SAAA4E,qBAAAnD,GACA,GAAA2D,EAAA,CACA,IAAAC,GACAvW,KAAAsW,EAAAtW,MACAiW,EAAAhF,gBAAAV,cAAA,GACA1C,OAAAyI,EAAAzI,QACAoI,EAAAhF,gBAAAV,gBAAA+F,EAAAtW,KACAiW,EAAAhF,gBAAAT,gBAAA,EACA,IAEA,OAAA+F,IAIA,OACAvW,KAAA,KACA6N,OAAA,OASAwB,EAAA1S,UAAA2U,eACA,SAAAG,EAAAE,GACAvV,KAAAgV,uBACAhV,KAAAmV,sBACA,QAAAtT,EAAA,EAAoBA,EAAA7B,KAAAwU,UAAAhS,OAA2BX,IAG/C,IAFA,IAAAgY,EAAA7Z,KAAAwU,UAAA3S,GACAuY,EAAAP,EAAA/E,SAAAoB,mBACAyD,EAAA,EAAsBA,EAAAS,EAAA5X,OAA4BmX,IAAA,CAClD,IAAAvD,EAAAgE,EAAAT,GAEA7Z,EAAA+Z,EAAA/E,SAAAd,SAAAqC,GAAAD,EAAAtW,QACA,OAAA+Z,EAAA/E,SAAAvB,aACAzT,EAAA0S,EAAApR,KAAAyY,EAAA/E,SAAAvB,WAAAzT,IAEAE,KAAAgU,SAAAqG,IAAAva,GACAA,EAAAE,KAAAgU,SAAA1Q,QAAAxD,GAEA,IAAA4L,EAAAmO,EAAA/E,SAAAhB,OAAAuC,GAAAD,EAAA1K,MACA1L,KAAA8T,OAAAuG,IAAA3O,GACAA,EAAA1L,KAAA8T,OAAAxQ,QAAAoI,GAMA,IAAA4O,GACAxa,SACAqU,cAAAiC,EAAAjC,eACA0F,EAAAhF,gBAAAV,cAAA,GACAC,gBAAAgC,EAAAhC,iBACAyF,EAAAhF,gBAAAV,gBAAAiC,EAAAjC,cACA0F,EAAAhF,gBAAAT,gBAAA,EACA,GACAC,aAAA+B,EAAA/B,aACAC,eAAA8B,EAAA9B,eACA5I,QAGA1L,KAAAgV,oBAAArS,KAAA2X,GACA,iBAAAA,EAAAjG,cACArU,KAAAmV,mBAAAxS,KAAA2X,GAKA1H,EAAA5S,KAAAgV,oBAAAxC,EAAA4F,qCACAxF,EAAA5S,KAAAmV,mBAAA3C,EAAAmE,6BAGAzZ,EAAA+V,4BAKA,SAAA3R,EAAApE,GA4BAA,EAAAkW,OATA,SAAAmD,EAAAgE,EAAAC,GACA,GAAAD,KAAAhE,EACA,OAAAA,EAAAgE,GACI,OAAAlO,UAAA7J,OACJ,OAAAgY,EAEA,UAAArX,MAAA,IAAAoX,EAAA,8BAKA,IAAAE,EAAA,iEACAC,EAAA,gBAEA,SAAApB,EAAAqB,GACA,IAAA3X,EAAA2X,EAAA3X,MAAAyX,GACA,OAAAzX,GAIAwW,OAAAxW,EAAA,GACA4X,KAAA5X,EAAA,GACA6X,KAAA7X,EAAA,GACA8X,KAAA9X,EAAA,GACAyW,KAAAzW,EAAA,IAPA,KAYA,SAAA+X,EAAAC,GACA,IAAA9P,EAAA,GAiBA,OAhBA8P,EAAAxB,SACAtO,GAAA8P,EAAAxB,OAAA,KAEAtO,GAAA,KACA8P,EAAAJ,OACA1P,GAAA8P,EAAAJ,KAAA,KAEAI,EAAAH,OACA3P,GAAA8P,EAAAH,MAEAG,EAAAF,OACA5P,GAAA,IAAA8P,EAAAF,MAEAE,EAAAvB,OACAvO,GAAA8P,EAAAvB,MAEAvO,EAeA,SAAAyI,EAAAsH,GACA,IAAAxB,EAAAwB,EACA/P,EAAAoO,EAAA2B,GACA,GAAA/P,EAAA,CACA,IAAAA,EAAAuO,KACA,OAAAwB,EAEAxB,EAAAvO,EAAAuO,KAKA,IAHA,IAGAyB,EAHAtH,EAAA1W,EAAA0W,WAAA6F,GAEAlW,EAAAkW,EAAA9V,MAAA,OACAwX,EAAA,EAAAtZ,EAAA0B,EAAAf,OAAA,EAA+CX,GAAA,EAAQA,IACvDqZ,EAAA3X,EAAA1B,GACA,MAAAqZ,EACA3X,EAAA6X,OAAAvZ,EAAA,GACM,OAAAqZ,EACNC,IACMA,EAAA,IACN,KAAAD,GAIA3X,EAAA6X,OAAAvZ,EAAA,EAAAsZ,GACAA,EAAA,IAEA5X,EAAA6X,OAAAvZ,EAAA,GACAsZ,MAUA,OANA1B,EAAAlW,EAAAnC,KAAA,KAEA,KAAAqY,IACAA,EAAA7F,EAAA,SAGA1I,GACAA,EAAAuO,OACAsB,EAAA7P,IAEAuO,EA5EAvc,EAAAoc,WAsBApc,EAAA6d,cAwDA7d,EAAAyW,YA2DAzW,EAAAkE,KAzCA,SAAAia,EAAAJ,GACA,KAAAI,IACAA,EAAA,KAEA,KAAAJ,IACAA,EAAA,KAEA,IAAAK,EAAAhC,EAAA2B,GACAM,EAAAjC,EAAA+B,GAMA,GALAE,IACAF,EAAAE,EAAA9B,MAAA,KAIA6B,MAAA9B,OAIA,OAHA+B,IACAD,EAAA9B,OAAA+B,EAAA/B,QAEAuB,EAAAO,GAGA,GAAAA,GAAAL,EAAAjY,MAAA0X,GACA,OAAAO,EAIA,GAAAM,MAAAV,OAAAU,EAAA9B,KAEA,OADA8B,EAAAV,KAAAI,EACAF,EAAAQ,GAGA,IAAAC,EAAA,MAAAP,EAAA3F,OAAA,GACA2F,EACAtH,EAAA0H,EAAA5X,QAAA,eAAAwX,GAEA,OAAAM,GACAA,EAAA9B,KAAA+B,EACAT,EAAAQ,IAEAC,GAIAte,EAAA0W,WAAA,SAAAqH,GACA,YAAAA,EAAA3F,OAAA,MAAA2F,EAAAjY,MAAAyX,IAyCAvd,EAAA2W,SAhCA,SAAAwH,EAAAJ,GACA,KAAAI,IACAA,EAAA,KAGAA,IAAA5X,QAAA,UAOA,IADA,IAAAgY,EAAA,EACA,IAAAR,EAAA3X,QAAA+X,EAAA,OACA,IAAArQ,EAAAqQ,EAAAlK,YAAA,KACA,GAAAnG,EAAA,EACA,OAAAiQ,EAOA,GADAI,IAAAvX,MAAA,EAAAkH,GACAqQ,EAAArY,MAAA,qBACA,OAAAiY,IAGAQ,EAIA,OAAApZ,MAAAoZ,EAAA,GAAAra,KAAA,OAAA6Z,EAAAS,OAAAL,EAAA7Y,OAAA,IAIA,IACAgD,EADAmW,GACAnW,EAAAxI,OAAAyL,OAAA,QACA,cAAAjD,IAGA,SAAAoW,EAAAnH,GACA,OAAAA,EA8BA,SAAAoH,EAAApH,GACA,IAAAA,EACA,SAGA,IAAAjS,EAAAiS,EAAAjS,OAEA,GAAAA,EAAA,EACA,SAGA,QAAAiS,EAAAqH,WAAAtZ,EAAA,IACA,KAAAiS,EAAAqH,WAAAtZ,EAAA,IACA,MAAAiS,EAAAqH,WAAAtZ,EAAA,IACA,MAAAiS,EAAAqH,WAAAtZ,EAAA,IACA,MAAAiS,EAAAqH,WAAAtZ,EAAA,IACA,MAAAiS,EAAAqH,WAAAtZ,EAAA,IACA,MAAAiS,EAAAqH,WAAAtZ,EAAA,IACA,KAAAiS,EAAAqH,WAAAtZ,EAAA,IACA,KAAAiS,EAAAqH,WAAAtZ,EAAA,GACA,SAGA,QAAAX,EAAAW,EAAA,GAA4BX,GAAA,EAAQA,IACpC,QAAA4S,EAAAqH,WAAAja,GACA,SAIA,SAgFA,SAAAka,EAAAC,EAAAC,GACA,OAAAD,IAAAC,EACA,EAGAD,EAAAC,EACA,GAGA,EAjIA/e,EAAAgf,YAAAP,EAAAC,EAPA,SAAAvG,GACA,OAAAwG,EAAAxG,GACA,IAAAA,EAGAA,GAWAnY,EAAAif,cAAAR,EAAAC,EAPA,SAAAvG,GACA,OAAAwG,EAAAxG,GACAA,EAAAvR,MAAA,GAGAuR,GAwEAnY,EAAAyZ,2BA5BA,SAAAyF,EAAAC,EAAAC,GACA,IAAAxC,EAAAsC,EAAAtc,OAAAuc,EAAAvc,OACA,WAAAga,EACAA,GAGAA,EAAAsC,EAAA/H,aAAAgI,EAAAhI,aACA,IAAAyF,EACAA,GAGAA,EAAAsC,EAAA9H,eAAA+H,EAAA/H,eACA,IAAAwF,GAAAwC,EACAxC,GAGAA,EAAAsC,EAAAhI,gBAAAiI,EAAAjI,gBACA,IAAA0F,EACAA,GAGAA,EAAAsC,EAAAjI,cAAAkI,EAAAlI,cACA,IAAA2F,EACAA,EAGAsC,EAAA1Q,KAAA2Q,EAAA3Q,UAyCAxO,EAAAkb,oCA5BA,SAAAgE,EAAAC,EAAAE,GACA,IAAAzC,EAAAsC,EAAAjI,cAAAkI,EAAAlI,cACA,WAAA2F,EACAA,GAGAA,EAAAsC,EAAAhI,gBAAAiI,EAAAjI,gBACA,IAAA0F,GAAAyC,EACAzC,GAGAA,EAAAsC,EAAAtc,OAAAuc,EAAAvc,OACA,IAAAga,EACAA,GAGAA,EAAAsC,EAAA/H,aAAAgI,EAAAhI,aACA,IAAAyF,EACAA,GAGAA,EAAAsC,EAAA9H,eAAA+H,EAAA/H,eACA,IAAAwF,EACAA,EAGAsC,EAAA1Q,KAAA2Q,EAAA3Q,UAgDAxO,EAAAsf,oCA5BA,SAAAJ,EAAAC,GACA,IAAAvC,EAAAsC,EAAAjI,cAAAkI,EAAAlI,cACA,WAAA2F,EACAA,GAGAA,EAAAsC,EAAAhI,gBAAAiI,EAAAjI,gBACA,IAAA0F,EACAA,GAGAA,EAAAiC,EAAAK,EAAAtc,OAAAuc,EAAAvc,QACA,IAAAga,EACAA,GAGAA,EAAAsC,EAAA/H,aAAAgI,EAAAhI,aACA,IAAAyF,EACAA,GAGAA,EAAAsC,EAAA9H,eAAA+H,EAAA/H,eACA,IAAAwF,EACAA,EAGAiC,EAAAK,EAAA1Q,KAAA2Q,EAAA3Q,YAOA,SAAApK,EAAApE,GASAA,EAAAwY,qBAAA,EACAxY,EAAAyY,kBAAA,EAgFAzY,EAAAmM,OAAA,SAAAgP,EAAAoE,EAAAC,EAAAhE,GACA,OAAA+D,EAAAja,OACA,SAGA,IAAAwI,EAtEA,SAAA2R,EAAAC,EAAAC,EAAAxE,EAAAoE,EAAAC,EAAAhE,GAUA,IAAAoE,EAAAC,KAAAC,OAAAH,EAAAD,GAAA,GAAAA,EACA9C,EAAA4C,EAAArE,EAAAoE,EAAAK,IAAA,GACA,WAAAhD,EAEAgD,EAEAhD,EAAA,EAEA+C,EAAAC,EAAA,EAEAH,EAAAG,EAAAD,EAAAxE,EAAAoE,EAAAC,EAAAhE,GAKAA,GAAAxb,EAAAyY,kBACAkH,EAAAJ,EAAAja,OAAAqa,GAAA,EAEAC,EAKAA,EAAAF,EAAA,EAEAD,EAAAC,EAAAE,EAAAzE,EAAAoE,EAAAC,EAAAhE,GAIAA,GAAAxb,EAAAyY,kBACAmH,EAEAF,EAAA,KAAAA,EA4BAD,EAAA,EAAAF,EAAAja,OAAA6V,EAAAoE,EACAC,EAAAhE,GAAAxb,EAAAwY,sBACA,GAAA1K,EAAA,EACA,SAMA,KAAAA,EAAA,MACA,IAAA0R,EAAAD,EAAAzR,GAAAyR,EAAAzR,EAAA,UAGAA,EAGA,OAAAA,IAMA,SAAA1J,EAAApE,EAAAsE,GASA,IAAAgR,EAAAhR,EAAA,GACAiV,EAAAzZ,OAAAuD,UAAA0c,eAQA,SAAAvK,IACA1S,KAAAkd,UACAld,KAAAmd,KAAAngB,OAAAyL,OAAA,MAMAiK,EAAAqB,UAAA,SAAAqJ,EAAAC,GAEA,IADA,IAAAC,EAAA,IAAA5K,EACA7Q,EAAA,EAAA6C,EAAA0Y,EAAA5a,OAAuCX,EAAA6C,EAAS7C,IAChDyb,EAAAjD,IAAA+C,EAAAvb,GAAAwb,GAEA,OAAAC,GASA5K,EAAAnS,UAAAyY,KAAA,WACA,OAAAhc,OAAAugB,oBAAAvd,KAAAmd,MAAA3a,QAQAkQ,EAAAnS,UAAA8Z,IAAA,SAAAhF,EAAAgI,GACA,IAAAG,EAAAhL,EAAA0J,YAAA7G,GACAoI,EAAAhH,EAAA5V,KAAAb,KAAAmd,KAAAK,GACAE,EAAA1d,KAAAkd,OAAA1a,OACAib,IAAAJ,GACArd,KAAAkd,OAAAva,KAAA0S,GAEAoI,IACAzd,KAAAmd,KAAAK,GAAAE,IASAhL,EAAAnS,UAAAkW,IAAA,SAAApB,GACA,IAAAmI,EAAAhL,EAAA0J,YAAA7G,GACA,OAAAoB,EAAA5V,KAAAb,KAAAmd,KAAAK,IAQA9K,EAAAnS,UAAA+C,QAAA,SAAA+R,GACA,IAAAmI,EAAAhL,EAAA0J,YAAA7G,GACA,GAAAoB,EAAA5V,KAAAb,KAAAmd,KAAAK,GACA,OAAAxd,KAAAmd,KAAAK,GAEA,UAAAra,MAAA,IAAAkS,EAAA,yBAQA3C,EAAAnS,UAAA8V,GAAA,SAAAsH,GACA,GAAAA,GAAA,GAAAA,EAAA3d,KAAAkd,OAAA1a,OACA,OAAAxC,KAAAkd,OAAAS,GAEA,UAAAxa,MAAA,yBAAAwa,IAQAjL,EAAAnS,UAAAuW,QAAA,WACA,OAAA9W,KAAAkd,OAAApZ,SAGA5G,EAAAwV,YAKA,SAAApR,EAAApE,EAAAsE,GAuCA,IAAAoc,EAAApc,EAAA,GAsDAtE,EAAA2gB,OAAA,SAAAC,GACA,IACAC,EADAC,EAAA,GAGAC,EA3BA,SAAAH,GACA,OAAAA,EAAA,EACA,IAAAA,GAAA,GACA,GAAAA,GAAA,GAwBAI,CAAAJ,GAEA,GACAC,EAzCAI,GAyCAF,EACAA,KAhDA,EAiDAA,EAAA,IAGAF,GAjDA,IAmDAC,GAAAJ,EAAAC,OAAAE,SACIE,EAAA,GAEJ,OAAAD,GAOA9gB,EAAAgb,OAAA,SAAA7C,EAAA+I,EAAAC,GACA,IAGAC,EAAAP,EAvCAD,EACAS,EACAC,EAkCAC,EAAApJ,EAAA7S,OACAiC,EAAA,EACAI,EAAA,EAGA,GACA,GAAAuZ,GAAAK,EACA,UAAAtb,MAAA,8CAIA,GADA4a,EAAAH,EAAA1F,OAAA7C,EAAAyG,WAAAsC,OACA,IAAAL,EACA,UAAA5a,MAAA,yBAAAkS,EAAAC,OAAA8I,EAAA,IAGAE,KA7EA,GA6EAP,GACAA,GA3EAI,GA4EA1Z,GAAAsZ,GAAAlZ,EACAA,GAnFA,QAoFIyZ,GAEJD,EAAAlhB,OAzDA2gB,EAyDArZ,EAxDA8Z,EAAA,MAAAT,GACAU,EAAAV,GAAA,EACAS,GACAC,EACAA,GAqDAH,EAAAlG,KAAAiG,IAMA,SAAA9c,EAAApE,GASA,IAAAwhB,EAAA,mEAAA/a,MAAA,IAKAzG,EAAA2gB,OAAA,SAAAc,GACA,MAAAA,KAAAD,EAAAlc,OACA,OAAAkc,EAAAC,GAEA,UAAA7d,UAAA,6BAAA6d,IAOAzhB,EAAAgb,OAAA,SAAA0G,GAiBA,OAhBA,IAgBAA,MAfA,GAgBAA,EAjBA,GAGA,IAkBAA,MAjBA,IAkBAA,EAnBA,GASA,GANA,IAoBAA,MAnBA,GAoBAA,EArBA,GAOA,GAJA,IAsBAA,EACA,GAtBA,IA0BAA,EACA,IAIA,IAMA,SAAAtd,EAAApE,GA6BA,SAAA2hB,EAAAC,EAAAC,EAAAC,GACA,IAAAhH,EAAA8G,EAAAC,GACAD,EAAAC,GAAAD,EAAAE,GACAF,EAAAE,GAAAhH,EA2BA,SAAAiH,EAAAH,EAAAI,EAAApQ,EAAAqQ,GAKA,GAAArQ,EAAAqQ,EAAA,CAYA,IAAAC,GAjCAC,EAiCAvQ,EAjCAwQ,EAiCAH,EAhCApC,KAAAwC,MAAAF,EAAAtC,KAAAyC,UAAAF,EAAAD,KAiCAxd,EAAAiN,EAAA,EAEA+P,EAAAC,EAAAM,EAAAD,GASA,IARA,IAAAM,EAAAX,EAAAK,GAQAxF,EAAA7K,EAAoB6K,EAAAwF,EAAOxF,IAC3BuF,EAAAJ,EAAAnF,GAAA8F,IAAA,IACA5d,GAAA,EACAgd,EAAAC,EAAAjd,EAAA8X,IAIAkF,EAAAC,EAAAjd,EAAA,EAAA8X,GACA,IAAA+F,EAAA7d,EAAA,EAIAod,EAAAH,EAAAI,EAAApQ,EAAA4Q,EAAA,GACAT,EAAAH,EAAAI,EAAAQ,EAAA,EAAAP,GA1DA,IAAAE,EAAAC,EAsEApiB,EAAA0V,UAAA,SAAAkM,EAAAI,GACAD,EAAAH,EAAAI,EAAA,EAAAJ,EAAAtc,OAAA,QAz1EAlB,EAAApE,QAAAgC,wBCQAoC,EAAApE,QAVA,SAAA0E,EAAA8C,IACA,MAAAA,KAAA9C,EAAAY,UAAAkC,EAAA9C,EAAAY,QAEA,QAAAX,EAAA,EAAA8d,EAAA,IAAAtd,MAAAqC,GAAwC7C,EAAA6C,EAAS7C,IACjD8d,EAAA9d,GAAAD,EAAAC,GAGA,OAAA8d,yBCPA,IAAAC,EAAuBpe,EAAQ,QAW/BF,EAAApE,QATA,SAAA2iB,EAAAC,GACA,GAAAD,EAAA,CACA,oBAAAA,EAAA,OAAAD,EAAAC,EAAAC,GACA,IAAA1gB,EAAApC,OAAAuD,UAAAK,SAAAC,KAAAgf,GAAA/b,MAAA,MAEA,MADA,WAAA1E,GAAAygB,EAAApa,cAAArG,EAAAygB,EAAApa,YAAAiG,MACA,QAAAtM,GAAA,QAAAA,EAAAiD,MAAA0d,KAAAF,GACA,cAAAzgB,GAAA,2CAAA4R,KAAA5R,GAAAwgB,EAAAC,EAAAC,QAAA,wBCmBAxe,EAAApE,QA3BA,SAAA0E,EAAAC,GACA,uBAAAyD,eAAAC,YAAAvI,OAAA4E,GAAA,CACA,IAAAgE,KACAC,GAAA,EACAC,GAAA,EACAC,OAAAhG,EAEA,IACA,QAAAiG,EAAAC,EAAArE,EAAA0D,OAAAC,cAA6CM,GAAAG,EAAAC,EAAAC,QAAAC,QAC7CP,EAAAjD,KAAAqD,EAAA7I,QAEA0E,GAAA+D,EAAApD,SAAAX,GAH4EgE,GAAA,IAKzE,MAAAO,GACHN,GAAA,EACAC,EAAAK,EACG,QACH,IACAP,GAAA,MAAAI,EAAA,QAAAA,EAAA,SACK,QACL,GAAAH,EAAA,MAAAC,GAIA,OAAAH,yCCtBA5I,OAAAC,eAAAC,EAAA,cACAC,OAAA,IAGA,IAAAkI,EAAA,mBAAAC,QAAA,iBAAAA,OAAAC,SAAA,SAAAC,GAAoG,cAAAA,GAAqB,SAAAA,GAAmB,OAAAA,GAAA,mBAAAF,QAAAE,EAAAC,cAAAH,QAAAE,IAAAF,OAAA/E,UAAA,gBAAAiF,GAE5Iwa,EAAA9iB,EAAA8iB,uBAAA,WACA,IAAAvV,EAAA4B,UAAA7J,OAAA,QAAAzC,IAAAsM,UAAA,GAAAA,UAAA,MAEArB,EAAAP,EAAA0G,YAAA,KAEA,OAAAnG,EAAA,EAAAP,IAAAiR,OAAA1Q,EAAA,IASAiV,GANA/iB,EAAAgjB,mBAAA,SAAAzV,GACA,IAAA0V,EAAA/V,EAAA,yBAAAA,CAAAK,GAEA,OAAA0V,IAAA1V,GAGAvN,EAAA+iB,kBAAA,SAAAxV,GACA,iBAAAuG,KAAAvG,KA8DAqC,GA1DA5P,EAAAiQ,mBAAA,SAAA1C,GACA,IAAA0V,EAAA/V,EAAA,yBAAAA,CAAAK,GAEA,WAAA0V,EAAA7c,QAAA,MAOApG,EAAAkQ,QAAA,SAAA3C,EAAA+O,EAAA5V,EAAA6N,GACA,IAAA0O,EAAA/V,EAAA,yBAAAA,CAAAK,GAEA,GAAAL,EAAA,oBAAAA,CAAAK,GACA,OAAA0V,EAGA,IAAAjV,EAAA,UAAAiV,EAwBA,MAtBA,WAAA3G,GACAtO,EAAAsO,EAAA,WAAAtO,EACAA,IAAAzH,QAAA,kBACAG,GAAAuc,IAAA1V,IACAS,IAAA,IAAAtH,EAEA6N,IACAvG,IAAA,IAAAuG,KAGG+H,IACHtO,EAAAsO,EAAA,eAAAtO,EAEAtH,GAAAuc,IAAA1V,IACAS,IAAA,SAAAtH,EAEA6N,IACAvG,IAAA,WAAAuG,KAKAvG,GAGAhO,EAAAmQ,aAAA,SAAA5C,EAAA7G,EAAA6N,GACA,IAAAxG,EAAAb,EAAA,yBAAAA,CAAAK,GAUA,OARA7G,GAAAqH,IAAAR,IACAQ,IAAA,IAAArH,EAEA6N,IACAxG,IAAA,IAAAwG,IAIAxG,GAGAjO,OAAAyL,OAAA,OAEAsE,EAAA,4BACAC,KAoBA,SAAA5C,EAAA6C,GACA,QAAAlN,IAAA+M,QAAA/M,IAAA+M,EAAAG,GACA,OAYA,SAAAA,GACA,OAAAA,GACA,6BACA,OAAA+S,EAEA,wBACA,OAAAC,EAGA,OArBA1S,CAAAN,GAEA,IAAA9P,EAAA2P,EAAAG,GAEA,OAAA9P,IAAA4P,OACA,EAEA5P,EAyCA,SAAAqQ,EAAAP,EAAA9P,GACA,wBAAA8P,EAAA,YAAA5H,EAAA4H,IAWA,OALAH,EAAAG,QADAlN,IAAA5C,EACA4P,EAEA5P,EAGA,WACAsQ,EAAAR,IAXAjQ,OAAA0Q,KAAAT,GAAAU,QAAA,SAAAjC,GACAoB,EAAApB,GAAAuB,EAAAvB,KAeA,SAAA+B,EAAAR,UACAH,EAAAG,GAGA,SAAAW,EAAA5B,GACA,IAAA6B,EAAA7Q,OAAA0Q,KAAA1B,GACA8B,KAEA,SAAAC,IACAF,EAAAF,QAAA,SAAAV,GACAH,EAAAG,GAAAa,EAAAb,KAIA,gBAAAe,GACAH,EAAAF,QAAA,SAAAV,GACAa,EAAAb,GAAAH,EAAAG,GACAH,EAAAG,GAAAjB,EAAAiB,KAEA,IAAAxI,EAAAuJ,IAQA,OANAvJ,GAAA,mBAAAA,EAAAwJ,KACAxJ,EAAAwJ,KAAAF,GAAAG,MAAAH,GAEAA,IAGAtJ,IAjHA,WACA,SAAA0J,EAAAzC,EAAAvO,GACAH,OAAAC,eAAA+P,EAAAtB,GACAvO,QACAuJ,YAAA,EACAC,cAAA,IAIAwH,EAAA,UAAA/D,GACA+D,EAAA,oBAAA/D,GACA+D,EAAA,aAAAX,GACAW,EAAA,UAAAX,GACAW,EAAA,YAAAV,GACAU,EAAA,sBAAAV,GACAU,EAAA,WAAAP,GAfA,GAqHA1Q,EAAAiI,QAAAiF,EACAlN,EAAAgI,kBAAAkF,EACAlN,EAAA+H,WAAAuI,EACAtQ,EAAA8H,QAAAwI,EACAtQ,EAAA6H,oBAAA0I,EACAvQ,EAAA4H,cAAAkI,EACA9P,EAAAE,QAAA4P,sBCjNA1L,EAAApE,QAJA,SAAA0E,GACA,GAAAS,MAAAsD,QAAA/D,GAAA,OAAAA,uBCGAN,EAAApE,QAJA,WACA,UAAA4D,UAAA","file":"vendors~main.3b86e5f3d48d454d387c.js","sourcesContent":["'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nvar _DefaultExportValue = {\n  redbox: {\n    boxSizing: 'border-box',\n    fontFamily: 'sans-serif',\n    position: 'fixed',\n    padding: 10,\n    top: '0px',\n    left: '0px',\n    bottom: '0px',\n    right: '0px',\n    width: '100%',\n    background: 'rgb(204, 0, 0)',\n    color: 'white',\n    zIndex: 2147483647,\n    textAlign: 'left',\n    fontSize: '16px',\n    lineHeight: 1.2,\n    overflow: 'auto'\n  },\n  message: {\n    fontWeight: 'bold'\n  },\n  stack: {\n    fontFamily: 'monospace',\n    marginTop: '2em'\n  },\n  frame: {\n    marginTop: '1em'\n  },\n  file: {\n    fontSize: '0.8em',\n    color: 'rgba(255, 255, 255, 0.7)'\n  },\n  linkToFile: {\n    textDecoration: 'none',\n    color: 'rgba(255, 255, 255, 0.7)'\n  }\n};\nexports.default = _DefaultExportValue;","(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 StackFrame(functionName, args, fileName, lineNumber, columnNumber, source) {\n        if (functionName !== undefined) {\n            this.setFunctionName(functionName);\n        }\n        if (args !== undefined) {\n            this.setArgs(args);\n        }\n        if (fileName !== undefined) {\n            this.setFileName(fileName);\n        }\n        if (lineNumber !== undefined) {\n            this.setLineNumber(lineNumber);\n        }\n        if (columnNumber !== undefined) {\n            this.setColumnNumber(columnNumber);\n        }\n        if (source !== undefined) {\n            this.setSource(source);\n        }\n    }\n\n    StackFrame.prototype = {\n        getFunctionName: function () {\n            return this.functionName;\n        },\n        setFunctionName: function (v) {\n            this.functionName = String(v);\n        },\n\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        // NOTE: Property name may be misleading as it includes the path,\n        // but it somewhat mirrors V8's JavaScriptStackTraceApi\n        // https://code.google.com/p/v8/wiki/JavaScriptStackTraceApi and Gecko's\n        // http://mxr.mozilla.org/mozilla-central/source/xpcom/base/nsIException.idl#14\n        getFileName: function () {\n            return this.fileName;\n        },\n        setFileName: function (v) {\n            this.fileName = String(v);\n        },\n\n        getLineNumber: function () {\n            return this.lineNumber;\n        },\n        setLineNumber: function (v) {\n            if (!_isNumber(v)) {\n                throw new TypeError('Line Number must be a Number');\n            }\n            this.lineNumber = Number(v);\n        },\n\n        getColumnNumber: function () {\n            return this.columnNumber;\n        },\n        setColumnNumber: function (v) {\n            if (!_isNumber(v)) {\n                throw new TypeError('Column Number must be a Number');\n            }\n            this.columnNumber = Number(v);\n        },\n\n        getSource: function () {\n            return this.source;\n        },\n        setSource: function (v) {\n            this.source = String(v);\n        },\n\n        toString: function() {\n            var functionName = this.getFunctionName() || '{anonymous}';\n            var args = '(' + (this.getArgs() || []).join(',') + ')';\n            var fileName = this.getFileName() ? ('@' + this.getFileName()) : '';\n            var lineNumber = _isNumber(this.getLineNumber()) ? (':' + this.getLineNumber()) : '';\n            var columnNumber = _isNumber(this.getColumnNumber()) ? (':' + this.getColumnNumber()) : '';\n            return functionName + args + fileName + lineNumber + columnNumber;\n        }\n    };\n\n    return StackFrame;\n}));\n","var arrayWithHoles = require(\"./arrayWithHoles\");\n\nvar iterableToArrayLimit = require(\"./iterableToArrayLimit\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray\");\n\nvar nonIterableRest = require(\"./nonIterableRest\");\n\nfunction _slicedToArray(arr, i) {\n  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}\n\nmodule.exports = _slicedToArray;","(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    function _map(array, fn, thisArg) {\n        if (typeof Array.prototype.map === 'function') {\n            return array.map(fn, thisArg);\n        } else {\n            var output = new Array(array.length);\n            for (var i = 0; i < array.length; i++) {\n                output[i] = fn.call(thisArg, array[i]);\n            }\n            return output;\n        }\n    }\n\n    function _filter(array, fn, thisArg) {\n        if (typeof Array.prototype.filter === 'function') {\n            return array.filter(fn, thisArg);\n        } else {\n            var output = [];\n            for (var i = 0; i < array.length; i++) {\n                if (fn.call(thisArg, array[i])) {\n                    output.push(array[i]);\n                }\n            }\n            return output;\n        }\n    }\n\n    function _indexOf(array, target) {\n        if (typeof Array.prototype.indexOf === 'function') {\n            return array.indexOf(target);\n        } else {\n            for (var i = 0; i < array.length; i++) {\n                if (array[i] === target) {\n                    return i;\n                }\n            }\n            return -1;\n        }\n    }\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 = _filter(error.stack.split('\\n'), function(line) {\n                return !!line.match(CHROME_IE_STACK_REGEXP);\n            }, this);\n\n            return _map(filtered, 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 tokens = line.replace(/^\\s+/, '').replace(/\\(eval code/g, '(').split(/\\s+/).slice(1);\n                var locationParts = this.extractLocation(tokens.pop());\n                var functionName = tokens.join(' ') || undefined;\n                var fileName = _indexOf(['eval', '<anonymous>'], locationParts[0]) > -1 ? undefined : locationParts[0];\n\n                return new StackFrame(functionName, undefined, fileName, locationParts[1], locationParts[2], line);\n            }, this);\n        },\n\n        parseFFOrSafari: function ErrorStackParser$$parseFFOrSafari(error) {\n            var filtered = _filter(error.stack.split('\\n'), function(line) {\n                return !line.match(SAFARI_NATIVE_CODE_REGEXP);\n            }, this);\n\n            return _map(filtered, 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(line);\n                } else {\n                    var tokens = line.split('@');\n                    var locationParts = this.extractLocation(tokens.pop());\n                    var functionName = tokens.join('@') || undefined;\n                    return new StackFrame(functionName,\n                        undefined,\n                        locationParts[0],\n                        locationParts[1],\n                        locationParts[2],\n                        line);\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(undefined, undefined, match[2], match[1], undefined, lines[i]));\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                            match[3] || undefined,\n                            undefined,\n                            match[2],\n                            match[1],\n                            undefined,\n                            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 = _filter(error.stack.split('\\n'), function(line) {\n                return !!line.match(FIREFOX_SAFARI_STACK_REGEXP) && !line.match(/^Error created at/);\n            }, this);\n\n            return _map(filtered, 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                return new StackFrame(\n                    functionName,\n                    args,\n                    locationParts[0],\n                    locationParts[1],\n                    locationParts[2],\n                    line);\n            }, this);\n        }\n    };\n}));\n\n","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.__RewireAPI__ = exports.__ResetDependency__ = exports.__set__ = exports.__Rewire__ = exports.__GetDependency__ = exports.__get__ = exports.RedBoxError = undefined;\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nvar _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"]) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError(\"Invalid attempt to destructure non-iterable instance\"); } }; }();\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _propTypes = require('prop-types');\n\nvar _propTypes2 = _interopRequireDefault(_propTypes);\n\nvar _react = require('react');\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _reactDom = require('react-dom');\n\nvar _reactDom2 = _interopRequireDefault(_reactDom);\n\nvar _style = require('./style.js');\n\nvar _style2 = _interopRequireDefault(_style);\n\nvar _errorStackParser = require('error-stack-parser');\n\nvar _errorStackParser2 = _interopRequireDefault(_errorStackParser);\n\nvar _objectAssign = require('object-assign');\n\nvar _objectAssign2 = _interopRequireDefault(_objectAssign);\n\nvar _lib = require('./lib');\n\nvar _sourcemappedStacktrace = require('sourcemapped-stacktrace');\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar RedBoxError = exports.RedBoxError = function (_get__2) {\n  _inherits(RedBoxError, _get__2);\n\n  function RedBoxError(props) {\n    _classCallCheck(this, RedBoxError);\n\n    var _this = _possibleConstructorReturn(this, (RedBoxError.__proto__ || Object.getPrototypeOf(RedBoxError)).call(this, props));\n\n    _this.state = {\n      error: null,\n      mapped: false\n    };\n\n    _this.mapOnConstruction(props.error);\n    return _this;\n  }\n\n  // State is used to store the error mapped to the source map.\n\n\n  _createClass(RedBoxError, [{\n    key: 'componentDidMount',\n    value: function componentDidMount() {\n      if (!this.state.mapped) this.mapError(this.props.error);\n    }\n\n    // Try to map the error when the component gets constructed, this is possible\n    // in some cases like evals.\n\n  }, {\n    key: 'mapOnConstruction',\n    value: function mapOnConstruction(error) {\n      var stackLines = error.stack.split('\\n');\n\n      // There's no stack, only the error message.\n      if (stackLines.length < 2) {\n        this.state = { error: error, mapped: true };\n        return;\n      }\n\n      // Using the “eval” setting on webpack already gives the correct location.\n      var isWebpackEval = stackLines[1].search(/\\(webpack:\\/{3}/) !== -1;\n      if (isWebpackEval) {\n        // No changes are needed here.\n        this.state = { error: error, mapped: true };\n        return;\n      }\n\n      // Other eval follow a specific pattern and can be easily parsed.\n      var isEval = stackLines[1].search(/\\(eval at/) !== -1;\n      if (!isEval) {\n        // mapping will be deferred until `componentDidMount`\n        this.state = { error: error, mapped: false };\n        return;\n      }\n\n      // The first line is the error message.\n      var fixedLines = [stackLines.shift()];\n      // The rest needs to be fixed.\n      var _iteratorNormalCompletion = true;\n      var _didIteratorError = false;\n      var _iteratorError = undefined;\n\n      try {\n        for (var _iterator = stackLines[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {\n          var stackLine = _step.value;\n\n          var evalStackLine = stackLine.match(/(.+)\\(eval at (.+) \\(.+?\\), .+(\\:[0-9]+\\:[0-9]+)\\)/);\n          if (evalStackLine) {\n            var _evalStackLine = _slicedToArray(evalStackLine, 4),\n                atSomething = _evalStackLine[1],\n                file = _evalStackLine[2],\n                rowColumn = _evalStackLine[3];\n\n            fixedLines.push(atSomething + ' (' + file + rowColumn + ')');\n          } else {\n            // TODO: When stack frames of different types are detected, try to load the additional source maps\n            fixedLines.push(stackLine);\n          }\n        }\n      } catch (err) {\n        _didIteratorError = true;\n        _iteratorError = err;\n      } finally {\n        try {\n          if (!_iteratorNormalCompletion && _iterator.return) {\n            _iterator.return();\n          }\n        } finally {\n          if (_didIteratorError) {\n            throw _iteratorError;\n          }\n        }\n      }\n\n      error.stack = fixedLines.join('\\n');\n      this.state = { error: error, mapped: true };\n    }\n  }, {\n    key: 'mapError',\n    value: function mapError(error) {\n      var _this2 = this;\n\n      _get__('mapStackTrace')(error.stack, function (mappedStack) {\n        error.stack = mappedStack.join('\\n');\n        _this2.setState({ error: error, mapped: true });\n      });\n    }\n  }, {\n    key: 'renderFrames',\n    value: function renderFrames(frames) {\n      var _props = this.props,\n          filename = _props.filename,\n          editorScheme = _props.editorScheme,\n          useLines = _props.useLines,\n          useColumns = _props.useColumns;\n\n      var _get__3 = _get__('assign')({}, _get__('style'), this.props.style),\n          frame = _get__3.frame,\n          file = _get__3.file,\n          linkToFile = _get__3.linkToFile;\n\n      return frames.map(function (f, index) {\n        var text = void 0;\n        var url = void 0;\n\n        if (index === 0 && filename && !_get__('isFilenameAbsolute')(f.fileName)) {\n          url = _get__('makeUrl')(filename, editorScheme);\n          text = _get__('makeLinkText')(filename);\n        } else {\n          var lines = useLines ? f.lineNumber : null;\n          var columns = useColumns ? f.columnNumber : null;\n          url = _get__('makeUrl')(f.fileName, editorScheme, lines, columns);\n          text = _get__('makeLinkText')(f.fileName, lines, columns);\n        }\n\n        return _get__('React').createElement(\n          'div',\n          { style: frame, key: index },\n          _get__('React').createElement(\n            'div',\n            null,\n            f.functionName\n          ),\n          _get__('React').createElement(\n            'div',\n            { style: file },\n            _get__('React').createElement(\n              'a',\n              { href: url, style: linkToFile },\n              text\n            )\n          )\n        );\n      });\n    }\n  }, {\n    key: 'render',\n    value: function render() {\n      // The error is received as a property to initialize state.error, which may\n      // be updated when it is mapped to the source map.\n      var error = this.state.error;\n      var className = this.props.className;\n\n      var _get__4 = _get__('assign')({}, _get__('style'), this.props.style),\n          redbox = _get__4.redbox,\n          message = _get__4.message,\n          stack = _get__4.stack,\n          frame = _get__4.frame;\n\n      var frames = void 0;\n      var parseError = void 0;\n      try {\n        frames = _get__('ErrorStackParser').parse(error);\n      } catch (e) {\n        parseError = new Error('Failed to parse stack trace. Stack trace information unavailable.');\n      }\n\n      if (parseError) {\n        frames = _get__('React').createElement(\n          'div',\n          { style: frame, key: 0 },\n          _get__('React').createElement(\n            'div',\n            null,\n            parseError.message\n          )\n        );\n      } else {\n        frames = this.renderFrames(frames);\n      }\n\n      return _get__('React').createElement(\n        'div',\n        { style: redbox, className: className },\n        _get__('React').createElement(\n          'div',\n          { style: message },\n          error.name,\n          ': ',\n          error.message\n        ),\n        _get__('React').createElement(\n          'div',\n          { style: stack },\n          frames\n        )\n      );\n    }\n  }]);\n\n  return RedBoxError;\n}(_get__('Component'));\n\n// \"Portal\" component for actual RedBoxError component to\n// render to (directly under body). Prevents bugs as in #27.\n\n\nRedBoxError.propTypes = {\n  error: _get__('PropTypes').instanceOf(Error).isRequired,\n  filename: _get__('PropTypes').string,\n  editorScheme: _get__('PropTypes').string,\n  useLines: _get__('PropTypes').bool,\n  useColumns: _get__('PropTypes').bool,\n  style: _get__('PropTypes').object,\n  className: _get__('PropTypes').string\n};\nRedBoxError.displayName = 'RedBoxError';\nRedBoxError.defaultProps = {\n  useLines: true,\n  useColumns: true };\n\nvar RedBox = function (_get__5) {\n  _inherits(RedBox, _get__5);\n\n  function RedBox() {\n    _classCallCheck(this, RedBox);\n\n    return _possibleConstructorReturn(this, (RedBox.__proto__ || Object.getPrototypeOf(RedBox)).apply(this, arguments));\n  }\n\n  _createClass(RedBox, [{\n    key: 'componentDidMount',\n    value: function componentDidMount() {\n      this.el = document.createElement('div');\n      document.body.appendChild(this.el);\n      this.renderRedBoxError();\n    }\n  }, {\n    key: 'componentDidUpdate',\n    value: function componentDidUpdate() {\n      this.renderRedBoxError();\n    }\n  }, {\n    key: 'componentWillUnmount',\n    value: function componentWillUnmount() {\n      _get__('ReactDOM').unmountComponentAtNode(this.el);\n      document.body.removeChild(this.el);\n      this.el = null;\n    }\n  }, {\n    key: 'renderRedBoxError',\n    value: function renderRedBoxError() {\n      _get__('ReactDOM').render(_get__('React').createElement(_get__('RedBoxError'), this.props), this.el);\n    }\n  }, {\n    key: 'render',\n    value: function render() {\n      return null;\n    }\n  }]);\n\n  return RedBox;\n}(_get__('Component'));\n\nRedBox.propTypes = {\n  error: _get__('PropTypes').instanceOf(Error).isRequired\n};\nRedBox.displayName = 'RedBox';\nexports.default = RedBox;\n\nvar _RewiredData__ = Object.create(null);\n\nvar INTENTIONAL_UNDEFINED = '__INTENTIONAL_UNDEFINED__';\nvar _RewireAPI__ = {};\n\n(function () {\n  function addPropertyToAPIObject(name, value) {\n    Object.defineProperty(_RewireAPI__, name, {\n      value: value,\n      enumerable: false,\n      configurable: true\n    });\n  }\n\n  addPropertyToAPIObject('__get__', _get__);\n  addPropertyToAPIObject('__GetDependency__', _get__);\n  addPropertyToAPIObject('__Rewire__', _set__);\n  addPropertyToAPIObject('__set__', _set__);\n  addPropertyToAPIObject('__reset__', _reset__);\n  addPropertyToAPIObject('__ResetDependency__', _reset__);\n  addPropertyToAPIObject('__with__', _with__);\n})();\n\nfunction _get__(variableName) {\n  if (_RewiredData__ === undefined || _RewiredData__[variableName] === undefined) {\n    return _get_original__(variableName);\n  } else {\n    var value = _RewiredData__[variableName];\n\n    if (value === INTENTIONAL_UNDEFINED) {\n      return undefined;\n    } else {\n      return value;\n    }\n  }\n}\n\nfunction _get_original__(variableName) {\n  switch (variableName) {\n    case 'PropTypes':\n      return _propTypes2.default;\n\n    case 'mapStackTrace':\n      return _sourcemappedStacktrace.mapStackTrace;\n\n    case 'assign':\n      return _objectAssign2.default;\n\n    case 'style':\n      return _style2.default;\n\n    case 'isFilenameAbsolute':\n      return _lib.isFilenameAbsolute;\n\n    case 'makeUrl':\n      return _lib.makeUrl;\n\n    case 'makeLinkText':\n      return _lib.makeLinkText;\n\n    case 'ErrorStackParser':\n      return _errorStackParser2.default;\n\n    case 'Component':\n      return _react.Component;\n\n    case 'ReactDOM':\n      return _reactDom2.default;\n\n    case 'React':\n      return _react2.default;\n\n    case 'RedBoxError':\n      return RedBoxError;\n  }\n\n  return undefined;\n}\n\nfunction _assign__(variableName, value) {\n  if (_RewiredData__ === undefined || _RewiredData__[variableName] === undefined) {\n    return _set_original__(variableName, value);\n  } else {\n    return _RewiredData__[variableName] = value;\n  }\n}\n\nfunction _set_original__(variableName, _value) {\n  switch (variableName) {}\n\n  return undefined;\n}\n\nfunction _update_operation__(operation, variableName, prefix) {\n  var oldValue = _get__(variableName);\n\n  var newValue = operation === '++' ? oldValue + 1 : oldValue - 1;\n\n  _assign__(variableName, newValue);\n\n  return prefix ? newValue : oldValue;\n}\n\nfunction _set__(variableName, value) {\n  if ((typeof variableName === 'undefined' ? 'undefined' : _typeof(variableName)) === 'object') {\n    Object.keys(variableName).forEach(function (name) {\n      _RewiredData__[name] = variableName[name];\n    });\n  } else {\n    if (value === undefined) {\n      _RewiredData__[variableName] = INTENTIONAL_UNDEFINED;\n    } else {\n      _RewiredData__[variableName] = value;\n    }\n\n    return function () {\n      _reset__(variableName);\n    };\n  }\n}\n\nfunction _reset__(variableName) {\n  delete _RewiredData__[variableName];\n}\n\nfunction _with__(object) {\n  var rewiredVariableNames = Object.keys(object);\n  var previousValues = {};\n\n  function reset() {\n    rewiredVariableNames.forEach(function (variableName) {\n      _RewiredData__[variableName] = previousValues[variableName];\n    });\n  }\n\n  return function (callback) {\n    rewiredVariableNames.forEach(function (variableName) {\n      previousValues[variableName] = _RewiredData__[variableName];\n      _RewiredData__[variableName] = object[variableName];\n    });\n    var result = callback();\n\n    if (!!result && typeof result.then == 'function') {\n      result.then(reset).catch(reset);\n    } else {\n      reset();\n    }\n\n    return result;\n  };\n}\n\nvar _typeOfOriginalExport = typeof RedBox === 'undefined' ? 'undefined' : _typeof(RedBox);\n\nfunction addNonEnumerableProperty(name, value) {\n  Object.defineProperty(RedBox, name, {\n    value: value,\n    enumerable: false,\n    configurable: true\n  });\n}\n\nif ((_typeOfOriginalExport === 'object' || _typeOfOriginalExport === 'function') && Object.isExtensible(RedBox)) {\n  addNonEnumerableProperty('__get__', _get__);\n  addNonEnumerableProperty('__GetDependency__', _get__);\n  addNonEnumerableProperty('__Rewire__', _set__);\n  addNonEnumerableProperty('__set__', _set__);\n  addNonEnumerableProperty('__reset__', _reset__);\n  addNonEnumerableProperty('__ResetDependency__', _reset__);\n  addNonEnumerableProperty('__with__', _with__);\n  addNonEnumerableProperty('__RewireAPI__', _RewireAPI__);\n}\n\nexports.__get__ = _get__;\nexports.__GetDependency__ = _get__;\nexports.__Rewire__ = _set__;\nexports.__set__ = _set__;\nexports.__ResetDependency__ = _reset__;\nexports.__RewireAPI__ = _RewireAPI__;","(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"sourceMappedStackTrace\"] = factory();\n\telse\n\t\troot[\"sourceMappedStackTrace\"] = factory();\n})(this, function() {\nreturn /******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId])\n/******/ \t\t\treturn installedModules[moduleId].exports;\n\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\texports: {},\n/******/ \t\t\tid: moduleId,\n/******/ \t\t\tloaded: false\n/******/ \t\t};\n\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.loaded = true;\n\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n\n\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(0);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*\n\t * sourcemapped-stacktrace.js\n\t * created by James Salter <iteration@gmail.com> (2014)\n\t *\n\t * https://github.com/novocaine/sourcemapped-stacktrace\n\t *\n\t * Licensed under the New BSD license. See LICENSE or:\n\t * http://opensource.org/licenses/BSD-3-Clause\n\t */\n\n\t/*global define */\n\n\t// note we only include source-map-consumer, not the whole source-map library,\n\t// which includes gear for generating source maps that we don't need\n\t!(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(1)], __WEBPACK_AMD_DEFINE_RESULT__ = function(source_map_consumer) {\n\n\t  var global_mapForUri = {};\n\n\t  /**\n\t   * Re-map entries in a stacktrace using sourcemaps if available.\n\t   *\n\t   * @param {Array} stack - Array of strings from the browser's stack\n\t   *                        representation. Currently only Chrome\n\t   *                        format is supported.\n\t   * @param {function} done - Callback invoked with the transformed stacktrace\n\t   *                          (an Array of Strings) passed as the first\n\t   *                          argument\n\t   * @param {Object} [opts] - Optional options object.\n\t   * @param {Function} [opts.filter] - Filter function applied to each stackTrace line.\n\t   *                                   Lines which do not pass the filter won't be processesd.\n\t   * @param {boolean} [opts.cacheGlobally] - Whether to cache sourcemaps globally across multiple calls.\n\t   */\n\t  var mapStackTrace = function(stack, done, opts) {\n\t    var lines;\n\t    var line;\n\t    var mapForUri = {};\n\t    var rows = {};\n\t    var fields;\n\t    var uri;\n\t    var expected_fields;\n\t    var regex;\n\t    var skip_lines;\n\n\t    var fetcher = new Fetcher(function() {\n\t      var result = processSourceMaps(lines, rows, fetcher.mapForUri);\n\t      done(result);\n\t    }, opts);\n\n\t    if (isChromeOrEdge() || isIE11Plus()) {\n\t      regex = /^ +at.+\\((.*):([0-9]+):([0-9]+)/;\n\t      expected_fields = 4;\n\t      // (skip first line containing exception message)\n\t      skip_lines = 1;\n\t    } else if (isFirefox() || isSafari()) {\n\t      regex = /@(.*):([0-9]+):([0-9]+)/;\n\t      expected_fields = 4;\n\t      skip_lines = 0;\n\t    } else {\n\t      throw new Error(\"unknown browser :(\");\n\t    }\n\n\t    lines = stack.split(\"\\n\").slice(skip_lines);\n\n\t    for (var i=0; i < lines.length; i++) {\n\t      line = lines[i];\n\t      if ( opts && opts.filter && !opts.filter(line) ) continue;\n\t      \n\t      fields = line.match(regex);\n\t      if (fields && fields.length === expected_fields) {\n\t        rows[i] = fields;\n\t        uri = fields[1];\n\t        if (!uri.match(/<anonymous>/)) {\n\t          fetcher.fetchScript(uri);\n\t        }\n\t      }\n\t    }\n\n\t    // if opts.cacheGlobally set, all maps could have been cached already,\n\t    // thus we need to call done callback right away\n\t    if ( fetcher.sem === 0 ) {\n\t      fetcher.done(fetcher.mapForUri);\n\t    }\n\t  };\n\n\t  var isChromeOrEdge = function() {\n\t    return navigator.userAgent.toLowerCase().indexOf('chrome') > -1;\n\t  };\n\n\t  var isFirefox = function() {\n\t    return navigator.userAgent.toLowerCase().indexOf('firefox') > -1;\n\t  };  \n\n\t  var isSafari = function() {\n\t    return navigator.userAgent.toLowerCase().indexOf('safari') > -1;\n\t  };\n\t\t\t\n\t  var isIE11Plus = function() {\n\t   \treturn document.documentMode && document.documentMode >= 11;\n\t  };\n\n\t  var Fetcher = function(done, opts) {\n\t    this.sem = 0;\n\t    this.mapForUri = opts && opts.cacheGlobally ? global_mapForUri : {};\n\t    this.done = done;\n\t  };\n\n\t  Fetcher.prototype.fetchScript = function(uri) {\n\t    if (!(uri in this.mapForUri)) {\n\t      this.sem++;\n\t      this.mapForUri[uri] = null;\n\t    } else {\n\t      return;\n\t    }\n\n\t    var xhr = createXMLHTTPObject();\n\t    var that = this;\n\t    xhr.onreadystatechange = function(e) {\n\t      that.onScriptLoad.call(that, e, uri);\n\t    };\n\t    xhr.open(\"GET\", uri, true);\n\t    xhr.send();\n\t  };\n\n\t  var absUrlRegex = new RegExp('^(?:[a-z]+:)?//', 'i');\n\n\t  Fetcher.prototype.onScriptLoad = function(e, uri) {\n\t    if (e.target.readyState !== 4) {\n\t      return;\n\t    }\n\n\t    if (e.target.status === 200 ||\n\t      (uri.slice(0, 7) === \"file://\" && e.target.status === 0))\n\t    {\n\t      // find .map in file.\n\t      //\n\t      // attempt to find it at the very end of the file, but tolerate trailing\n\t      // whitespace inserted by some packers.\n\t      var match = e.target.responseText.match(\"//# [s]ourceMappingURL=(.*)[\\\\s]*$\", \"m\");\n\t      if (match && match.length === 2) {\n\t        // get the map\n\t        var mapUri = match[1];\n\n\t        var embeddedSourceMap = mapUri.match(\"data:application/json;(charset=[^;]+;)?base64,(.*)\");\n\n\t        if (embeddedSourceMap && embeddedSourceMap[2]) {\n\t          this.mapForUri[uri] = new source_map_consumer.SourceMapConsumer(atob(embeddedSourceMap[2]));\n\t          this.done(this.mapForUri);\n\t        } else {\n\t          if (!absUrlRegex.test(mapUri)) {\n\t            // relative url; according to sourcemaps spec is 'source origin'\n\t            var origin;\n\t            var lastSlash = uri.lastIndexOf('/');\n\t            if (lastSlash !== -1) {\n\t              origin = uri.slice(0, lastSlash + 1);\n\t              mapUri = origin + mapUri;\n\t              // note if lastSlash === -1, actual script uri has no slash\n\t              // somehow, so no way to use it as a prefix... we give up and try\n\t              // as absolute\n\t            }\n\t          }\n\n\t          var xhrMap = createXMLHTTPObject();\n\t          var that = this;\n\t          xhrMap.onreadystatechange = function() {\n\t            if (xhrMap.readyState === 4) {\n\t              that.sem--;\n\t              if (xhrMap.status === 200 ||\n\t                (mapUri.slice(0, 7) === \"file://\" && xhrMap.status === 0)) {\n\t                that.mapForUri[uri] = new source_map_consumer.SourceMapConsumer(xhrMap.responseText);\n\t              }\n\t              if (that.sem === 0) {\n\t                that.done(that.mapForUri);\n\t              }\n\t            }\n\t          };\n\n\t          xhrMap.open(\"GET\", mapUri, true);\n\t          xhrMap.send();\n\t        }\n\t      } else {\n\t        // no map\n\t        this.sem--;\n\t      }\n\t    } else {\n\t      // HTTP error fetching uri of the script\n\t      this.sem--;\n\t    }\n\n\t    if (this.sem === 0) {\n\t      this.done(this.mapForUri);\n\t    }\n\t  };\n\n\t  var processSourceMaps = function(lines, rows, mapForUri) {\n\t    var result = [];\n\t    var map;\n\t    for (var i=0; i < lines.length; i++) {\n\t      var row = rows[i];\n\t      if (row) {\n\t        var uri = row[1];\n\t        var line = parseInt(row[2], 10);\n\t        var column = parseInt(row[3], 10);\n\t        map = mapForUri[uri];\n\n\t        if (map) {\n\t          // we think we have a map for that uri. call source-map library\n\t          var origPos = map.originalPositionFor(\n\t            { line: line, column: column });\n\t          result.push(formatOriginalPosition(origPos.source,\n\t            origPos.line, origPos.column, origPos.name || origName(lines[i])));\n\t        } else {\n\t          // we can't find a map for that url, but we parsed the row.\n\t          // reformat unchanged line for consistency with the sourcemapped\n\t          // lines.\n\t          result.push(formatOriginalPosition(uri, line, column, origName(lines[i])));\n\t        }\n\t      } else {\n\t        // we weren't able to parse the row, push back what we were given\n\t        result.push(lines[i]);\n\t      }\n\t    }\n\n\t    return result;\n\t  };\n\n\t  function origName(origLine) {\n\t    var match = String(origLine).match((isChromeOrEdge() || isIE11Plus()) ?\n\t      / +at +([^ ]*).*/ :\n\t      /([^@]*)@.*/);\n\t    return match && match[1];\n\t  }\n\n\t  var formatOriginalPosition = function(source, line, column, name) {\n\t    // mimic chrome's format\n\t    return \"    at \" + (name ? name : \"(unknown)\") +\n\t      \" (\" + source + \":\" + line + \":\" + column + \")\";\n\t  };\n\n\t  // xmlhttprequest boilerplate\n\t  var XMLHttpFactories = [\n\t\tfunction () {return new XMLHttpRequest();},\n\t\tfunction () {return new ActiveXObject(\"Msxml2.XMLHTTP\");},\n\t\tfunction () {return new ActiveXObject(\"Msxml3.XMLHTTP\");},\n\t\tfunction () {return new ActiveXObject(\"Microsoft.XMLHTTP\");}\n\t  ];\n\n\t  function createXMLHTTPObject() {\n\t      var xmlhttp = false;\n\t      for (var i=0;i<XMLHttpFactories.length;i++) {\n\t          try {\n\t              xmlhttp = XMLHttpFactories[i]();\n\t          }\n\t          catch (e) {\n\t              continue;\n\t          }\n\t          break;\n\t      }\n\t      return xmlhttp;\n\t  }\n\n\t  return {\n\t    mapStackTrace: mapStackTrace\n\t  }\n\t}.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\n\n/***/ },\n/* 1 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t/* -*- Mode: js; js-indent-level: 2; -*- */\n\t/*\n\t * Copyright 2011 Mozilla Foundation and contributors\n\t * Licensed under the New BSD license. See LICENSE or:\n\t * http://opensource.org/licenses/BSD-3-Clause\n\t */\n\n\tvar util = __webpack_require__(2);\n\tvar binarySearch = __webpack_require__(3);\n\tvar ArraySet = __webpack_require__(4).ArraySet;\n\tvar base64VLQ = __webpack_require__(5);\n\tvar quickSort = __webpack_require__(7).quickSort;\n\n\tfunction SourceMapConsumer(aSourceMap) {\n\t  var sourceMap = aSourceMap;\n\t  if (typeof aSourceMap === 'string') {\n\t    sourceMap = JSON.parse(aSourceMap.replace(/^\\)\\]\\}'/, ''));\n\t  }\n\n\t  return sourceMap.sections != null\n\t    ? new IndexedSourceMapConsumer(sourceMap)\n\t    : new BasicSourceMapConsumer(sourceMap);\n\t}\n\n\tSourceMapConsumer.fromSourceMap = function(aSourceMap) {\n\t  return BasicSourceMapConsumer.fromSourceMap(aSourceMap);\n\t}\n\n\t/**\n\t * The version of the source mapping spec that we are consuming.\n\t */\n\tSourceMapConsumer.prototype._version = 3;\n\n\t// `__generatedMappings` and `__originalMappings` are arrays that hold the\n\t// parsed mapping coordinates from the source map's \"mappings\" attribute. They\n\t// are lazily instantiated, accessed via the `_generatedMappings` and\n\t// `_originalMappings` getters respectively, and we only parse the mappings\n\t// and create these arrays once queried for a source location. We jump through\n\t// these hoops because there can be many thousands of mappings, and parsing\n\t// them is expensive, so we only want to do it if we must.\n\t//\n\t// Each object in the arrays is of the form:\n\t//\n\t//     {\n\t//       generatedLine: The line number in the generated code,\n\t//       generatedColumn: The column number in the generated code,\n\t//       source: The path to the original source file that generated this\n\t//               chunk of code,\n\t//       originalLine: The line number in the original source that\n\t//                     corresponds to this chunk of generated code,\n\t//       originalColumn: The column number in the original source that\n\t//                       corresponds to this chunk of generated code,\n\t//       name: The name of the original symbol which generated this chunk of\n\t//             code.\n\t//     }\n\t//\n\t// All properties except for `generatedLine` and `generatedColumn` can be\n\t// `null`.\n\t//\n\t// `_generatedMappings` is ordered by the generated positions.\n\t//\n\t// `_originalMappings` is ordered by the original positions.\n\n\tSourceMapConsumer.prototype.__generatedMappings = null;\n\tObject.defineProperty(SourceMapConsumer.prototype, '_generatedMappings', {\n\t  get: function () {\n\t    if (!this.__generatedMappings) {\n\t      this._parseMappings(this._mappings, this.sourceRoot);\n\t    }\n\n\t    return this.__generatedMappings;\n\t  }\n\t});\n\n\tSourceMapConsumer.prototype.__originalMappings = null;\n\tObject.defineProperty(SourceMapConsumer.prototype, '_originalMappings', {\n\t  get: function () {\n\t    if (!this.__originalMappings) {\n\t      this._parseMappings(this._mappings, this.sourceRoot);\n\t    }\n\n\t    return this.__originalMappings;\n\t  }\n\t});\n\n\tSourceMapConsumer.prototype._charIsMappingSeparator =\n\t  function SourceMapConsumer_charIsMappingSeparator(aStr, index) {\n\t    var c = aStr.charAt(index);\n\t    return c === \";\" || c === \",\";\n\t  };\n\n\t/**\n\t * Parse the mappings in a string in to a data structure which we can easily\n\t * query (the ordered arrays in the `this.__generatedMappings` and\n\t * `this.__originalMappings` properties).\n\t */\n\tSourceMapConsumer.prototype._parseMappings =\n\t  function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {\n\t    throw new Error(\"Subclasses must implement _parseMappings\");\n\t  };\n\n\tSourceMapConsumer.GENERATED_ORDER = 1;\n\tSourceMapConsumer.ORIGINAL_ORDER = 2;\n\n\tSourceMapConsumer.GREATEST_LOWER_BOUND = 1;\n\tSourceMapConsumer.LEAST_UPPER_BOUND = 2;\n\n\t/**\n\t * Iterate over each mapping between an original source/line/column and a\n\t * generated line/column in this source map.\n\t *\n\t * @param Function aCallback\n\t *        The function that is called with each mapping.\n\t * @param Object aContext\n\t *        Optional. If specified, this object will be the value of `this` every\n\t *        time that `aCallback` is called.\n\t * @param aOrder\n\t *        Either `SourceMapConsumer.GENERATED_ORDER` or\n\t *        `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to\n\t *        iterate over the mappings sorted by the generated file's line/column\n\t *        order or the original's source/line/column order, respectively. Defaults to\n\t *        `SourceMapConsumer.GENERATED_ORDER`.\n\t */\n\tSourceMapConsumer.prototype.eachMapping =\n\t  function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {\n\t    var context = aContext || null;\n\t    var order = aOrder || SourceMapConsumer.GENERATED_ORDER;\n\n\t    var mappings;\n\t    switch (order) {\n\t    case SourceMapConsumer.GENERATED_ORDER:\n\t      mappings = this._generatedMappings;\n\t      break;\n\t    case SourceMapConsumer.ORIGINAL_ORDER:\n\t      mappings = this._originalMappings;\n\t      break;\n\t    default:\n\t      throw new Error(\"Unknown order of iteration.\");\n\t    }\n\n\t    var sourceRoot = this.sourceRoot;\n\t    mappings.map(function (mapping) {\n\t      var source = mapping.source === null ? null : this._sources.at(mapping.source);\n\t      if (source != null && sourceRoot != null) {\n\t        source = util.join(sourceRoot, source);\n\t      }\n\t      return {\n\t        source: source,\n\t        generatedLine: mapping.generatedLine,\n\t        generatedColumn: mapping.generatedColumn,\n\t        originalLine: mapping.originalLine,\n\t        originalColumn: mapping.originalColumn,\n\t        name: mapping.name === null ? null : this._names.at(mapping.name)\n\t      };\n\t    }, this).forEach(aCallback, context);\n\t  };\n\n\t/**\n\t * Returns all generated line and column information for the original source,\n\t * line, and column provided. If no column is provided, returns all mappings\n\t * corresponding to a either the line we are searching for or the next\n\t * closest line that has any mappings. Otherwise, returns all mappings\n\t * corresponding to the given line and either the column we are searching for\n\t * or the next closest column that has any offsets.\n\t *\n\t * The only argument is an object with the following properties:\n\t *\n\t *   - source: The filename of the original source.\n\t *   - line: The line number in the original source.\n\t *   - column: Optional. the column number in the original source.\n\t *\n\t * and an array of objects is returned, each with the following properties:\n\t *\n\t *   - line: The line number in the generated source, or null.\n\t *   - column: The column number in the generated source, or null.\n\t */\n\tSourceMapConsumer.prototype.allGeneratedPositionsFor =\n\t  function SourceMapConsumer_allGeneratedPositionsFor(aArgs) {\n\t    var line = util.getArg(aArgs, 'line');\n\n\t    // When there is no exact match, BasicSourceMapConsumer.prototype._findMapping\n\t    // returns the index of the closest mapping less than the needle. By\n\t    // setting needle.originalColumn to 0, we thus find the last mapping for\n\t    // the given line, provided such a mapping exists.\n\t    var needle = {\n\t      source: util.getArg(aArgs, 'source'),\n\t      originalLine: line,\n\t      originalColumn: util.getArg(aArgs, 'column', 0)\n\t    };\n\n\t    if (this.sourceRoot != null) {\n\t      needle.source = util.relative(this.sourceRoot, needle.source);\n\t    }\n\t    if (!this._sources.has(needle.source)) {\n\t      return [];\n\t    }\n\t    needle.source = this._sources.indexOf(needle.source);\n\n\t    var mappings = [];\n\n\t    var index = this._findMapping(needle,\n\t                                  this._originalMappings,\n\t                                  \"originalLine\",\n\t                                  \"originalColumn\",\n\t                                  util.compareByOriginalPositions,\n\t                                  binarySearch.LEAST_UPPER_BOUND);\n\t    if (index >= 0) {\n\t      var mapping = this._originalMappings[index];\n\n\t      if (aArgs.column === undefined) {\n\t        var originalLine = mapping.originalLine;\n\n\t        // Iterate until either we run out of mappings, or we run into\n\t        // a mapping for a different line than the one we found. Since\n\t        // mappings are sorted, this is guaranteed to find all mappings for\n\t        // the line we found.\n\t        while (mapping && mapping.originalLine === originalLine) {\n\t          mappings.push({\n\t            line: util.getArg(mapping, 'generatedLine', null),\n\t            column: util.getArg(mapping, 'generatedColumn', null),\n\t            lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)\n\t          });\n\n\t          mapping = this._originalMappings[++index];\n\t        }\n\t      } else {\n\t        var originalColumn = mapping.originalColumn;\n\n\t        // Iterate until either we run out of mappings, or we run into\n\t        // a mapping for a different line than the one we were searching for.\n\t        // Since mappings are sorted, this is guaranteed to find all mappings for\n\t        // the line we are searching for.\n\t        while (mapping &&\n\t               mapping.originalLine === line &&\n\t               mapping.originalColumn == originalColumn) {\n\t          mappings.push({\n\t            line: util.getArg(mapping, 'generatedLine', null),\n\t            column: util.getArg(mapping, 'generatedColumn', null),\n\t            lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)\n\t          });\n\n\t          mapping = this._originalMappings[++index];\n\t        }\n\t      }\n\t    }\n\n\t    return mappings;\n\t  };\n\n\texports.SourceMapConsumer = SourceMapConsumer;\n\n\t/**\n\t * A BasicSourceMapConsumer instance represents a parsed source map which we can\n\t * query for information about the original file positions by giving it a file\n\t * position in the generated source.\n\t *\n\t * The only parameter is the raw source map (either as a JSON string, or\n\t * already parsed to an object). According to the spec, source maps have the\n\t * following attributes:\n\t *\n\t *   - version: Which version of the source map spec this map is following.\n\t *   - sources: An array of URLs to the original source files.\n\t *   - names: An array of identifiers which can be referrenced by individual mappings.\n\t *   - sourceRoot: Optional. The URL root from which all sources are relative.\n\t *   - sourcesContent: Optional. An array of contents of the original source files.\n\t *   - mappings: A string of base64 VLQs which contain the actual mappings.\n\t *   - file: Optional. The generated file this source map is associated with.\n\t *\n\t * Here is an example source map, taken from the source map spec[0]:\n\t *\n\t *     {\n\t *       version : 3,\n\t *       file: \"out.js\",\n\t *       sourceRoot : \"\",\n\t *       sources: [\"foo.js\", \"bar.js\"],\n\t *       names: [\"src\", \"maps\", \"are\", \"fun\"],\n\t *       mappings: \"AA,AB;;ABCDE;\"\n\t *     }\n\t *\n\t * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit?pli=1#\n\t */\n\tfunction BasicSourceMapConsumer(aSourceMap) {\n\t  var sourceMap = aSourceMap;\n\t  if (typeof aSourceMap === 'string') {\n\t    sourceMap = JSON.parse(aSourceMap.replace(/^\\)\\]\\}'/, ''));\n\t  }\n\n\t  var version = util.getArg(sourceMap, 'version');\n\t  var sources = util.getArg(sourceMap, 'sources');\n\t  // Sass 3.3 leaves out the 'names' array, so we deviate from the spec (which\n\t  // requires the array) to play nice here.\n\t  var names = util.getArg(sourceMap, 'names', []);\n\t  var sourceRoot = util.getArg(sourceMap, 'sourceRoot', null);\n\t  var sourcesContent = util.getArg(sourceMap, 'sourcesContent', null);\n\t  var mappings = util.getArg(sourceMap, 'mappings');\n\t  var file = util.getArg(sourceMap, 'file', null);\n\n\t  // Once again, Sass deviates from the spec and supplies the version as a\n\t  // string rather than a number, so we use loose equality checking here.\n\t  if (version != this._version) {\n\t    throw new Error('Unsupported version: ' + version);\n\t  }\n\n\t  sources = sources\n\t    .map(String)\n\t    // Some source maps produce relative source paths like \"./foo.js\" instead of\n\t    // \"foo.js\".  Normalize these first so that future comparisons will succeed.\n\t    // See bugzil.la/1090768.\n\t    .map(util.normalize)\n\t    // Always ensure that absolute sources are internally stored relative to\n\t    // the source root, if the source root is absolute. Not doing this would\n\t    // be particularly problematic when the source root is a prefix of the\n\t    // source (valid, but why??). See github issue #199 and bugzil.la/1188982.\n\t    .map(function (source) {\n\t      return sourceRoot && util.isAbsolute(sourceRoot) && util.isAbsolute(source)\n\t        ? util.relative(sourceRoot, source)\n\t        : source;\n\t    });\n\n\t  // Pass `true` below to allow duplicate names and sources. While source maps\n\t  // are intended to be compressed and deduplicated, the TypeScript compiler\n\t  // sometimes generates source maps with duplicates in them. See Github issue\n\t  // #72 and bugzil.la/889492.\n\t  this._names = ArraySet.fromArray(names.map(String), true);\n\t  this._sources = ArraySet.fromArray(sources, true);\n\n\t  this.sourceRoot = sourceRoot;\n\t  this.sourcesContent = sourcesContent;\n\t  this._mappings = mappings;\n\t  this.file = file;\n\t}\n\n\tBasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);\n\tBasicSourceMapConsumer.prototype.consumer = SourceMapConsumer;\n\n\t/**\n\t * Create a BasicSourceMapConsumer from a SourceMapGenerator.\n\t *\n\t * @param SourceMapGenerator aSourceMap\n\t *        The source map that will be consumed.\n\t * @returns BasicSourceMapConsumer\n\t */\n\tBasicSourceMapConsumer.fromSourceMap =\n\t  function SourceMapConsumer_fromSourceMap(aSourceMap) {\n\t    var smc = Object.create(BasicSourceMapConsumer.prototype);\n\n\t    var names = smc._names = ArraySet.fromArray(aSourceMap._names.toArray(), true);\n\t    var sources = smc._sources = ArraySet.fromArray(aSourceMap._sources.toArray(), true);\n\t    smc.sourceRoot = aSourceMap._sourceRoot;\n\t    smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(),\n\t                                                            smc.sourceRoot);\n\t    smc.file = aSourceMap._file;\n\n\t    // Because we are modifying the entries (by converting string sources and\n\t    // names to indices into the sources and names ArraySets), we have to make\n\t    // a copy of the entry or else bad things happen. Shared mutable state\n\t    // strikes again! See github issue #191.\n\n\t    var generatedMappings = aSourceMap._mappings.toArray().slice();\n\t    var destGeneratedMappings = smc.__generatedMappings = [];\n\t    var destOriginalMappings = smc.__originalMappings = [];\n\n\t    for (var i = 0, length = generatedMappings.length; i < length; i++) {\n\t      var srcMapping = generatedMappings[i];\n\t      var destMapping = new Mapping;\n\t      destMapping.generatedLine = srcMapping.generatedLine;\n\t      destMapping.generatedColumn = srcMapping.generatedColumn;\n\n\t      if (srcMapping.source) {\n\t        destMapping.source = sources.indexOf(srcMapping.source);\n\t        destMapping.originalLine = srcMapping.originalLine;\n\t        destMapping.originalColumn = srcMapping.originalColumn;\n\n\t        if (srcMapping.name) {\n\t          destMapping.name = names.indexOf(srcMapping.name);\n\t        }\n\n\t        destOriginalMappings.push(destMapping);\n\t      }\n\n\t      destGeneratedMappings.push(destMapping);\n\t    }\n\n\t    quickSort(smc.__originalMappings, util.compareByOriginalPositions);\n\n\t    return smc;\n\t  };\n\n\t/**\n\t * The version of the source mapping spec that we are consuming.\n\t */\n\tBasicSourceMapConsumer.prototype._version = 3;\n\n\t/**\n\t * The list of original sources.\n\t */\n\tObject.defineProperty(BasicSourceMapConsumer.prototype, 'sources', {\n\t  get: function () {\n\t    return this._sources.toArray().map(function (s) {\n\t      return this.sourceRoot != null ? util.join(this.sourceRoot, s) : s;\n\t    }, this);\n\t  }\n\t});\n\n\t/**\n\t * Provide the JIT with a nice shape / hidden class.\n\t */\n\tfunction Mapping() {\n\t  this.generatedLine = 0;\n\t  this.generatedColumn = 0;\n\t  this.source = null;\n\t  this.originalLine = null;\n\t  this.originalColumn = null;\n\t  this.name = null;\n\t}\n\n\t/**\n\t * Parse the mappings in a string in to a data structure which we can easily\n\t * query (the ordered arrays in the `this.__generatedMappings` and\n\t * `this.__originalMappings` properties).\n\t */\n\tBasicSourceMapConsumer.prototype._parseMappings =\n\t  function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {\n\t    var generatedLine = 1;\n\t    var previousGeneratedColumn = 0;\n\t    var previousOriginalLine = 0;\n\t    var previousOriginalColumn = 0;\n\t    var previousSource = 0;\n\t    var previousName = 0;\n\t    var length = aStr.length;\n\t    var index = 0;\n\t    var cachedSegments = {};\n\t    var temp = {};\n\t    var originalMappings = [];\n\t    var generatedMappings = [];\n\t    var mapping, str, segment, end, value;\n\n\t    while (index < length) {\n\t      if (aStr.charAt(index) === ';') {\n\t        generatedLine++;\n\t        index++;\n\t        previousGeneratedColumn = 0;\n\t      }\n\t      else if (aStr.charAt(index) === ',') {\n\t        index++;\n\t      }\n\t      else {\n\t        mapping = new Mapping();\n\t        mapping.generatedLine = generatedLine;\n\n\t        // Because each offset is encoded relative to the previous one,\n\t        // many segments often have the same encoding. We can exploit this\n\t        // fact by caching the parsed variable length fields of each segment,\n\t        // allowing us to avoid a second parse if we encounter the same\n\t        // segment again.\n\t        for (end = index; end < length; end++) {\n\t          if (this._charIsMappingSeparator(aStr, end)) {\n\t            break;\n\t          }\n\t        }\n\t        str = aStr.slice(index, end);\n\n\t        segment = cachedSegments[str];\n\t        if (segment) {\n\t          index += str.length;\n\t        } else {\n\t          segment = [];\n\t          while (index < end) {\n\t            base64VLQ.decode(aStr, index, temp);\n\t            value = temp.value;\n\t            index = temp.rest;\n\t            segment.push(value);\n\t          }\n\n\t          if (segment.length === 2) {\n\t            throw new Error('Found a source, but no line and column');\n\t          }\n\n\t          if (segment.length === 3) {\n\t            throw new Error('Found a source and line, but no column');\n\t          }\n\n\t          cachedSegments[str] = segment;\n\t        }\n\n\t        // Generated column.\n\t        mapping.generatedColumn = previousGeneratedColumn + segment[0];\n\t        previousGeneratedColumn = mapping.generatedColumn;\n\n\t        if (segment.length > 1) {\n\t          // Original source.\n\t          mapping.source = previousSource + segment[1];\n\t          previousSource += segment[1];\n\n\t          // Original line.\n\t          mapping.originalLine = previousOriginalLine + segment[2];\n\t          previousOriginalLine = mapping.originalLine;\n\t          // Lines are stored 0-based\n\t          mapping.originalLine += 1;\n\n\t          // Original column.\n\t          mapping.originalColumn = previousOriginalColumn + segment[3];\n\t          previousOriginalColumn = mapping.originalColumn;\n\n\t          if (segment.length > 4) {\n\t            // Original name.\n\t            mapping.name = previousName + segment[4];\n\t            previousName += segment[4];\n\t          }\n\t        }\n\n\t        generatedMappings.push(mapping);\n\t        if (typeof mapping.originalLine === 'number') {\n\t          originalMappings.push(mapping);\n\t        }\n\t      }\n\t    }\n\n\t    quickSort(generatedMappings, util.compareByGeneratedPositionsDeflated);\n\t    this.__generatedMappings = generatedMappings;\n\n\t    quickSort(originalMappings, util.compareByOriginalPositions);\n\t    this.__originalMappings = originalMappings;\n\t  };\n\n\t/**\n\t * Find the mapping that best matches the hypothetical \"needle\" mapping that\n\t * we are searching for in the given \"haystack\" of mappings.\n\t */\n\tBasicSourceMapConsumer.prototype._findMapping =\n\t  function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName,\n\t                                         aColumnName, aComparator, aBias) {\n\t    // To return the position we are searching for, we must first find the\n\t    // mapping for the given position and then return the opposite position it\n\t    // points to. Because the mappings are sorted, we can use binary search to\n\t    // find the best mapping.\n\n\t    if (aNeedle[aLineName] <= 0) {\n\t      throw new TypeError('Line must be greater than or equal to 1, got '\n\t                          + aNeedle[aLineName]);\n\t    }\n\t    if (aNeedle[aColumnName] < 0) {\n\t      throw new TypeError('Column must be greater than or equal to 0, got '\n\t                          + aNeedle[aColumnName]);\n\t    }\n\n\t    return binarySearch.search(aNeedle, aMappings, aComparator, aBias);\n\t  };\n\n\t/**\n\t * Compute the last column for each generated mapping. The last column is\n\t * inclusive.\n\t */\n\tBasicSourceMapConsumer.prototype.computeColumnSpans =\n\t  function SourceMapConsumer_computeColumnSpans() {\n\t    for (var index = 0; index < this._generatedMappings.length; ++index) {\n\t      var mapping = this._generatedMappings[index];\n\n\t      // Mappings do not contain a field for the last generated columnt. We\n\t      // can come up with an optimistic estimate, however, by assuming that\n\t      // mappings are contiguous (i.e. given two consecutive mappings, the\n\t      // first mapping ends where the second one starts).\n\t      if (index + 1 < this._generatedMappings.length) {\n\t        var nextMapping = this._generatedMappings[index + 1];\n\n\t        if (mapping.generatedLine === nextMapping.generatedLine) {\n\t          mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1;\n\t          continue;\n\t        }\n\t      }\n\n\t      // The last mapping for each line spans the entire line.\n\t      mapping.lastGeneratedColumn = Infinity;\n\t    }\n\t  };\n\n\t/**\n\t * Returns the original source, line, and column information for the generated\n\t * source's line and column positions provided. The only argument is an object\n\t * with the following properties:\n\t *\n\t *   - line: The line number in the generated source.\n\t *   - column: The column number in the generated source.\n\t *   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or\n\t *     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the\n\t *     closest element that is smaller than or greater than the one we are\n\t *     searching for, respectively, if the exact element cannot be found.\n\t *     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.\n\t *\n\t * and an object is returned with the following properties:\n\t *\n\t *   - source: The original source file, or null.\n\t *   - line: The line number in the original source, or null.\n\t *   - column: The column number in the original source, or null.\n\t *   - name: The original identifier, or null.\n\t */\n\tBasicSourceMapConsumer.prototype.originalPositionFor =\n\t  function SourceMapConsumer_originalPositionFor(aArgs) {\n\t    var needle = {\n\t      generatedLine: util.getArg(aArgs, 'line'),\n\t      generatedColumn: util.getArg(aArgs, 'column')\n\t    };\n\n\t    var index = this._findMapping(\n\t      needle,\n\t      this._generatedMappings,\n\t      \"generatedLine\",\n\t      \"generatedColumn\",\n\t      util.compareByGeneratedPositionsDeflated,\n\t      util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)\n\t    );\n\n\t    if (index >= 0) {\n\t      var mapping = this._generatedMappings[index];\n\n\t      if (mapping.generatedLine === needle.generatedLine) {\n\t        var source = util.getArg(mapping, 'source', null);\n\t        if (source !== null) {\n\t          source = this._sources.at(source);\n\t          if (this.sourceRoot != null) {\n\t            source = util.join(this.sourceRoot, source);\n\t          }\n\t        }\n\t        var name = util.getArg(mapping, 'name', null);\n\t        if (name !== null) {\n\t          name = this._names.at(name);\n\t        }\n\t        return {\n\t          source: source,\n\t          line: util.getArg(mapping, 'originalLine', null),\n\t          column: util.getArg(mapping, 'originalColumn', null),\n\t          name: name\n\t        };\n\t      }\n\t    }\n\n\t    return {\n\t      source: null,\n\t      line: null,\n\t      column: null,\n\t      name: null\n\t    };\n\t  };\n\n\t/**\n\t * Return true if we have the source content for every source in the source\n\t * map, false otherwise.\n\t */\n\tBasicSourceMapConsumer.prototype.hasContentsOfAllSources =\n\t  function BasicSourceMapConsumer_hasContentsOfAllSources() {\n\t    if (!this.sourcesContent) {\n\t      return false;\n\t    }\n\t    return this.sourcesContent.length >= this._sources.size() &&\n\t      !this.sourcesContent.some(function (sc) { return sc == null; });\n\t  };\n\n\t/**\n\t * Returns the original source content. The only argument is the url of the\n\t * original source file. Returns null if no original source content is\n\t * available.\n\t */\n\tBasicSourceMapConsumer.prototype.sourceContentFor =\n\t  function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {\n\t    if (!this.sourcesContent) {\n\t      return null;\n\t    }\n\n\t    if (this.sourceRoot != null) {\n\t      aSource = util.relative(this.sourceRoot, aSource);\n\t    }\n\n\t    if (this._sources.has(aSource)) {\n\t      return this.sourcesContent[this._sources.indexOf(aSource)];\n\t    }\n\n\t    var url;\n\t    if (this.sourceRoot != null\n\t        && (url = util.urlParse(this.sourceRoot))) {\n\t      // XXX: file:// URIs and absolute paths lead to unexpected behavior for\n\t      // many users. We can help them out when they expect file:// URIs to\n\t      // behave like it would if they were running a local HTTP server. See\n\t      // https://bugzilla.mozilla.org/show_bug.cgi?id=885597.\n\t      var fileUriAbsPath = aSource.replace(/^file:\\/\\//, \"\");\n\t      if (url.scheme == \"file\"\n\t          && this._sources.has(fileUriAbsPath)) {\n\t        return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)]\n\t      }\n\n\t      if ((!url.path || url.path == \"/\")\n\t          && this._sources.has(\"/\" + aSource)) {\n\t        return this.sourcesContent[this._sources.indexOf(\"/\" + aSource)];\n\t      }\n\t    }\n\n\t    // This function is used recursively from\n\t    // IndexedSourceMapConsumer.prototype.sourceContentFor. In that case, we\n\t    // don't want to throw if we can't find the source - we just want to\n\t    // return null, so we provide a flag to exit gracefully.\n\t    if (nullOnMissing) {\n\t      return null;\n\t    }\n\t    else {\n\t      throw new Error('\"' + aSource + '\" is not in the SourceMap.');\n\t    }\n\t  };\n\n\t/**\n\t * Returns the generated line and column information for the original source,\n\t * line, and column positions provided. The only argument is an object with\n\t * the following properties:\n\t *\n\t *   - source: The filename of the original source.\n\t *   - line: The line number in the original source.\n\t *   - column: The column number in the original source.\n\t *   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or\n\t *     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the\n\t *     closest element that is smaller than or greater than the one we are\n\t *     searching for, respectively, if the exact element cannot be found.\n\t *     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.\n\t *\n\t * and an object is returned with the following properties:\n\t *\n\t *   - line: The line number in the generated source, or null.\n\t *   - column: The column number in the generated source, or null.\n\t */\n\tBasicSourceMapConsumer.prototype.generatedPositionFor =\n\t  function SourceMapConsumer_generatedPositionFor(aArgs) {\n\t    var source = util.getArg(aArgs, 'source');\n\t    if (this.sourceRoot != null) {\n\t      source = util.relative(this.sourceRoot, source);\n\t    }\n\t    if (!this._sources.has(source)) {\n\t      return {\n\t        line: null,\n\t        column: null,\n\t        lastColumn: null\n\t      };\n\t    }\n\t    source = this._sources.indexOf(source);\n\n\t    var needle = {\n\t      source: source,\n\t      originalLine: util.getArg(aArgs, 'line'),\n\t      originalColumn: util.getArg(aArgs, 'column')\n\t    };\n\n\t    var index = this._findMapping(\n\t      needle,\n\t      this._originalMappings,\n\t      \"originalLine\",\n\t      \"originalColumn\",\n\t      util.compareByOriginalPositions,\n\t      util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)\n\t    );\n\n\t    if (index >= 0) {\n\t      var mapping = this._originalMappings[index];\n\n\t      if (mapping.source === needle.source) {\n\t        return {\n\t          line: util.getArg(mapping, 'generatedLine', null),\n\t          column: util.getArg(mapping, 'generatedColumn', null),\n\t          lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)\n\t        };\n\t      }\n\t    }\n\n\t    return {\n\t      line: null,\n\t      column: null,\n\t      lastColumn: null\n\t    };\n\t  };\n\n\texports.BasicSourceMapConsumer = BasicSourceMapConsumer;\n\n\t/**\n\t * An IndexedSourceMapConsumer instance represents a parsed source map which\n\t * we can query for information. It differs from BasicSourceMapConsumer in\n\t * that it takes \"indexed\" source maps (i.e. ones with a \"sections\" field) as\n\t * input.\n\t *\n\t * The only parameter is a raw source map (either as a JSON string, or already\n\t * parsed to an object). According to the spec for indexed source maps, they\n\t * have the following attributes:\n\t *\n\t *   - version: Which version of the source map spec this map is following.\n\t *   - file: Optional. The generated file this source map is associated with.\n\t *   - sections: A list of section definitions.\n\t *\n\t * Each value under the \"sections\" field has two fields:\n\t *   - offset: The offset into the original specified at which this section\n\t *       begins to apply, defined as an object with a \"line\" and \"column\"\n\t *       field.\n\t *   - map: A source map definition. This source map could also be indexed,\n\t *       but doesn't have to be.\n\t *\n\t * Instead of the \"map\" field, it's also possible to have a \"url\" field\n\t * specifying a URL to retrieve a source map from, but that's currently\n\t * unsupported.\n\t *\n\t * Here's an example source map, taken from the source map spec[0], but\n\t * modified to omit a section which uses the \"url\" field.\n\t *\n\t *  {\n\t *    version : 3,\n\t *    file: \"app.js\",\n\t *    sections: [{\n\t *      offset: {line:100, column:10},\n\t *      map: {\n\t *        version : 3,\n\t *        file: \"section.js\",\n\t *        sources: [\"foo.js\", \"bar.js\"],\n\t *        names: [\"src\", \"maps\", \"are\", \"fun\"],\n\t *        mappings: \"AAAA,E;;ABCDE;\"\n\t *      }\n\t *    }],\n\t *  }\n\t *\n\t * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit#heading=h.535es3xeprgt\n\t */\n\tfunction IndexedSourceMapConsumer(aSourceMap) {\n\t  var sourceMap = aSourceMap;\n\t  if (typeof aSourceMap === 'string') {\n\t    sourceMap = JSON.parse(aSourceMap.replace(/^\\)\\]\\}'/, ''));\n\t  }\n\n\t  var version = util.getArg(sourceMap, 'version');\n\t  var sections = util.getArg(sourceMap, 'sections');\n\n\t  if (version != this._version) {\n\t    throw new Error('Unsupported version: ' + version);\n\t  }\n\n\t  this._sources = new ArraySet();\n\t  this._names = new ArraySet();\n\n\t  var lastOffset = {\n\t    line: -1,\n\t    column: 0\n\t  };\n\t  this._sections = sections.map(function (s) {\n\t    if (s.url) {\n\t      // The url field will require support for asynchronicity.\n\t      // See https://github.com/mozilla/source-map/issues/16\n\t      throw new Error('Support for url field in sections not implemented.');\n\t    }\n\t    var offset = util.getArg(s, 'offset');\n\t    var offsetLine = util.getArg(offset, 'line');\n\t    var offsetColumn = util.getArg(offset, 'column');\n\n\t    if (offsetLine < lastOffset.line ||\n\t        (offsetLine === lastOffset.line && offsetColumn < lastOffset.column)) {\n\t      throw new Error('Section offsets must be ordered and non-overlapping.');\n\t    }\n\t    lastOffset = offset;\n\n\t    return {\n\t      generatedOffset: {\n\t        // The offset fields are 0-based, but we use 1-based indices when\n\t        // encoding/decoding from VLQ.\n\t        generatedLine: offsetLine + 1,\n\t        generatedColumn: offsetColumn + 1\n\t      },\n\t      consumer: new SourceMapConsumer(util.getArg(s, 'map'))\n\t    }\n\t  });\n\t}\n\n\tIndexedSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);\n\tIndexedSourceMapConsumer.prototype.constructor = SourceMapConsumer;\n\n\t/**\n\t * The version of the source mapping spec that we are consuming.\n\t */\n\tIndexedSourceMapConsumer.prototype._version = 3;\n\n\t/**\n\t * The list of original sources.\n\t */\n\tObject.defineProperty(IndexedSourceMapConsumer.prototype, 'sources', {\n\t  get: function () {\n\t    var sources = [];\n\t    for (var i = 0; i < this._sections.length; i++) {\n\t      for (var j = 0; j < this._sections[i].consumer.sources.length; j++) {\n\t        sources.push(this._sections[i].consumer.sources[j]);\n\t      }\n\t    }\n\t    return sources;\n\t  }\n\t});\n\n\t/**\n\t * Returns the original source, line, and column information for the generated\n\t * source's line and column positions provided. The only argument is an object\n\t * with the following properties:\n\t *\n\t *   - line: The line number in the generated source.\n\t *   - column: The column number in the generated source.\n\t *\n\t * and an object is returned with the following properties:\n\t *\n\t *   - source: The original source file, or null.\n\t *   - line: The line number in the original source, or null.\n\t *   - column: The column number in the original source, or null.\n\t *   - name: The original identifier, or null.\n\t */\n\tIndexedSourceMapConsumer.prototype.originalPositionFor =\n\t  function IndexedSourceMapConsumer_originalPositionFor(aArgs) {\n\t    var needle = {\n\t      generatedLine: util.getArg(aArgs, 'line'),\n\t      generatedColumn: util.getArg(aArgs, 'column')\n\t    };\n\n\t    // Find the section containing the generated position we're trying to map\n\t    // to an original position.\n\t    var sectionIndex = binarySearch.search(needle, this._sections,\n\t      function(needle, section) {\n\t        var cmp = needle.generatedLine - section.generatedOffset.generatedLine;\n\t        if (cmp) {\n\t          return cmp;\n\t        }\n\n\t        return (needle.generatedColumn -\n\t                section.generatedOffset.generatedColumn);\n\t      });\n\t    var section = this._sections[sectionIndex];\n\n\t    if (!section) {\n\t      return {\n\t        source: null,\n\t        line: null,\n\t        column: null,\n\t        name: null\n\t      };\n\t    }\n\n\t    return section.consumer.originalPositionFor({\n\t      line: needle.generatedLine -\n\t        (section.generatedOffset.generatedLine - 1),\n\t      column: needle.generatedColumn -\n\t        (section.generatedOffset.generatedLine === needle.generatedLine\n\t         ? section.generatedOffset.generatedColumn - 1\n\t         : 0),\n\t      bias: aArgs.bias\n\t    });\n\t  };\n\n\t/**\n\t * Return true if we have the source content for every source in the source\n\t * map, false otherwise.\n\t */\n\tIndexedSourceMapConsumer.prototype.hasContentsOfAllSources =\n\t  function IndexedSourceMapConsumer_hasContentsOfAllSources() {\n\t    return this._sections.every(function (s) {\n\t      return s.consumer.hasContentsOfAllSources();\n\t    });\n\t  };\n\n\t/**\n\t * Returns the original source content. The only argument is the url of the\n\t * original source file. Returns null if no original source content is\n\t * available.\n\t */\n\tIndexedSourceMapConsumer.prototype.sourceContentFor =\n\t  function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {\n\t    for (var i = 0; i < this._sections.length; i++) {\n\t      var section = this._sections[i];\n\n\t      var content = section.consumer.sourceContentFor(aSource, true);\n\t      if (content) {\n\t        return content;\n\t      }\n\t    }\n\t    if (nullOnMissing) {\n\t      return null;\n\t    }\n\t    else {\n\t      throw new Error('\"' + aSource + '\" is not in the SourceMap.');\n\t    }\n\t  };\n\n\t/**\n\t * Returns the generated line and column information for the original source,\n\t * line, and column positions provided. The only argument is an object with\n\t * the following properties:\n\t *\n\t *   - source: The filename of the original source.\n\t *   - line: The line number in the original source.\n\t *   - column: The column number in the original source.\n\t *\n\t * and an object is returned with the following properties:\n\t *\n\t *   - line: The line number in the generated source, or null.\n\t *   - column: The column number in the generated source, or null.\n\t */\n\tIndexedSourceMapConsumer.prototype.generatedPositionFor =\n\t  function IndexedSourceMapConsumer_generatedPositionFor(aArgs) {\n\t    for (var i = 0; i < this._sections.length; i++) {\n\t      var section = this._sections[i];\n\n\t      // Only consider this section if the requested source is in the list of\n\t      // sources of the consumer.\n\t      if (section.consumer.sources.indexOf(util.getArg(aArgs, 'source')) === -1) {\n\t        continue;\n\t      }\n\t      var generatedPosition = section.consumer.generatedPositionFor(aArgs);\n\t      if (generatedPosition) {\n\t        var ret = {\n\t          line: generatedPosition.line +\n\t            (section.generatedOffset.generatedLine - 1),\n\t          column: generatedPosition.column +\n\t            (section.generatedOffset.generatedLine === generatedPosition.line\n\t             ? section.generatedOffset.generatedColumn - 1\n\t             : 0)\n\t        };\n\t        return ret;\n\t      }\n\t    }\n\n\t    return {\n\t      line: null,\n\t      column: null\n\t    };\n\t  };\n\n\t/**\n\t * Parse the mappings in a string in to a data structure which we can easily\n\t * query (the ordered arrays in the `this.__generatedMappings` and\n\t * `this.__originalMappings` properties).\n\t */\n\tIndexedSourceMapConsumer.prototype._parseMappings =\n\t  function IndexedSourceMapConsumer_parseMappings(aStr, aSourceRoot) {\n\t    this.__generatedMappings = [];\n\t    this.__originalMappings = [];\n\t    for (var i = 0; i < this._sections.length; i++) {\n\t      var section = this._sections[i];\n\t      var sectionMappings = section.consumer._generatedMappings;\n\t      for (var j = 0; j < sectionMappings.length; j++) {\n\t        var mapping = sectionMappings[j];\n\n\t        var source = section.consumer._sources.at(mapping.source);\n\t        if (section.consumer.sourceRoot !== null) {\n\t          source = util.join(section.consumer.sourceRoot, source);\n\t        }\n\t        this._sources.add(source);\n\t        source = this._sources.indexOf(source);\n\n\t        var name = section.consumer._names.at(mapping.name);\n\t        this._names.add(name);\n\t        name = this._names.indexOf(name);\n\n\t        // The mappings coming from the consumer for the section have\n\t        // generated positions relative to the start of the section, so we\n\t        // need to offset them to be relative to the start of the concatenated\n\t        // generated file.\n\t        var adjustedMapping = {\n\t          source: source,\n\t          generatedLine: mapping.generatedLine +\n\t            (section.generatedOffset.generatedLine - 1),\n\t          generatedColumn: mapping.generatedColumn +\n\t            (section.generatedOffset.generatedLine === mapping.generatedLine\n\t            ? section.generatedOffset.generatedColumn - 1\n\t            : 0),\n\t          originalLine: mapping.originalLine,\n\t          originalColumn: mapping.originalColumn,\n\t          name: name\n\t        };\n\n\t        this.__generatedMappings.push(adjustedMapping);\n\t        if (typeof adjustedMapping.originalLine === 'number') {\n\t          this.__originalMappings.push(adjustedMapping);\n\t        }\n\t      }\n\t    }\n\n\t    quickSort(this.__generatedMappings, util.compareByGeneratedPositionsDeflated);\n\t    quickSort(this.__originalMappings, util.compareByOriginalPositions);\n\t  };\n\n\texports.IndexedSourceMapConsumer = IndexedSourceMapConsumer;\n\n\n/***/ },\n/* 2 */\n/***/ function(module, exports) {\n\n\t/* -*- Mode: js; js-indent-level: 2; -*- */\n\t/*\n\t * Copyright 2011 Mozilla Foundation and contributors\n\t * Licensed under the New BSD license. See LICENSE or:\n\t * http://opensource.org/licenses/BSD-3-Clause\n\t */\n\n\t/**\n\t * This is a helper function for getting values from parameter/options\n\t * objects.\n\t *\n\t * @param args The object we are extracting values from\n\t * @param name The name of the property we are getting.\n\t * @param defaultValue An optional value to return if the property is missing\n\t * from the object. If this is not specified and the property is missing, an\n\t * error will be thrown.\n\t */\n\tfunction getArg(aArgs, aName, aDefaultValue) {\n\t  if (aName in aArgs) {\n\t    return aArgs[aName];\n\t  } else if (arguments.length === 3) {\n\t    return aDefaultValue;\n\t  } else {\n\t    throw new Error('\"' + aName + '\" is a required argument.');\n\t  }\n\t}\n\texports.getArg = getArg;\n\n\tvar urlRegexp = /^(?:([\\w+\\-.]+):)?\\/\\/(?:(\\w+:\\w+)@)?([\\w.]*)(?::(\\d+))?(\\S*)$/;\n\tvar dataUrlRegexp = /^data:.+\\,.+$/;\n\n\tfunction urlParse(aUrl) {\n\t  var match = aUrl.match(urlRegexp);\n\t  if (!match) {\n\t    return null;\n\t  }\n\t  return {\n\t    scheme: match[1],\n\t    auth: match[2],\n\t    host: match[3],\n\t    port: match[4],\n\t    path: match[5]\n\t  };\n\t}\n\texports.urlParse = urlParse;\n\n\tfunction urlGenerate(aParsedUrl) {\n\t  var url = '';\n\t  if (aParsedUrl.scheme) {\n\t    url += aParsedUrl.scheme + ':';\n\t  }\n\t  url += '//';\n\t  if (aParsedUrl.auth) {\n\t    url += aParsedUrl.auth + '@';\n\t  }\n\t  if (aParsedUrl.host) {\n\t    url += aParsedUrl.host;\n\t  }\n\t  if (aParsedUrl.port) {\n\t    url += \":\" + aParsedUrl.port\n\t  }\n\t  if (aParsedUrl.path) {\n\t    url += aParsedUrl.path;\n\t  }\n\t  return url;\n\t}\n\texports.urlGenerate = urlGenerate;\n\n\t/**\n\t * Normalizes a path, or the path portion of a URL:\n\t *\n\t * - Replaces consecutive slashes with one slash.\n\t * - Removes unnecessary '.' parts.\n\t * - Removes unnecessary '<dir>/..' parts.\n\t *\n\t * Based on code in the Node.js 'path' core module.\n\t *\n\t * @param aPath The path or url to normalize.\n\t */\n\tfunction normalize(aPath) {\n\t  var path = aPath;\n\t  var url = urlParse(aPath);\n\t  if (url) {\n\t    if (!url.path) {\n\t      return aPath;\n\t    }\n\t    path = url.path;\n\t  }\n\t  var isAbsolute = exports.isAbsolute(path);\n\n\t  var parts = path.split(/\\/+/);\n\t  for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {\n\t    part = parts[i];\n\t    if (part === '.') {\n\t      parts.splice(i, 1);\n\t    } else if (part === '..') {\n\t      up++;\n\t    } else if (up > 0) {\n\t      if (part === '') {\n\t        // The first part is blank if the path is absolute. Trying to go\n\t        // above the root is a no-op. Therefore we can remove all '..' parts\n\t        // directly after the root.\n\t        parts.splice(i + 1, up);\n\t        up = 0;\n\t      } else {\n\t        parts.splice(i, 2);\n\t        up--;\n\t      }\n\t    }\n\t  }\n\t  path = parts.join('/');\n\n\t  if (path === '') {\n\t    path = isAbsolute ? '/' : '.';\n\t  }\n\n\t  if (url) {\n\t    url.path = path;\n\t    return urlGenerate(url);\n\t  }\n\t  return path;\n\t}\n\texports.normalize = normalize;\n\n\t/**\n\t * Joins two paths/URLs.\n\t *\n\t * @param aRoot The root path or URL.\n\t * @param aPath The path or URL to be joined with the root.\n\t *\n\t * - If aPath is a URL or a data URI, aPath is returned, unless aPath is a\n\t *   scheme-relative URL: Then the scheme of aRoot, if any, is prepended\n\t *   first.\n\t * - Otherwise aPath is a path. If aRoot is a URL, then its path portion\n\t *   is updated with the result and aRoot is returned. Otherwise the result\n\t *   is returned.\n\t *   - If aPath is absolute, the result is aPath.\n\t *   - Otherwise the two paths are joined with a slash.\n\t * - Joining for example 'http://' and 'www.example.com' is also supported.\n\t */\n\tfunction join(aRoot, aPath) {\n\t  if (aRoot === \"\") {\n\t    aRoot = \".\";\n\t  }\n\t  if (aPath === \"\") {\n\t    aPath = \".\";\n\t  }\n\t  var aPathUrl = urlParse(aPath);\n\t  var aRootUrl = urlParse(aRoot);\n\t  if (aRootUrl) {\n\t    aRoot = aRootUrl.path || '/';\n\t  }\n\n\t  // `join(foo, '//www.example.org')`\n\t  if (aPathUrl && !aPathUrl.scheme) {\n\t    if (aRootUrl) {\n\t      aPathUrl.scheme = aRootUrl.scheme;\n\t    }\n\t    return urlGenerate(aPathUrl);\n\t  }\n\n\t  if (aPathUrl || aPath.match(dataUrlRegexp)) {\n\t    return aPath;\n\t  }\n\n\t  // `join('http://', 'www.example.com')`\n\t  if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {\n\t    aRootUrl.host = aPath;\n\t    return urlGenerate(aRootUrl);\n\t  }\n\n\t  var joined = aPath.charAt(0) === '/'\n\t    ? aPath\n\t    : normalize(aRoot.replace(/\\/+$/, '') + '/' + aPath);\n\n\t  if (aRootUrl) {\n\t    aRootUrl.path = joined;\n\t    return urlGenerate(aRootUrl);\n\t  }\n\t  return joined;\n\t}\n\texports.join = join;\n\n\texports.isAbsolute = function (aPath) {\n\t  return aPath.charAt(0) === '/' || !!aPath.match(urlRegexp);\n\t};\n\n\t/**\n\t * Make a path relative to a URL or another path.\n\t *\n\t * @param aRoot The root path or URL.\n\t * @param aPath The path or URL to be made relative to aRoot.\n\t */\n\tfunction relative(aRoot, aPath) {\n\t  if (aRoot === \"\") {\n\t    aRoot = \".\";\n\t  }\n\n\t  aRoot = aRoot.replace(/\\/$/, '');\n\n\t  // It is possible for the path to be above the root. In this case, simply\n\t  // checking whether the root is a prefix of the path won't work. Instead, we\n\t  // need to remove components from the root one by one, until either we find\n\t  // a prefix that fits, or we run out of components to remove.\n\t  var level = 0;\n\t  while (aPath.indexOf(aRoot + '/') !== 0) {\n\t    var index = aRoot.lastIndexOf(\"/\");\n\t    if (index < 0) {\n\t      return aPath;\n\t    }\n\n\t    // If the only part of the root that is left is the scheme (i.e. http://,\n\t    // file:///, etc.), one or more slashes (/), or simply nothing at all, we\n\t    // have exhausted all components, so the path is not relative to the root.\n\t    aRoot = aRoot.slice(0, index);\n\t    if (aRoot.match(/^([^\\/]+:\\/)?\\/*$/)) {\n\t      return aPath;\n\t    }\n\n\t    ++level;\n\t  }\n\n\t  // Make sure we add a \"../\" for each component we removed from the root.\n\t  return Array(level + 1).join(\"../\") + aPath.substr(aRoot.length + 1);\n\t}\n\texports.relative = relative;\n\n\tvar supportsNullProto = (function () {\n\t  var obj = Object.create(null);\n\t  return !('__proto__' in obj);\n\t}());\n\n\tfunction identity (s) {\n\t  return s;\n\t}\n\n\t/**\n\t * Because behavior goes wacky when you set `__proto__` on objects, we\n\t * have to prefix all the strings in our set with an arbitrary character.\n\t *\n\t * See https://github.com/mozilla/source-map/pull/31 and\n\t * https://github.com/mozilla/source-map/issues/30\n\t *\n\t * @param String aStr\n\t */\n\tfunction toSetString(aStr) {\n\t  if (isProtoString(aStr)) {\n\t    return '$' + aStr;\n\t  }\n\n\t  return aStr;\n\t}\n\texports.toSetString = supportsNullProto ? identity : toSetString;\n\n\tfunction fromSetString(aStr) {\n\t  if (isProtoString(aStr)) {\n\t    return aStr.slice(1);\n\t  }\n\n\t  return aStr;\n\t}\n\texports.fromSetString = supportsNullProto ? identity : fromSetString;\n\n\tfunction isProtoString(s) {\n\t  if (!s) {\n\t    return false;\n\t  }\n\n\t  var length = s.length;\n\n\t  if (length < 9 /* \"__proto__\".length */) {\n\t    return false;\n\t  }\n\n\t  if (s.charCodeAt(length - 1) !== 95  /* '_' */ ||\n\t      s.charCodeAt(length - 2) !== 95  /* '_' */ ||\n\t      s.charCodeAt(length - 3) !== 111 /* 'o' */ ||\n\t      s.charCodeAt(length - 4) !== 116 /* 't' */ ||\n\t      s.charCodeAt(length - 5) !== 111 /* 'o' */ ||\n\t      s.charCodeAt(length - 6) !== 114 /* 'r' */ ||\n\t      s.charCodeAt(length - 7) !== 112 /* 'p' */ ||\n\t      s.charCodeAt(length - 8) !== 95  /* '_' */ ||\n\t      s.charCodeAt(length - 9) !== 95  /* '_' */) {\n\t    return false;\n\t  }\n\n\t  for (var i = length - 10; i >= 0; i--) {\n\t    if (s.charCodeAt(i) !== 36 /* '$' */) {\n\t      return false;\n\t    }\n\t  }\n\n\t  return true;\n\t}\n\n\t/**\n\t * Comparator between two mappings where the original positions are compared.\n\t *\n\t * Optionally pass in `true` as `onlyCompareGenerated` to consider two\n\t * mappings with the same original source/line/column, but different generated\n\t * line and column the same. Useful when searching for a mapping with a\n\t * stubbed out mapping.\n\t */\n\tfunction compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {\n\t  var cmp = mappingA.source - mappingB.source;\n\t  if (cmp !== 0) {\n\t    return cmp;\n\t  }\n\n\t  cmp = mappingA.originalLine - mappingB.originalLine;\n\t  if (cmp !== 0) {\n\t    return cmp;\n\t  }\n\n\t  cmp = mappingA.originalColumn - mappingB.originalColumn;\n\t  if (cmp !== 0 || onlyCompareOriginal) {\n\t    return cmp;\n\t  }\n\n\t  cmp = mappingA.generatedColumn - mappingB.generatedColumn;\n\t  if (cmp !== 0) {\n\t    return cmp;\n\t  }\n\n\t  cmp = mappingA.generatedLine - mappingB.generatedLine;\n\t  if (cmp !== 0) {\n\t    return cmp;\n\t  }\n\n\t  return mappingA.name - mappingB.name;\n\t}\n\texports.compareByOriginalPositions = compareByOriginalPositions;\n\n\t/**\n\t * Comparator between two mappings with deflated source and name indices where\n\t * the generated positions are compared.\n\t *\n\t * Optionally pass in `true` as `onlyCompareGenerated` to consider two\n\t * mappings with the same generated line and column, but different\n\t * source/name/original line and column the same. Useful when searching for a\n\t * mapping with a stubbed out mapping.\n\t */\n\tfunction compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {\n\t  var cmp = mappingA.generatedLine - mappingB.generatedLine;\n\t  if (cmp !== 0) {\n\t    return cmp;\n\t  }\n\n\t  cmp = mappingA.generatedColumn - mappingB.generatedColumn;\n\t  if (cmp !== 0 || onlyCompareGenerated) {\n\t    return cmp;\n\t  }\n\n\t  cmp = mappingA.source - mappingB.source;\n\t  if (cmp !== 0) {\n\t    return cmp;\n\t  }\n\n\t  cmp = mappingA.originalLine - mappingB.originalLine;\n\t  if (cmp !== 0) {\n\t    return cmp;\n\t  }\n\n\t  cmp = mappingA.originalColumn - mappingB.originalColumn;\n\t  if (cmp !== 0) {\n\t    return cmp;\n\t  }\n\n\t  return mappingA.name - mappingB.name;\n\t}\n\texports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;\n\n\tfunction strcmp(aStr1, aStr2) {\n\t  if (aStr1 === aStr2) {\n\t    return 0;\n\t  }\n\n\t  if (aStr1 > aStr2) {\n\t    return 1;\n\t  }\n\n\t  return -1;\n\t}\n\n\t/**\n\t * Comparator between two mappings with inflated source and name strings where\n\t * the generated positions are compared.\n\t */\n\tfunction compareByGeneratedPositionsInflated(mappingA, mappingB) {\n\t  var cmp = mappingA.generatedLine - mappingB.generatedLine;\n\t  if (cmp !== 0) {\n\t    return cmp;\n\t  }\n\n\t  cmp = mappingA.generatedColumn - mappingB.generatedColumn;\n\t  if (cmp !== 0) {\n\t    return cmp;\n\t  }\n\n\t  cmp = strcmp(mappingA.source, mappingB.source);\n\t  if (cmp !== 0) {\n\t    return cmp;\n\t  }\n\n\t  cmp = mappingA.originalLine - mappingB.originalLine;\n\t  if (cmp !== 0) {\n\t    return cmp;\n\t  }\n\n\t  cmp = mappingA.originalColumn - mappingB.originalColumn;\n\t  if (cmp !== 0) {\n\t    return cmp;\n\t  }\n\n\t  return strcmp(mappingA.name, mappingB.name);\n\t}\n\texports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;\n\n\n/***/ },\n/* 3 */\n/***/ function(module, exports) {\n\n\t/* -*- Mode: js; js-indent-level: 2; -*- */\n\t/*\n\t * Copyright 2011 Mozilla Foundation and contributors\n\t * Licensed under the New BSD license. See LICENSE or:\n\t * http://opensource.org/licenses/BSD-3-Clause\n\t */\n\n\texports.GREATEST_LOWER_BOUND = 1;\n\texports.LEAST_UPPER_BOUND = 2;\n\n\t/**\n\t * Recursive implementation of binary search.\n\t *\n\t * @param aLow Indices here and lower do not contain the needle.\n\t * @param aHigh Indices here and higher do not contain the needle.\n\t * @param aNeedle The element being searched for.\n\t * @param aHaystack The non-empty array being searched.\n\t * @param aCompare Function which takes two elements and returns -1, 0, or 1.\n\t * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or\n\t *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the\n\t *     closest element that is smaller than or greater than the one we are\n\t *     searching for, respectively, if the exact element cannot be found.\n\t */\n\tfunction recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare, aBias) {\n\t  // This function terminates when one of the following is true:\n\t  //\n\t  //   1. We find the exact element we are looking for.\n\t  //\n\t  //   2. We did not find the exact element, but we can return the index of\n\t  //      the next-closest element.\n\t  //\n\t  //   3. We did not find the exact element, and there is no next-closest\n\t  //      element than the one we are searching for, so we return -1.\n\t  var mid = Math.floor((aHigh - aLow) / 2) + aLow;\n\t  var cmp = aCompare(aNeedle, aHaystack[mid], true);\n\t  if (cmp === 0) {\n\t    // Found the element we are looking for.\n\t    return mid;\n\t  }\n\t  else if (cmp > 0) {\n\t    // Our needle is greater than aHaystack[mid].\n\t    if (aHigh - mid > 1) {\n\t      // The element is in the upper half.\n\t      return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias);\n\t    }\n\n\t    // The exact needle element was not found in this haystack. Determine if\n\t    // we are in termination case (3) or (2) and return the appropriate thing.\n\t    if (aBias == exports.LEAST_UPPER_BOUND) {\n\t      return aHigh < aHaystack.length ? aHigh : -1;\n\t    } else {\n\t      return mid;\n\t    }\n\t  }\n\t  else {\n\t    // Our needle is less than aHaystack[mid].\n\t    if (mid - aLow > 1) {\n\t      // The element is in the lower half.\n\t      return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias);\n\t    }\n\n\t    // we are in termination case (3) or (2) and return the appropriate thing.\n\t    if (aBias == exports.LEAST_UPPER_BOUND) {\n\t      return mid;\n\t    } else {\n\t      return aLow < 0 ? -1 : aLow;\n\t    }\n\t  }\n\t}\n\n\t/**\n\t * This is an implementation of binary search which will always try and return\n\t * the index of the closest element if there is no exact hit. This is because\n\t * mappings between original and generated line/col pairs are single points,\n\t * and there is an implicit region between each of them, so a miss just means\n\t * that you aren't on the very start of a region.\n\t *\n\t * @param aNeedle The element you are looking for.\n\t * @param aHaystack The array that is being searched.\n\t * @param aCompare A function which takes the needle and an element in the\n\t *     array and returns -1, 0, or 1 depending on whether the needle is less\n\t *     than, equal to, or greater than the element, respectively.\n\t * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or\n\t *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the\n\t *     closest element that is smaller than or greater than the one we are\n\t *     searching for, respectively, if the exact element cannot be found.\n\t *     Defaults to 'binarySearch.GREATEST_LOWER_BOUND'.\n\t */\n\texports.search = function search(aNeedle, aHaystack, aCompare, aBias) {\n\t  if (aHaystack.length === 0) {\n\t    return -1;\n\t  }\n\n\t  var index = recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack,\n\t                              aCompare, aBias || exports.GREATEST_LOWER_BOUND);\n\t  if (index < 0) {\n\t    return -1;\n\t  }\n\n\t  // We have found either the exact element, or the next-closest element than\n\t  // the one we are searching for. However, there may be more than one such\n\t  // element. Make sure we always return the smallest of these.\n\t  while (index - 1 >= 0) {\n\t    if (aCompare(aHaystack[index], aHaystack[index - 1], true) !== 0) {\n\t      break;\n\t    }\n\t    --index;\n\t  }\n\n\t  return index;\n\t};\n\n\n/***/ },\n/* 4 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t/* -*- Mode: js; js-indent-level: 2; -*- */\n\t/*\n\t * Copyright 2011 Mozilla Foundation and contributors\n\t * Licensed under the New BSD license. See LICENSE or:\n\t * http://opensource.org/licenses/BSD-3-Clause\n\t */\n\n\tvar util = __webpack_require__(2);\n\tvar has = Object.prototype.hasOwnProperty;\n\n\t/**\n\t * A data structure which is a combination of an array and a set. Adding a new\n\t * member is O(1), testing for membership is O(1), and finding the index of an\n\t * element is O(1). Removing elements from the set is not supported. Only\n\t * strings are supported for membership.\n\t */\n\tfunction ArraySet() {\n\t  this._array = [];\n\t  this._set = Object.create(null);\n\t}\n\n\t/**\n\t * Static method for creating ArraySet instances from an existing array.\n\t */\n\tArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {\n\t  var set = new ArraySet();\n\t  for (var i = 0, len = aArray.length; i < len; i++) {\n\t    set.add(aArray[i], aAllowDuplicates);\n\t  }\n\t  return set;\n\t};\n\n\t/**\n\t * Return how many unique items are in this ArraySet. If duplicates have been\n\t * added, than those do not count towards the size.\n\t *\n\t * @returns Number\n\t */\n\tArraySet.prototype.size = function ArraySet_size() {\n\t  return Object.getOwnPropertyNames(this._set).length;\n\t};\n\n\t/**\n\t * Add the given string to this set.\n\t *\n\t * @param String aStr\n\t */\n\tArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {\n\t  var sStr = util.toSetString(aStr);\n\t  var isDuplicate = has.call(this._set, sStr);\n\t  var idx = this._array.length;\n\t  if (!isDuplicate || aAllowDuplicates) {\n\t    this._array.push(aStr);\n\t  }\n\t  if (!isDuplicate) {\n\t    this._set[sStr] = idx;\n\t  }\n\t};\n\n\t/**\n\t * Is the given string a member of this set?\n\t *\n\t * @param String aStr\n\t */\n\tArraySet.prototype.has = function ArraySet_has(aStr) {\n\t  var sStr = util.toSetString(aStr);\n\t  return has.call(this._set, sStr);\n\t};\n\n\t/**\n\t * What is the index of the given string in the array?\n\t *\n\t * @param String aStr\n\t */\n\tArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {\n\t  var sStr = util.toSetString(aStr);\n\t  if (has.call(this._set, sStr)) {\n\t    return this._set[sStr];\n\t  }\n\t  throw new Error('\"' + aStr + '\" is not in the set.');\n\t};\n\n\t/**\n\t * What is the element at the given index?\n\t *\n\t * @param Number aIdx\n\t */\n\tArraySet.prototype.at = function ArraySet_at(aIdx) {\n\t  if (aIdx >= 0 && aIdx < this._array.length) {\n\t    return this._array[aIdx];\n\t  }\n\t  throw new Error('No element indexed by ' + aIdx);\n\t};\n\n\t/**\n\t * Returns the array representation of this set (which has the proper indices\n\t * indicated by indexOf). Note that this is a copy of the internal array used\n\t * for storing the members so that no one can mess with internal state.\n\t */\n\tArraySet.prototype.toArray = function ArraySet_toArray() {\n\t  return this._array.slice();\n\t};\n\n\texports.ArraySet = ArraySet;\n\n\n/***/ },\n/* 5 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t/* -*- Mode: js; js-indent-level: 2; -*- */\n\t/*\n\t * Copyright 2011 Mozilla Foundation and contributors\n\t * Licensed under the New BSD license. See LICENSE or:\n\t * http://opensource.org/licenses/BSD-3-Clause\n\t *\n\t * Based on the Base 64 VLQ implementation in Closure Compiler:\n\t * https://code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/debugging/sourcemap/Base64VLQ.java\n\t *\n\t * Copyright 2011 The Closure Compiler Authors. All rights reserved.\n\t * Redistribution and use in source and binary forms, with or without\n\t * modification, are permitted provided that the following conditions are\n\t * met:\n\t *\n\t *  * Redistributions of source code must retain the above copyright\n\t *    notice, this list of conditions and the following disclaimer.\n\t *  * Redistributions in binary form must reproduce the above\n\t *    copyright notice, this list of conditions and the following\n\t *    disclaimer in the documentation and/or other materials provided\n\t *    with the distribution.\n\t *  * Neither the name of Google Inc. nor the names of its\n\t *    contributors may be used to endorse or promote products derived\n\t *    from this software without specific prior written permission.\n\t *\n\t * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n\t * \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n\t * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n\t * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n\t * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n\t * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n\t * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n\t * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n\t * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n\t * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n\t * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\t */\n\n\tvar base64 = __webpack_require__(6);\n\n\t// A single base 64 digit can contain 6 bits of data. For the base 64 variable\n\t// length quantities we use in the source map spec, the first bit is the sign,\n\t// the next four bits are the actual value, and the 6th bit is the\n\t// continuation bit. The continuation bit tells us whether there are more\n\t// digits in this value following this digit.\n\t//\n\t//   Continuation\n\t//   |    Sign\n\t//   |    |\n\t//   V    V\n\t//   101011\n\n\tvar VLQ_BASE_SHIFT = 5;\n\n\t// binary: 100000\n\tvar VLQ_BASE = 1 << VLQ_BASE_SHIFT;\n\n\t// binary: 011111\n\tvar VLQ_BASE_MASK = VLQ_BASE - 1;\n\n\t// binary: 100000\n\tvar VLQ_CONTINUATION_BIT = VLQ_BASE;\n\n\t/**\n\t * Converts from a two-complement value to a value where the sign bit is\n\t * placed in the least significant bit.  For example, as decimals:\n\t *   1 becomes 2 (10 binary), -1 becomes 3 (11 binary)\n\t *   2 becomes 4 (100 binary), -2 becomes 5 (101 binary)\n\t */\n\tfunction toVLQSigned(aValue) {\n\t  return aValue < 0\n\t    ? ((-aValue) << 1) + 1\n\t    : (aValue << 1) + 0;\n\t}\n\n\t/**\n\t * Converts to a two-complement value from a value where the sign bit is\n\t * placed in the least significant bit.  For example, as decimals:\n\t *   2 (10 binary) becomes 1, 3 (11 binary) becomes -1\n\t *   4 (100 binary) becomes 2, 5 (101 binary) becomes -2\n\t */\n\tfunction fromVLQSigned(aValue) {\n\t  var isNegative = (aValue & 1) === 1;\n\t  var shifted = aValue >> 1;\n\t  return isNegative\n\t    ? -shifted\n\t    : shifted;\n\t}\n\n\t/**\n\t * Returns the base 64 VLQ encoded value.\n\t */\n\texports.encode = function base64VLQ_encode(aValue) {\n\t  var encoded = \"\";\n\t  var digit;\n\n\t  var vlq = toVLQSigned(aValue);\n\n\t  do {\n\t    digit = vlq & VLQ_BASE_MASK;\n\t    vlq >>>= VLQ_BASE_SHIFT;\n\t    if (vlq > 0) {\n\t      // There are still more digits in this value, so we must make sure the\n\t      // continuation bit is marked.\n\t      digit |= VLQ_CONTINUATION_BIT;\n\t    }\n\t    encoded += base64.encode(digit);\n\t  } while (vlq > 0);\n\n\t  return encoded;\n\t};\n\n\t/**\n\t * Decodes the next base 64 VLQ value from the given string and returns the\n\t * value and the rest of the string via the out parameter.\n\t */\n\texports.decode = function base64VLQ_decode(aStr, aIndex, aOutParam) {\n\t  var strLen = aStr.length;\n\t  var result = 0;\n\t  var shift = 0;\n\t  var continuation, digit;\n\n\t  do {\n\t    if (aIndex >= strLen) {\n\t      throw new Error(\"Expected more digits in base 64 VLQ value.\");\n\t    }\n\n\t    digit = base64.decode(aStr.charCodeAt(aIndex++));\n\t    if (digit === -1) {\n\t      throw new Error(\"Invalid base64 digit: \" + aStr.charAt(aIndex - 1));\n\t    }\n\n\t    continuation = !!(digit & VLQ_CONTINUATION_BIT);\n\t    digit &= VLQ_BASE_MASK;\n\t    result = result + (digit << shift);\n\t    shift += VLQ_BASE_SHIFT;\n\t  } while (continuation);\n\n\t  aOutParam.value = fromVLQSigned(result);\n\t  aOutParam.rest = aIndex;\n\t};\n\n\n/***/ },\n/* 6 */\n/***/ function(module, exports) {\n\n\t/* -*- Mode: js; js-indent-level: 2; -*- */\n\t/*\n\t * Copyright 2011 Mozilla Foundation and contributors\n\t * Licensed under the New BSD license. See LICENSE or:\n\t * http://opensource.org/licenses/BSD-3-Clause\n\t */\n\n\tvar intToCharMap = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split('');\n\n\t/**\n\t * Encode an integer in the range of 0 to 63 to a single base 64 digit.\n\t */\n\texports.encode = function (number) {\n\t  if (0 <= number && number < intToCharMap.length) {\n\t    return intToCharMap[number];\n\t  }\n\t  throw new TypeError(\"Must be between 0 and 63: \" + number);\n\t};\n\n\t/**\n\t * Decode a single base 64 character code digit to an integer. Returns -1 on\n\t * failure.\n\t */\n\texports.decode = function (charCode) {\n\t  var bigA = 65;     // 'A'\n\t  var bigZ = 90;     // 'Z'\n\n\t  var littleA = 97;  // 'a'\n\t  var littleZ = 122; // 'z'\n\n\t  var zero = 48;     // '0'\n\t  var nine = 57;     // '9'\n\n\t  var plus = 43;     // '+'\n\t  var slash = 47;    // '/'\n\n\t  var littleOffset = 26;\n\t  var numberOffset = 52;\n\n\t  // 0 - 25: ABCDEFGHIJKLMNOPQRSTUVWXYZ\n\t  if (bigA <= charCode && charCode <= bigZ) {\n\t    return (charCode - bigA);\n\t  }\n\n\t  // 26 - 51: abcdefghijklmnopqrstuvwxyz\n\t  if (littleA <= charCode && charCode <= littleZ) {\n\t    return (charCode - littleA + littleOffset);\n\t  }\n\n\t  // 52 - 61: 0123456789\n\t  if (zero <= charCode && charCode <= nine) {\n\t    return (charCode - zero + numberOffset);\n\t  }\n\n\t  // 62: +\n\t  if (charCode == plus) {\n\t    return 62;\n\t  }\n\n\t  // 63: /\n\t  if (charCode == slash) {\n\t    return 63;\n\t  }\n\n\t  // Invalid base64 digit.\n\t  return -1;\n\t};\n\n\n/***/ },\n/* 7 */\n/***/ function(module, exports) {\n\n\t/* -*- Mode: js; js-indent-level: 2; -*- */\n\t/*\n\t * Copyright 2011 Mozilla Foundation and contributors\n\t * Licensed under the New BSD license. See LICENSE or:\n\t * http://opensource.org/licenses/BSD-3-Clause\n\t */\n\n\t// It turns out that some (most?) JavaScript engines don't self-host\n\t// `Array.prototype.sort`. This makes sense because C++ will likely remain\n\t// faster than JS when doing raw CPU-intensive sorting. However, when using a\n\t// custom comparator function, calling back and forth between the VM's C++ and\n\t// JIT'd JS is rather slow *and* loses JIT type information, resulting in\n\t// worse generated code for the comparator function than would be optimal. In\n\t// fact, when sorting with a comparator, these costs outweigh the benefits of\n\t// sorting in C++. By using our own JS-implemented Quick Sort (below), we get\n\t// a ~3500ms mean speed-up in `bench/bench.html`.\n\n\t/**\n\t * Swap the elements indexed by `x` and `y` in the array `ary`.\n\t *\n\t * @param {Array} ary\n\t *        The array.\n\t * @param {Number} x\n\t *        The index of the first item.\n\t * @param {Number} y\n\t *        The index of the second item.\n\t */\n\tfunction swap(ary, x, y) {\n\t  var temp = ary[x];\n\t  ary[x] = ary[y];\n\t  ary[y] = temp;\n\t}\n\n\t/**\n\t * Returns a random integer within the range `low .. high` inclusive.\n\t *\n\t * @param {Number} low\n\t *        The lower bound on the range.\n\t * @param {Number} high\n\t *        The upper bound on the range.\n\t */\n\tfunction randomIntInRange(low, high) {\n\t  return Math.round(low + (Math.random() * (high - low)));\n\t}\n\n\t/**\n\t * The Quick Sort algorithm.\n\t *\n\t * @param {Array} ary\n\t *        An array to sort.\n\t * @param {function} comparator\n\t *        Function to use to compare two items.\n\t * @param {Number} p\n\t *        Start index of the array\n\t * @param {Number} r\n\t *        End index of the array\n\t */\n\tfunction doQuickSort(ary, comparator, p, r) {\n\t  // If our lower bound is less than our upper bound, we (1) partition the\n\t  // array into two pieces and (2) recurse on each half. If it is not, this is\n\t  // the empty array and our base case.\n\n\t  if (p < r) {\n\t    // (1) Partitioning.\n\t    //\n\t    // The partitioning chooses a pivot between `p` and `r` and moves all\n\t    // elements that are less than or equal to the pivot to the before it, and\n\t    // all the elements that are greater than it after it. The effect is that\n\t    // once partition is done, the pivot is in the exact place it will be when\n\t    // the array is put in sorted order, and it will not need to be moved\n\t    // again. This runs in O(n) time.\n\n\t    // Always choose a random pivot so that an input array which is reverse\n\t    // sorted does not cause O(n^2) running time.\n\t    var pivotIndex = randomIntInRange(p, r);\n\t    var i = p - 1;\n\n\t    swap(ary, pivotIndex, r);\n\t    var pivot = ary[r];\n\n\t    // Immediately after `j` is incremented in this loop, the following hold\n\t    // true:\n\t    //\n\t    //   * Every element in `ary[p .. i]` is less than or equal to the pivot.\n\t    //\n\t    //   * Every element in `ary[i+1 .. j-1]` is greater than the pivot.\n\t    for (var j = p; j < r; j++) {\n\t      if (comparator(ary[j], pivot) <= 0) {\n\t        i += 1;\n\t        swap(ary, i, j);\n\t      }\n\t    }\n\n\t    swap(ary, i + 1, j);\n\t    var q = i + 1;\n\n\t    // (2) Recurse on each half.\n\n\t    doQuickSort(ary, comparator, p, q - 1);\n\t    doQuickSort(ary, comparator, q + 1, r);\n\t  }\n\t}\n\n\t/**\n\t * Sort the given array in-place with the given comparator function.\n\t *\n\t * @param {Array} ary\n\t *        An array to sort.\n\t * @param {function} comparator\n\t *        Function to use to compare two items.\n\t */\n\texports.quickSort = function (ary, comparator) {\n\t  doQuickSort(ary, comparator, 0, ary.length - 1);\n\t};\n\n\n/***/ }\n/******/ ])\n});\n;","function _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n\n  for (var i = 0, arr2 = new Array(len); i < len; i++) {\n    arr2[i] = arr[i];\n  }\n\n  return arr2;\n}\n\nmodule.exports = _arrayLikeToArray;","var arrayLikeToArray = require(\"./arrayLikeToArray\");\n\nfunction _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen);\n}\n\nmodule.exports = _unsupportedIterableToArray;","function _iterableToArrayLimit(arr, i) {\n  if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return;\n  var _arr = [];\n  var _n = true;\n  var _d = false;\n  var _e = undefined;\n\n  try {\n    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {\n      _arr.push(_s.value);\n\n      if (i && _arr.length === i) break;\n    }\n  } catch (err) {\n    _d = true;\n    _e = err;\n  } finally {\n    try {\n      if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n    } finally {\n      if (_d) throw _e;\n    }\n  }\n\n  return _arr;\n}\n\nmodule.exports = _iterableToArrayLimit;","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nvar filenameWithoutLoaders = exports.filenameWithoutLoaders = function filenameWithoutLoaders() {\n  var filename = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';\n\n  var index = filename.lastIndexOf('!');\n\n  return index < 0 ? filename : filename.substr(index + 1);\n};\n\nvar filenameHasLoaders = exports.filenameHasLoaders = function filenameHasLoaders(filename) {\n  var actualFilename = _get__('filenameWithoutLoaders')(filename);\n\n  return actualFilename !== filename;\n};\n\nvar filenameHasSchema = exports.filenameHasSchema = function filenameHasSchema(filename) {\n  return (/^[\\w]+\\:/.test(filename)\n  );\n};\n\nvar isFilenameAbsolute = exports.isFilenameAbsolute = function isFilenameAbsolute(filename) {\n  var actualFilename = _get__('filenameWithoutLoaders')(filename);\n\n  if (actualFilename.indexOf('/') === 0) {\n    return true;\n  }\n\n  return false;\n};\n\nvar makeUrl = exports.makeUrl = function makeUrl(filename, scheme, line, column) {\n  var actualFilename = _get__('filenameWithoutLoaders')(filename);\n\n  if (_get__('filenameHasSchema')(filename)) {\n    return actualFilename;\n  }\n\n  var url = 'file://' + actualFilename;\n\n  if (scheme === 'vscode') {\n    url = scheme + '://file/' + url;\n    url = url.replace(/file:\\/\\/\\//, ''); // visual studio code does not need file:/// in its scheme\n    if (line && actualFilename === filename) {\n      url = url + ':' + line;\n\n      if (column) {\n        url = url + ':' + column;\n      }\n    }\n  } else if (scheme) {\n    url = scheme + '://open?url=' + url;\n\n    if (line && actualFilename === filename) {\n      url = url + '&line=' + line;\n\n      if (column) {\n        url = url + '&column=' + column;\n      }\n    }\n  }\n\n  return url;\n};\n\nvar makeLinkText = exports.makeLinkText = function makeLinkText(filename, line, column) {\n  var text = _get__('filenameWithoutLoaders')(filename);\n\n  if (line && text === filename) {\n    text = text + ':' + line;\n\n    if (column) {\n      text = text + ':' + column;\n    }\n  }\n\n  return text;\n};\n\nvar _RewiredData__ = Object.create(null);\n\nvar INTENTIONAL_UNDEFINED = '__INTENTIONAL_UNDEFINED__';\nvar _RewireAPI__ = {};\n\n(function () {\n  function addPropertyToAPIObject(name, value) {\n    Object.defineProperty(_RewireAPI__, name, {\n      value: value,\n      enumerable: false,\n      configurable: true\n    });\n  }\n\n  addPropertyToAPIObject('__get__', _get__);\n  addPropertyToAPIObject('__GetDependency__', _get__);\n  addPropertyToAPIObject('__Rewire__', _set__);\n  addPropertyToAPIObject('__set__', _set__);\n  addPropertyToAPIObject('__reset__', _reset__);\n  addPropertyToAPIObject('__ResetDependency__', _reset__);\n  addPropertyToAPIObject('__with__', _with__);\n})();\n\nfunction _get__(variableName) {\n  if (_RewiredData__ === undefined || _RewiredData__[variableName] === undefined) {\n    return _get_original__(variableName);\n  } else {\n    var value = _RewiredData__[variableName];\n\n    if (value === INTENTIONAL_UNDEFINED) {\n      return undefined;\n    } else {\n      return value;\n    }\n  }\n}\n\nfunction _get_original__(variableName) {\n  switch (variableName) {\n    case 'filenameWithoutLoaders':\n      return filenameWithoutLoaders;\n\n    case 'filenameHasSchema':\n      return filenameHasSchema;\n  }\n\n  return undefined;\n}\n\nfunction _assign__(variableName, value) {\n  if (_RewiredData__ === undefined || _RewiredData__[variableName] === undefined) {\n    return _set_original__(variableName, value);\n  } else {\n    return _RewiredData__[variableName] = value;\n  }\n}\n\nfunction _set_original__(variableName, _value) {\n  switch (variableName) {}\n\n  return undefined;\n}\n\nfunction _update_operation__(operation, variableName, prefix) {\n  var oldValue = _get__(variableName);\n\n  var newValue = operation === '++' ? oldValue + 1 : oldValue - 1;\n\n  _assign__(variableName, newValue);\n\n  return prefix ? newValue : oldValue;\n}\n\nfunction _set__(variableName, value) {\n  if ((typeof variableName === 'undefined' ? 'undefined' : _typeof(variableName)) === 'object') {\n    Object.keys(variableName).forEach(function (name) {\n      _RewiredData__[name] = variableName[name];\n    });\n  } else {\n    if (value === undefined) {\n      _RewiredData__[variableName] = INTENTIONAL_UNDEFINED;\n    } else {\n      _RewiredData__[variableName] = value;\n    }\n\n    return function () {\n      _reset__(variableName);\n    };\n  }\n}\n\nfunction _reset__(variableName) {\n  delete _RewiredData__[variableName];\n}\n\nfunction _with__(object) {\n  var rewiredVariableNames = Object.keys(object);\n  var previousValues = {};\n\n  function reset() {\n    rewiredVariableNames.forEach(function (variableName) {\n      _RewiredData__[variableName] = previousValues[variableName];\n    });\n  }\n\n  return function (callback) {\n    rewiredVariableNames.forEach(function (variableName) {\n      previousValues[variableName] = _RewiredData__[variableName];\n      _RewiredData__[variableName] = object[variableName];\n    });\n    var result = callback();\n\n    if (!!result && typeof result.then == 'function') {\n      result.then(reset).catch(reset);\n    } else {\n      reset();\n    }\n\n    return result;\n  };\n}\n\nexports.__get__ = _get__;\nexports.__GetDependency__ = _get__;\nexports.__Rewire__ = _set__;\nexports.__set__ = _set__;\nexports.__ResetDependency__ = _reset__;\nexports.__RewireAPI__ = _RewireAPI__;\nexports.default = _RewireAPI__;","function _arrayWithHoles(arr) {\n  if (Array.isArray(arr)) return arr;\n}\n\nmodule.exports = _arrayWithHoles;","function _nonIterableRest() {\n  throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\nmodule.exports = _nonIterableRest;"],"sourceRoot":""}