{“version”:3,“sources”:[“webpack:///webpack/universalModuleDefinition”,“webpack:///source-map.min.js”,“webpack:///webpack/bootstrap 0fd5815da764db5fb9fe”,“webpack:///./source-map.js”,“webpack:///./lib/source-map-generator.js”,“webpack:///./lib/base64-vlq.js”,“webpack:///./lib/base64.js”,“webpack:///./lib/util.js”,“webpack:///./lib/array-set.js”,“webpack:///./lib/mapping-list.js”,“webpack:///./lib/source-map-consumer.js”,“webpack:///./lib/binary-search.js”,“webpack:///./lib/quick-sort.js”,“webpack:///./lib/source-node.js”],“names”:[“root”,“factory”,“exports”,“module”,“define”,“amd”,“this”,“modules”,“webpack_require”,“moduleId”,“installedModules”,“id”,“loaded”,“call”,“m”,“c”,“p”,“SourceMapGenerator”,“SourceMapConsumer”,“SourceNode”,“aArgs”,“_file”,“util”,“getArg”,“_sourceRoot”,“_skipValidation”,“_sources”,“ArraySet”,“_names”,“_mappings”,“MappingList”,“_sourcesContents”,“base64VLQ”,“prototype”,“_version”,“fromSourceMap”,“aSourceMapConsumer”,“sourceRoot”,“generator”,“file”,“eachMapping”,“mapping”,“newMapping”,“generated”,“line”,“generatedLine”,“column”,“generatedColumn”,“source”,“relative”,“original”,“originalLine”,“originalColumn”,“name”,“addMapping”,“sources”,“forEach”,“sourceFile”,“sourceRelative”,“has”,“add”,“content”,“sourceContentFor”,“setSourceContent”,“_validateMapping”,“String”,“aSourceFile”,“aSourceContent”,“Object”,“create”,“toSetString”,“keys”,“length”,“applySourceMap”,“aSourceMapPath”,“Error”,“newSources”,“newNames”,“unsortedForEach”,“originalPositionFor”,“join”,“aGenerated”,“aOriginal”,“aSource”,“aName”,“JSON”,“stringify”,“_serializeMappings”,“next”,“nameIdx”,“sourceIdx”,“previousGeneratedColumn”,“previousGeneratedLine”,“previousOriginalColumn”,“previousOriginalLine”,“previousName”,“previousSource”,“result”,“mappings”,“toArray”,“i”,“len”,“compareByGeneratedPositionsInflated”,“encode”,“indexOf”,“_generateSourcesContent”,“aSources”,“aSourceRoot”,“map”,“key”,“hasOwnProperty”,“toJSON”,“version”,“names”,“sourcesContent”,“toString”,“toVLQSigned”,“aValue”,“fromVLQSigned”,“isNegative”,“shifted”,“base64”,“VLQ_BASE_SHIFT”,“VLQ_BASE”,“VLQ_BASE_MASK”,“VLQ_CONTINUATION_BIT”,“digit”,“encoded”,“vlq”,“decode”,“aStr”,“aIndex”,“aOutParam”,“continuation”,“strLen”,“shift”,“charCodeAt”,“charAt”,“value”,“rest”,“intToCharMap”,“split”,“number”,“TypeError”,“charCode”,“bigA”,“bigZ”,“littleA”,“littleZ”,“zero”,“nine”,“plus”,“slash”,“littleOffset”,“numberOffset”,“aDefaultValue”,“arguments”,“urlParse”,“aUrl”,“match”,“urlRegexp”,“scheme”,“auth”,“host”,“port”,“path”,“urlGenerate”,“aParsedUrl”,“url”,“normalize”,“aPath”,“part”,“isAbsolute”,“parts”,“up”,“splice”,“aRoot”,“aPathUrl”,“aRootUrl”,“dataUrlRegexp”,“joined”,“replace”,“level”,“index”,“lastIndexOf”,“slice”,“Array”,“substr”,“identity”,“s”,“isProtoString”,“fromSetString”,“compareByOriginalPositions”,“mappingA”,“mappingB”,“onlyCompareOriginal”,“cmp”,“strcmp”,“compareByGeneratedPositionsDeflated”,“onlyCompareGenerated”,“aStr1”,“aStr2”,“parseSourceMapInput”,“str”,“parse”,“computeSourceURL”,“sourceURL”,“sourceMapURL”,“parsed”,“substring”,“test”,“supportsNullProto”,“obj”,“_array”,“_set”,“hasNativeMap”,“Map”,“fromArray”,“aArray”,“aAllowDuplicates”,“set”,“size”,“getOwnPropertyNames”,“sStr”,“isDuplicate”,“idx”,“push”,“get”,“at”,“aIdx”,“generatedPositionAfter”,“lineA”,“lineB”,“columnA”,“columnB”,“_sorted”,“_last”,“aCallback”,“aThisArg”,“aMapping”,“sort”,“aSourceMap”,“aSourceMapURL”,“sourceMap”,“sections”,“IndexedSourceMapConsumer”,“BasicSourceMapConsumer”,“_absoluteSources”,“_sourceMapURL”,“Mapping”,“lastOffset”,“_sections”,“offset”,“offsetLine”,“offsetColumn”,“generatedOffset”,“consumer”,“binarySearch”,“quickSort”,“__generatedMappings”,“defineProperty”,“configurable”,“enumerable”,“_parseMappings”,“__originalMappings”,“_charIsMappingSeparator”,“GENERATED_ORDER”,“ORIGINAL_ORDER”,“GREATEST_LOWER_BOUND”,“LEAST_UPPER_BOUND”,“aContext”,“aOrder”,“context”,“order”,“_generatedMappings”,“_originalMappings”,“allGeneratedPositionsFor”,“needle”,“_findSourceIndex”,“_findMapping”,“undefined”,“lastColumn”,“relativeSource”,“smc”,“generatedMappings”,“destGeneratedMappings”,“destOriginalMappings”,“srcMapping”,“destMapping”,“segment”,“end”,“cachedSegments”,“temp”,“originalMappings”,“aNeedle”,“aMappings”,“aLineName”,“aColumnName”,“aComparator”,“aBias”,“search”,“computeColumnSpans”,“nextMapping”,“lastGeneratedColumn”,“Infinity”,“hasContentsOfAllSources”,“some”,“sc”,“nullOnMissing”,“fileUriAbsPath”,“generatedPositionFor”,“constructor”,“j”,“sectionIndex”,“section”,“bias”,“every”,“generatedPosition”,“ret”,“sectionMappings”,“adjustedMapping”,“recursiveSearch”,“aLow”,“aHigh”,“aHaystack”,“aCompare”,“mid”,“Math”,“floor”,“swap”,“ary”,“x”,“y”,“randomIntInRange”,“low”,“high”,“round”,“random”,“doQuickSort”,“comparator”,“r”,“pivotIndex”,“pivot”,“q”,“aLine”,“aColumn”,“aChunks”,“children”,“sourceContents”,“isSourceNode”,“REGEX_NEWLINE”,“NEWLINE_CODE”,“fromStringWithSourceMap”,“aGeneratedCode”,“aRelativePath”,“addMappingWithCode”,“code”,“node”,“remainingLines”,“remainingLinesIndex”,“shiftNextLine”,“getNextLine”,“lineContents”,“newLine”,“lastGeneratedLine”,“lastMapping”,“nextLine”,“aChunk”,“isArray”,“chunk”,“prepend”,“unshift”,“walk”,“aFn”,“aSep”,“newChildren”,“replaceRight”,“aPattern”,“aReplacement”,“lastChild”,“walkSourceContents”,“toStringWithSourceMap”,“sourceMappingActive”,“lastOriginalSource”,“lastOriginalLine”,“lastOriginalColumn”,“lastOriginalName”,“sourceContent”],“mappings”:“CAAA,SAAAA,EAAAC,GACA,gBAAAC,UAAA,gBAAAC,QACAA,OAAAD,QAAAD,IACA,kBAAAG,gBAAAC,IACAD,UAAAH,GACA,gBAAAC,SACAA,QAAA,UAAAD,IAEAD,EAAA,UAAAC,KACCK,KAAA,WACD,MCAgB,UAAUC,GCN1B,QAAAC,GAAAC,GAGA,GAAAC,EAAAD,GACA,MAAAC,GAAAD,GAAAP,OAGA,IAAAC,GAAAO,EAAAD,IACAP,WACAS,GAAAF,EACAG,QAAA,EAUA,OANAL,GAAAE,GAAAI,KAAAV,EAAAD,QAAAC,IAAAD,QAAAM,GAGAL,EAAAS,QAAA,EAGAT,EAAAD,QAvBA,GAAAQ,KAqCA,OATAF,GAAAM,EAAAP,EAGAC,EAAAO,EAAAL,EAGAF,EAAAQ,EAAA,GAGAR,EAAA,KDgBM,SAAUL,EAAQD,EAASM,GEjDjCN,EAAAe,mBAAAT,EAAA,GAAAS,mBACAf,EAAAgB,kBAAAV,EAAA,GAAAU,kBACAhB,EAAAiB,WAAAX,EAAA,IAAAW,YF6DM,SAAUhB,EAAQD,EAASM,GGhDjC,QAAAS,GAAAG,GACAA,IACAA,MAEAd,KAAAe,MAAAC,EAAAC,OAAAH,EAAA,aACAd,KAAAkB,YAAAF,EAAAC,OAAAH,EAAA,mBACAd,KAAAmB,gBAAAH,EAAAC,OAAAH,EAAA,qBACAd,KAAAoB,SAAA,GAAAC,GACArB,KAAAsB,OAAA,GAAAD,GACArB,KAAAuB,UAAA,GAAAC,GACAxB,KAAAyB,iBAAA,KAvBA,GAAAC,GAAAxB,EAAA,GACAc,EAAAd,EAAA,GACAmB,EAAAnB,EAAA,GAAAmB,SACAG,EAAAtB,EAAA,GAAAsB,WAuBAb,GAAAgB,UAAAC,SAAA,EAOAjB,EAAAkB,cACA,SAAAC,GACA,GAAAC,GAAAD,EAAAC,WACAC,EAAA,GAAArB,IACAsB,KAAAH,EAAAG,KACAF,cA2CA,OAzCAD,GAAAI,YAAA,SAAAC,GACA,GAAAC,IACAC,WACAC,KAAAH,EAAAI,cACAC,OAAAL,EAAAM,iBAIA,OAAAN,EAAAO,SACAN,EAAAM,OAAAP,EAAAO,OACA,MAAAX,IACAK,EAAAM,OAAA1B,EAAA2B,SAAAZ,EAAAK,EAAAM,SAGAN,EAAAQ,UACAN,KAAAH,EAAAU,aACAL,OAAAL,EAAAW,gBAGA,MAAAX,EAAAY,OACAX,EAAAW,KAAAZ,EAAAY,OAIAf,EAAAgB,WAAAZ,KAEAN,EAAAmB,QAAAC,QAAA,SAAAC,GACA,GAAAC,GAAAD,CACA,QAAApB,IACAqB,EAAApC,EAAA2B,SAAAZ,EAAAoB,IAGAnB,EAAAZ,SAAAiC,IAAAD,IACApB,EAAAZ,SAAAkC,IAAAF,EAGA,IAAAG,GAAAzB,EAAA0B,iBAAAL,EACA,OAAAI,GACAvB,EAAAyB,iBAAAN,EAAAI,KAGAvB,GAaArB,EAAAgB,UAAAqB,WACA,SAAAlC,GACA,GAAAuB,GAAArB,EAAAC,OAAAH,EAAA,aACA8B,EAAA5B,EAAAC,OAAAH,EAAA,iBACA4B,EAAA1B,EAAAC,OAAAH,EAAA,eACAiC,EAAA/B,EAAAC,OAAAH,EAAA,YAEAd,MAAAmB,iBACAnB,KAAA0D,iBAAArB,EAAAO,EAAAF,EAAAK,GAGA,MAAAL,IACAA,EAAAiB,OAAAjB,GACA1C,KAAAoB,SAAAiC,IAAAX,IACA1C,KAAAoB,SAAAkC,IAAAZ,IAIA,MAAAK,IACAA,EAAAY,OAAAZ,GACA/C,KAAAsB,OAAA+B,IAAAN,IACA/C,KAAAsB,OAAAgC,IAAAP,IAIA/C,KAAAuB,UAAA+B,KACAf,cAAAF,EAAAC,KACAG,gBAAAJ,EAAAG,OACAK,aAAA,MAAAD,KAAAN,KACAQ,eAAA,MAAAF,KAAAJ,OACAE,SACAK,UAOApC,EAAAgB,UAAA8B,iBACA,SAAAG,EAAAC,GACA,GAAAnB,GAAAkB,CACA,OAAA5D,KAAAkB,cACAwB,EAAA1B,EAAA2B,SAAA3C,KAAAkB,YAAAwB,IAGA,MAAAmB,GAGA7D,KAAAyB,mBACAzB,KAAAyB,iBAAAqC,OAAAC,OAAA,OAEA/D,KAAAyB,iBAAAT,EAAAgD,YAAAtB,IAAAmB,GACK7D,KAAAyB,yBAGLzB,MAAAyB,iBAAAT,EAAAgD,YAAAtB,IACA,IAAAoB,OAAAG,KAAAjE,KAAAyB,kBAAAyC,SACAlE,KAAAyB,iBAAA,QAqBAd,EAAAgB,UAAAwC,eACA,SAAArC,EAAA8B,EAAAQ,GACA,GAAAjB,GAAAS,CAEA,UAAAA,EAAA,CACA,SAAA9B,EAAAG,KACA,SAAAoC,OACA,gJAIAlB,GAAArB,EAAAG,KAEA,GAAAF,GAAA/B,KAAAkB,WAEA,OAAAa,IACAoB,EAAAnC,EAAA2B,SAAAZ,EAAAoB,GAIA,IAAAmB,GAAA,GAAAjD,GACAkD,EAAA,GAAAlD,EAGArB,MAAAuB,UAAAiD,gBAAA,SAAArC,GACA,GAAAA,EAAAO,SAAAS,GAAA,MAAAhB,EAAAU,aAAA,CAEA,GAAAD,GAAAd,EAAA2C,qBACAnC,KAAAH,EAAAU,aACAL,OAAAL,EAAAW,gBAEA,OAAAF,EAAAF,SAEAP,EAAAO,OAAAE,EAAAF,OACA,MAAA0B,IACAjC,EAAAO,OAAA1B,EAAA0D,KAAAN,EAAAjC,EAAAO,SAEA,MAAAX,IACAI,EAAAO,OAAA1B,EAAA2B,SAAAZ,EAAAI,EAAAO,SAEAP,EAAAU,aAAAD,EAAAN,KACAH,EAAAW,eAAAF,EAAAJ,OACA,MAAAI,EAAAG,OACAZ,EAAAY,KAAAH,EAAAG,OAKA,GAAAL,GAAAP,EAAAO,MACA,OAAAA,GAAA4B,EAAAjB,IAAAX,IACA4B,EAAAhB,IAAAZ,EAGA,IAAAK,GAAAZ,EAAAY,IACA,OAAAA,GAAAwB,EAAAlB,IAAAN,IACAwB,EAAAjB,IAAAP,IAGK/C,MACLA,KAAAoB,SAAAkD,EACAtE,KAAAsB,OAAAiD,EAGAzC,EAAAmB,QAAAC,QAAA,SAAAC,GACA,GAAAI,GAAAzB,EAAA0B,iBAAAL,EACA,OAAAI,IACA,MAAAa,IACAjB,EAAAnC,EAAA0D,KAAAN,EAAAjB,IAEA,MAAApB,IACAoB,EAAAnC,EAAA2B,SAAAZ,EAAAoB,IAEAnD,KAAAyD,iBAAAN,EAAAI,KAEKvD,OAcLW,EAAAgB,UAAA+B,iBACA,SAAAiB,EAAAC,EAAAC,EACAC,GAKA,GAAAF,GAAA,gBAAAA,GAAAtC,MAAA,gBAAAsC,GAAApC,OACA,SAAA6B,OACA,+OAMA,OAAAM,GAAA,QAAAA,IAAA,UAAAA,IACAA,EAAArC,KAAA,GAAAqC,EAAAnC,QAAA,IACAoC,GAAAC,GAAAC,MAIAH,GAAA,QAAAA,IAAA,UAAAA,IACAC,GAAA,QAAAA,IAAA,UAAAA,IACAD,EAAArC,KAAA,GAAAqC,EAAAnC,QAAA,GACAoC,EAAAtC,KAAA,GAAAsC,EAAApC,QAAA,GACAqC,GAKA,SAAAR,OAAA,oBAAAU,KAAAC,WACA3C,UAAAsC,EACAjC,OAAAmC,EACAjC,SAAAgC,EACA7B,KAAA+B,MASAnE,EAAAgB,UAAAsD,mBACA,WAcA,OANAC,GACA/C,EACAgD,EACAC,EAVAC,EAAA,EACAC,EAAA,EACAC,EAAA,EACAC,EAAA,EACAC,EAAA,EACAC,EAAA,EACAC,EAAA,GAMAC,EAAA5F,KAAAuB,UAAAsE,UACAC,EAAA,EAAAC,EAAAH,EAAA1B,OAA0C4B,EAAAC,EAASD,IAAA,CAInD,GAHA3D,EAAAyD,EAAAE,GACAZ,EAAA,GAEA/C,EAAAI,gBAAA+C,EAEA,IADAD,EAAA,EACAlD,EAAAI,gBAAA+C,GACAJ,GAAA,IACAI,QAIA,IAAAQ,EAAA,GACA,IAAA9E,EAAAgF,oCAAA7D,EAAAyD,EAAAE,EAAA,IACA,QAEAZ,IAAA,IAIAA,GAAAxD,EAAAuE,OAAA9D,EAAAM,gBACA4C,GACAA,EAAAlD,EAAAM,gBAEA,MAAAN,EAAAO,SACA0C,EAAApF,KAAAoB,SAAA8E,QAAA/D,EAAAO,QACAwC,GAAAxD,EAAAuE,OAAAb,EAAAM,GACAA,EAAAN,EAGAF,GAAAxD,EAAAuE,OAAA9D,EAAAU,aAAA,EACA2C,GACAA,EAAArD,EAAAU,aAAA,EAEAqC,GAAAxD,EAAAuE,OAAA9D,EAAAW,eACAyC,GACAA,EAAApD,EAAAW,eAEA,MAAAX,EAAAY,OACAoC,EAAAnF,KAAAsB,OAAA4E,QAAA/D,EAAAY,MACAmC,GAAAxD,EAAAuE,OAAAd,EAAAM,GACAA,EAAAN,IAIAQ,GAAAT,EAGA,MAAAS,IAGAhF,EAAAgB,UAAAwE,wBACA,SAAAC,EAAAC,GACA,MAAAD,GAAAE,IAAA,SAAA5D,GACA,IAAA1C,KAAAyB,iBACA,WAEA,OAAA4E,IACA3D,EAAA1B,EAAA2B,SAAA0D,EAAA3D,GAEA,IAAA6D,GAAAvF,EAAAgD,YAAAtB,EACA,OAAAoB,QAAAnC,UAAA6E,eAAAjG,KAAAP,KAAAyB,iBAAA8E,GACAvG,KAAAyB,iBAAA8E,GACA,MACKvG,OAMLW,EAAAgB,UAAA8E,OACA,WACA,GAAAH,IACAI,QAAA1G,KAAA4B,SACAqB,QAAAjD,KAAAoB,SAAAyE,UACAc,MAAA3G,KAAAsB,OAAAuE,UACAD,SAAA5F,KAAAiF,qBAYA,OAVA,OAAAjF,KAAAe,QACAuF,EAAArE,KAAAjC,KAAAe,OAEA,MAAAf,KAAAkB,cACAoF,EAAAvE,WAAA/B,KAAAkB,aAEAlB,KAAAyB,mBACA6E,EAAAM,eAAA5G,KAAAmG,wBAAAG,EAAArD,QAAAqD,EAAAvE,aAGAuE,GAMA3F,EAAAgB,UAAAkF,SACA,WACA,MAAA9B,MAAAC,UAAAhF,KAAAyG,WAGA7G,EAAAe,sBH2EM,SAAUd,EAAQD,EAASM,GI/ajC,QAAA4G,GAAAC,GACA,MAAAA,GAAA,IACAA,GAAA,MACAA,GAAA,KASA,QAAAC,GAAAD,GACA,GAAAE,GAAA,OAAAF,GACAG,EAAAH,GAAA,CACA,OAAAE,IACAC,EACAA,EAhDA,GAAAC,GAAAjH,EAAA,GAcAkH,EAAA,EAGAC,EAAA,GAAAD,EAGAE,EAAAD,EAAA,EAGAE,EAAAF,CA+BAzH,GAAAqG,OAAA,SAAAc,GACA,GACAS,GADAC,EAAA,GAGAC,EAAAZ,EAAAC,EAEA,GACAS,GAAAE,EAAAJ,EACAI,KAAAN,EACAM,EAAA,IAGAF,GAAAD,GAEAE,GAAAN,EAAAlB,OAAAuB,SACGE,EAAA,EAEH,OAAAD,IAOA7H,EAAA+H,OAAA,SAAAC,EAAAC,EAAAC,GACA,GAGAC,GAAAP,EAHAQ,EAAAJ,EAAA1D,OACAyB,EAAA,EACAsC,EAAA,CAGA,IACA,GAAAJ,GAAAG,EACA,SAAA3D,OAAA,6CAIA,IADAmD,EAAAL,EAAAQ,OAAAC,EAAAM,WAAAL,MACAL,KAAA,EACA,SAAAnD,OAAA,yBAAAuD,EAAAO,OAAAN,EAAA,GAGAE,MAAAP,EAAAD,GACAC,GAAAF,EACA3B,GAAA6B,GAAAS,EACAA,GAAAb,QACGW,EAEHD,GAAAM,MAAApB,EAAArB,GACAmC,EAAAO,KAAAR,IJ2fM,SAAUhI,EAAQD,GK9nBxB,GAAA0I,GAAA,mEAAAC,MAAA,GAKA3I,GAAAqG,OAAA,SAAAuC,GACA,MAAAA,KAAAF,EAAApE,OACA,MAAAoE,GAAAE,EAEA,UAAAC,WAAA,6BAAAD,IAOA5I,EAAA+H,OAAA,SAAAe,GACA,GAAAC,GAAA,GACAC,EAAA,GAEAC,EAAA,GACAC,EAAA,IAEAC,EAAA,GACAC,EAAA,GAEAC,EAAA,GACAC,EAAA,GAEAC,EAAA,GACAC,EAAA,EAGA,OAAAT,IAAAD,MAAAE,EACAF,EAAAC,EAIAE,GAAAH,MAAAI,EACAJ,EAAAG,EAAAM,EAIAJ,GAAAL,MAAAM,EACAN,EAAAK,EAAAK,EAIAV,GAAAO,EACA,GAIAP,GAAAQ,EACA,IAIA,IL6oBM,SAAUrJ,EAAQD,GM7rBxB,QAAAqB,GAAAH,EAAAgE,EAAAuE,GACA,GAAAvE,IAAAhE,GACA,MAAAA,GAAAgE,EACG,QAAAwE,UAAApF,OACH,MAAAmF,EAEA,UAAAhF,OAAA,IAAAS,EAAA,6BAQA,QAAAyE,GAAAC,GACA,GAAAC,GAAAD,EAAAC,MAAAC,EACA,OAAAD,IAIAE,OAAAF,EAAA,GACAG,KAAAH,EAAA,GACAI,KAAAJ,EAAA,GACAK,KAAAL,EAAA,GACAM,KAAAN,EAAA,IAPA,KAYA,QAAAO,GAAAC,GACA,GAAAC,GAAA,EAiBA,OAhBAD,GAAAN,SACAO,GAAAD,EAAAN,OAAA,KAEAO,GAAA,KACAD,EAAAL,OACAM,GAAAD,EAAAL,KAAA,KAEAK,EAAAJ,OACAK,GAAAD,EAAAJ,MAEAI,EAAAH,OACAI,GAAA,IAAAD,EAAAH,MAEAG,EAAAF,OACAG,GAAAD,EAAAF,MAEAG,EAeA,QAAAC,GAAAC,GACA,GAAAL,GAAAK,EACAF,EAAAX,EAAAa,EACA,IAAAF,EAAA,CACA,IAAAA,EAAAH,KACA,MAAAK,EAEAL,GAAAG,EAAAH,KAKA,OAAAM,GAHAC,EAAA1K,EAAA0K,WAAAP,GAEAQ,EAAAR,EAAAxB,MAAA,OACAiC,EAAA,EAAA1E,EAAAyE,EAAArG,OAAA,EAA8C4B,GAAA,EAAQA,IACtDuE,EAAAE,EAAAzE,GACA,MAAAuE,EACAE,EAAAE,OAAA3E,EAAA,GACK,OAAAuE,EACLG,IACKA,EAAA,IACL,KAAAH,GAIAE,EAAAE,OAAA3E,EAAA,EAAA0E,GACAA,EAAA,IAEAD,EAAAE,OAAA3E,EAAA,GACA0E,KAUA,OANAT,GAAAQ,EAAA7F,KAAA,KAEA,KAAAqF,IACAA,EAAAO,EAAA,SAGAJ,GACAA,EAAAH,OACAC,EAAAE,IAEAH,EAoBA,QAAArF,GAAAgG,EAAAN,GACA,KAAAM,IACAA,EAAA,KAEA,KAAAN,IACAA,EAAA,IAEA,IAAAO,GAAApB,EAAAa,GACAQ,EAAArB,EAAAmB,EAMA,IALAE,IACAF,EAAAE,EAAAb,MAAA,KAIAY,MAAAhB,OAIA,MAHAiB,KACAD,EAAAhB,OAAAiB,EAAAjB,QAEAK,EAAAW,EAGA,IAAAA,GAAAP,EAAAX,MAAAoB,GACA,MAAAT,EAIA,IAAAQ,MAAAf,OAAAe,EAAAb,KAEA,MADAa,GAAAf,KAAAO,EACAJ,EAAAY,EAGA,IAAAE,GAAA,MAAAV,EAAAjC,OAAA,GACAiC,EACAD,EAAAO,EAAAK,QAAA,eAAAX,EAEA,OAAAQ,IACAA,EAAAb,KAAAe,EACAd,EAAAY,IAEAE,EAcA,QAAAnI,GAAA+H,EAAAN,GACA,KAAAM,IACAA,EAAA,KAGAA,IAAAK,QAAA,SAOA,KADA,GAAAC,GAAA,EACA,IAAAZ,EAAAlE,QAAAwE,EAAA,OACA,GAAAO,GAAAP,EAAAQ,YAAA,IACA,IAAAD,EAAA,EACA,MAAAb,EAOA,IADAM,IAAAS,MAAA,EAAAF,GACAP,EAAAjB,MAAA,qBACA,MAAAW,KAGAY,EAIA,MAAAI,OAAAJ,EAAA,GAAAtG,KAAA,OAAA0F,EAAAiB,OAAAX,EAAAxG,OAAA,GASA,QAAAoH,GAAAC,GACA,MAAAA,GAYA,QAAAvH,GAAA4D,GACA,MAAA4D,GAAA5D,GACA,IAAAA,EAGAA,EAIA,QAAA6D,GAAA7D,GACA,MAAA4D,GAAA5D,GACAA,EAAAuD,MAAA,GAGAvD,EAIA,QAAA4D,GAAAD,GACA,IAAAA,EACA,QAGA,IAAArH,GAAAqH,EAAArH,MAEA,IAAAA,EAAA,EACA,QAGA,SAAAqH,EAAArD,WAAAhE,EAAA,IACA,KAAAqH,EAAArD,WAAAhE,EAAA,IACA,MAAAqH,EAAArD,WAAAhE,EAAA,IACA,MAAAqH,EAAArD,WAAAhE,EAAA,IACA,MAAAqH,EAAArD,WAAAhE,EAAA,IACA,MAAAqH,EAAArD,WAAAhE,EAAA,IACA,MAAAqH,EAAArD,WAAAhE,EAAA,IACA,KAAAqH,EAAArD,WAAAhE,EAAA,IACA,KAAAqH,EAAArD,WAAAhE,EAAA,GACA,QAGA,QAAA4B,GAAA5B,EAAA,GAA2B4B,GAAA,EAAQA,IACnC,QAAAyF,EAAArD,WAAApC,GACA,QAIA,UAWA,QAAA4F,GAAAC,EAAAC,EAAAC,GACA,GAAAC,GAAAC,EAAAJ,EAAAjJ,OAAAkJ,EAAAlJ,OACA,YAAAoJ,EACAA,GAGAA,EAAAH,EAAA9I,aAAA+I,EAAA/I,aACA,IAAAiJ,EACAA,GAGAA,EAAAH,EAAA7I,eAAA8I,EAAA9I,eACA,IAAAgJ,GAAAD,EACAC,GAGAA,EAAAH,EAAAlJ,gBAAAmJ,EAAAnJ,gBACA,IAAAqJ,EACAA,GAGAA,EAAAH,EAAApJ,cAAAqJ,EAAArJ,cACA,IAAAuJ,EACAA,EAGAC,EAAAJ,EAAA5I,KAAA6I,EAAA7I,UAaA,QAAAiJ,GAAAL,EAAAC,EAAAK,GACA,GAAAH,GAAAH,EAAApJ,cAAAqJ,EAAArJ,aACA,YAAAuJ,EACAA,GAGAA,EAAAH,EAAAlJ,gBAAAmJ,EAAAnJ,gBACA,IAAAqJ,GAAAG,EACAH,GAGAA,EAAAC,EAAAJ,EAAAjJ,OAAAkJ,EAAAlJ,QACA,IAAAoJ,EACAA,GAGAA,EAAAH,EAAA9I,aAAA+I,EAAA/I,aACA,IAAAiJ,EACAA,GAGAA,EAAAH,EAAA7I,eAAA8I,EAAA9I,eACA,IAAAgJ,EACAA,EAGAC,EAAAJ,EAAA5I,KAAA6I,EAAA7I,UAIA,QAAAgJ,GAAAG,EAAAC,GACA,MAAAD,KAAAC,EACA,EAGA,OAAAD,EACA,EAGA,OAAAC,GACA,EAGAD,EAAAC,EACA,GAGA,EAOA,QAAAnG,GAAA2F,EAAAC,GACA,GAAAE,GAAAH,EAAApJ,cAAAqJ,EAAArJ,aACA,YAAAuJ,EACAA,GAGAA,EAAAH,EAAAlJ,gBAAAmJ,EAAAnJ,gBACA,IAAAqJ,EACAA,GAGAA,EAAAC,EAAAJ,EAAAjJ,OAAAkJ,EAAAlJ,QACA,IAAAoJ,EACAA,GAGAA,EAAAH,EAAA9I,aAAA+I,EAAA/I,aACA,IAAAiJ,EACAA,GAGAA,EAAAH,EAAA7I,eAAA8I,EAAA9I,eACA,IAAAgJ,EACAA,EAGAC,EAAAJ,EAAA5I,KAAA6I,EAAA7I,UASA,QAAAqJ,GAAAC,GACA,MAAAtH,MAAAuH,MAAAD,EAAAtB,QAAA,iBAAsC,KAQtC,QAAAwB,GAAAxK,EAAAyK,EAAAC,GA8BA,GA7BAD,KAAA,GAEAzK,IAEA,MAAAA,IAAAmC,OAAA,UAAAsI,EAAA,KACAzK,GAAA,KAOAyK,EAAAzK,EAAAyK,GAiBAC,EAAA,CACA,GAAAC,GAAAnD,EAAAkD,EACA,KAAAC,EACA,SAAArI,OAAA,mCAEA,IAAAqI,EAAA3C,KAAA,CAEA,GAAAkB,GAAAyB,EAAA3C,KAAAmB,YAAA,IACAD,IAAA,IACAyB,EAAA3C,KAAA2C,EAAA3C,KAAA4C,UAAA,EAAA1B,EAAA,IAGAuB,EAAA9H,EAAAsF,EAAA0C,GAAAF,GAGA,MAAArC,GAAAqC,GA3cA5M,EAAAqB,QAEA,IAAAyI,GAAA,iEACAmB,EAAA,eAeAjL,GAAA2J,WAsBA3J,EAAAoK,cAwDApK,EAAAuK,YA2DAvK,EAAA8E,OAEA9E,EAAA0K,WAAA,SAAAF,GACA,YAAAA,EAAAjC,OAAA,IAAAuB,EAAAkD,KAAAxC,IAyCAxK,EAAA+C,UAEA,IAAAkK,GAAA,WACA,GAAAC,GAAAhJ,OAAAC,OAAA,KACA,sBAAA+I,MAuBAlN,GAAAoE,YAAA6I,EAAAvB,EAAAtH,EASApE,EAAA6L,cAAAoB,EAAAvB,EAAAG,EAsEA7L,EAAA8L,6BAuCA9L,EAAAoM,sCAsDApM,EAAAoG,sCAUApG,EAAAwM,sBAqDAxM,EAAA2M,oBNqtBM,SAAU1M,EAAQD,EAASM,GO3qCjC,QAAAmB,KACArB,KAAA+M,UACA/M,KAAAgN,KAAAC,EAAA,GAAAC,KAAApJ,OAAAC,OAAA,MAZA,GAAA/C,GAAAd,EAAA,GACAmD,EAAAS,OAAAnC,UAAA6E,eACAyG,EAAA,mBAAAC,IAgBA7L,GAAA8L,UAAA,SAAAC,EAAAC,GAEA,OADAC,GAAA,GAAAjM,GACAyE,EAAA,EAAAC,EAAAqH,EAAAlJ,OAAsC4B,EAAAC,EAASD,IAC/CwH,EAAAhK,IAAA8J,EAAAtH,GAAAuH,EAEA,OAAAC,IASAjM,EAAAM,UAAA4L,KAAA,WACA,MAAAN,GAAAjN,KAAAgN,KAAAO,KAAAzJ,OAAA0J,oBAAAxN,KAAAgN,MAAA9I,QAQA7C,EAAAM,UAAA2B,IAAA,SAAAsE,EAAAyF,GACA,GAAAI,GAAAR,EAAArF,EAAA5G,EAAAgD,YAAA4D,GACA8F,EAAAT,EAAAjN,KAAAqD,IAAAuE,GAAAvE,EAAA9C,KAAAP,KAAAgN,KAAAS,GACAE,EAAA3N,KAAA+M,OAAA7I,MACAwJ,KAAAL,GACArN,KAAA+M,OAAAa,KAAAhG,GAEA8F,IACAT,EACAjN,KAAAgN,KAAAM,IAAA1F,EAAA+F,GAEA3N,KAAAgN,KAAAS,GAAAE,IAUAtM,EAAAM,UAAA0B,IAAA,SAAAuE,GACA,GAAAqF,EACA,MAAAjN,MAAAgN,KAAA3J,IAAAuE,EAEA,IAAA6F,GAAAzM,EAAAgD,YAAA4D,EACA,OAAAvE,GAAA9C,KAAAP,KAAAgN,KAAAS,IASApM,EAAAM,UAAAuE,QAAA,SAAA0B,GACA,GAAAqF,EAAA,CACA,GAAAU,GAAA3N,KAAAgN,KAAAa,IAAAjG,EACA,IAAA+F,GAAA,EACA,MAAAA,OAEG,CACH,GAAAF,GAAAzM,EAAAgD,YAAA4D,EACA,IAAAvE,EAAA9C,KAAAP,KAAAgN,KAAAS,GACA,MAAAzN,MAAAgN,KAAAS,GAIA,SAAApJ,OAAA,IAAAuD,EAAA,yBAQAvG,EAAAM,UAAAmM,GAAA,SAAAC,GACA,GAAAA,GAAA,GAAAA,EAAA/N,KAAA+M,OAAA7I,OACA,MAAAlE,MAAA+M,OAAAgB,EAEA,UAAA1J,OAAA,yBAAA0J,IAQA1M,EAAAM,UAAAkE,QAAA,WACA,MAAA7F,MAAA+M,OAAA5B,SAGAvL,EAAAyB,YPmsCM,SAAUxB,EAAQD,EAASM,GQ9yCjC,QAAA8N,GAAArC,EAAAC,GAEA,GAAAqC,GAAAtC,EAAApJ,cACA2L,EAAAtC,EAAArJ,cACA4L,EAAAxC,EAAAlJ,gBACA2L,EAAAxC,EAAAnJ,eACA,OAAAyL,GAAAD,GAAAC,GAAAD,GAAAG,GAAAD,GACAnN,EAAAgF,oCAAA2F,EAAAC,IAAA,EAQA,QAAApK,KACAxB,KAAA+M,UACA/M,KAAAqO,SAAA,EAEArO,KAAAsO,OAAgB/L,eAAA,EAAAE,gBAAA,GAzBhB,GAAAzB,GAAAd,EAAA,EAkCAsB,GAAAG,UAAA6C,gBACA,SAAA+J,EAAAC,GACAxO,KAAA+M,OAAA7J,QAAAqL,EAAAC,IAQAhN,EAAAG,UAAA2B,IAAA,SAAAmL,GACAT,EAAAhO,KAAAsO,MAAAG,IACAzO,KAAAsO,MAAAG,EACAzO,KAAA+M,OAAAa,KAAAa,KAEAzO,KAAAqO,SAAA,EACArO,KAAA+M,OAAAa,KAAAa,KAaAjN,EAAAG,UAAAkE,QAAA,WAKA,MAJA7F,MAAAqO,UACArO,KAAA+M,OAAA2B,KAAA1N,EAAAgF,qCACAhG,KAAAqO,SAAA,GAEArO,KAAA+M,QAGAnN,EAAA4B,eRk0CM,SAAU3B,EAAQD,EAASM,GSn4CjC,QAAAU,GAAA+N,EAAAC,GACA,GAAAC,GAAAF,CAKA,OAJA,gBAAAA,KACAE,EAAA7N,EAAAoL,oBAAAuC,IAGA,MAAAE,EAAAC,SACA,GAAAC,GAAAF,EAAAD,GACA,GAAAI,GAAAH,EAAAD,GA0QA,QAAAI,GAAAL,EAAAC,GACA,GAAAC,GAAAF,CACA,iBAAAA,KACAE,EAAA7N,EAAAoL,oBAAAuC,GAGA,IAAAjI,GAAA1F,EAAAC,OAAA4N,EAAA,WACA5L,EAAAjC,EAAAC,OAAA4N,EAAA,WAGAlI,EAAA3F,EAAAC,OAAA4N,EAAA,YACA9M,EAAAf,EAAAC,OAAA4N,EAAA,mBACAjI,EAAA5F,EAAAC,OAAA4N,EAAA,uBACAjJ,EAAA5E,EAAAC,OAAA4N,EAAA,YACA5M,EAAAjB,EAAAC,OAAA4N,EAAA,YAIA,IAAAnI,GAAA1G,KAAA4B,SACA,SAAAyC,OAAA,wBAAAqC,EAGA3E,KACAA,EAAAf,EAAAmJ,UAAApI,IAGAkB,IACAqD,IAAA3C,QAIA2C,IAAAtF,EAAAmJ,WAKA7D,IAAA,SAAA5D,GACA,MAAAX,IAAAf,EAAAsJ,WAAAvI,IAAAf,EAAAsJ,WAAA5H,GACA1B,EAAA2B,SAAAZ,EAAAW,GACAA,IAOA1C,KAAAsB,OAAAD,EAAA8L,UAAAxG,EAAAL,IAAA3C,SAAA,GACA3D,KAAAoB,SAAAC,EAAA8L,UAAAlK,GAAA,GAEAjD,KAAAiP,iBAAAjP,KAAAoB,SAAAyE,UAAAS,IAAA,SAAAiF,GACA,MAAAvK,GAAAuL,iBAAAxK,EAAAwJ,EAAAqD,KAGA5O,KAAA+B,aACA/B,KAAA4G,iBACA5G,KAAAuB,UAAAqE,EACA5F,KAAAkP,cAAAN,EACA5O,KAAAiC,OA4GA,QAAAkN,KACAnP,KAAAuC,cAAA,EACAvC,KAAAyC,gBAAA,EACAzC,KAAA0C,OAAA,KACA1C,KAAA6C,aAAA,KACA7C,KAAA8C,eAAA,KACA9C,KAAA+C,KAAA,KAkaA,QAAAgM,GAAAJ,EAAAC,GACA,GAAAC,GAAAF,CACA,iBAAAA,KACAE,EAAA7N,EAAAoL,oBAAAuC,GAGA,IAAAjI,GAAA1F,EAAAC,OAAA4N,EAAA,WACAC,EAAA9N,EAAAC,OAAA4N,EAAA,WAEA,IAAAnI,GAAA1G,KAAA4B,SACA,SAAAyC,OAAA,wBAAAqC,EAGA1G,MAAAoB,SAAA,GAAAC,GACArB,KAAAsB,OAAA,GAAAD,EAEA,IAAA+N,IACA9M,MAAA,EACAE,OAAA,EAEAxC,MAAAqP,UAAAP,EAAAxI,IAAA,SAAAiF,GACA,GAAAA,EAAArB,IAGA,SAAA7F,OAAA,qDAEA,IAAAiL,GAAAtO,EAAAC,OAAAsK,EAAA,UACAgE,EAAAvO,EAAAC,OAAAqO,EAAA,QACAE,EAAAxO,EAAAC,OAAAqO,EAAA,SAEA,IAAAC,EAAAH,EAAA9M,MACAiN,IAAAH,EAAA9M,MAAAkN,EAAAJ,EAAA5M,OACA,SAAA6B,OAAA,uDAIA,OAFA+K,GAAAE,GAGAG,iBAGAlN,cAAAgN,EAAA,EACA9M,gBAAA+M,EAAA,GAEAE,SAAA,GAAA9O,GAAAI,EAAAC,OAAAsK,EAAA,OAAAqD,MAh5BA,GAAA5N,GAAAd,EAAA,GACAyP,EAAAzP,EAAA,GACAmB,EAAAnB,EAAA,GAAAmB,SACAK,EAAAxB,EAAA,GACA0P,EAAA1P,EAAA,GAAA0P,SAaAhP,GAAAiB,cAAA,SAAA8M,EAAAC,GACA,MAAAI,GAAAnN,cAAA8M,EAAAC,IAMAhO,EAAAe,UAAAC,SAAA,EAgCAhB,EAAAe,UAAAkO,oBAAA,KACA/L,OAAAgM,eAAAlP,EAAAe,UAAA,sBACAoO,cAAA,EACAC,YAAA,EACAnC,IAAA,WAKA,MAJA7N,MAAA6P,qBACA7P,KAAAiQ,eAAAjQ,KAAAuB,UAAAvB,KAAA+B,YAGA/B,KAAA6P,uBAIAjP,EAAAe,UAAAuO,mBAAA,KACApM,OAAAgM,eAAAlP,EAAAe,UAAA,qBACAoO,cAAA,EACAC,YAAA,EACAnC,IAAA,WAKA,MAJA7N,MAAAkQ,oBACAlQ,KAAAiQ,eAAAjQ,KAAAuB,UAAAvB,KAAA+B,YAGA/B,KAAAkQ,sBAIAtP,EAAAe,UAAAwO,wBACA,SAAAvI,EAAAqD,GACA,GAAAxK,GAAAmH,EAAAO,OAAA8C,EACA,aAAAxK,GAAmB,MAAAA,GAQnBG,EAAAe,UAAAsO,eACA,SAAArI,EAAAvB,GACA,SAAAhC,OAAA,6CAGAzD,EAAAwP,gBAAA,EACAxP,EAAAyP,eAAA,EAEAzP,EAAA0P,qBAAA,EACA1P,EAAA2P,kBAAA,EAkBA3P,EAAAe,UAAAO,YACA,SAAAqM,EAAAiC,EAAAC,GACA,GAGA7K,GAHA8K,EAAAF,GAAA,KACAG,EAAAF,GAAA7P,EAAAwP,eAGA,QAAAO,GACA,IAAA/P,GAAAwP,gBACAxK,EAAA5F,KAAA4Q,kBACA,MACA,KAAAhQ,GAAAyP,eACAzK,EAAA5F,KAAA6Q,iBACA,MACA,SACA,SAAAxM,OAAA,+BAGA,GAAAtC,GAAA/B,KAAA+B,UACA6D,GAAAU,IAAA,SAAAnE,GACA,GAAAO,GAAA,OAAAP,EAAAO,OAAA,KAAA1C,KAAAoB,SAAA0M,GAAA3L,EAAAO,OAEA,OADAA,GAAA1B,EAAAuL,iBAAAxK,EAAAW,EAAA1C,KAAAkP,gBAEAxM,SACAH,cAAAJ,EAAAI,cACAE,gBAAAN,EAAAM,gBACAI,aAAAV,EAAAU,aACAC,eAAAX,EAAAW,eACAC,KAAA,OAAAZ,EAAAY,KAAA,KAAA/C,KAAAsB,OAAAwM,GAAA3L,EAAAY,QAEK/C,MAAAkD,QAAAqL,EAAAmC,IAyBL9P,EAAAe,UAAAmP,yBACA,SAAAhQ,GACA,GAAAwB,GAAAtB,EAAAC,OAAAH,EAAA,QAMAiQ,GACArO,OAAA1B,EAAAC,OAAAH,EAAA,UACA+B,aAAAP,EACAQ,eAAA9B,EAAAC,OAAAH,EAAA,YAIA,IADAiQ,EAAArO,OAAA1C,KAAAgR,iBAAAD,EAAArO,QACAqO,EAAArO,OAAA,EACA,QAGA,IAAAkD,MAEAqF,EAAAjL,KAAAiR,aAAAF,EACA/Q,KAAA6Q,kBACA,eACA,iBACA7P,EAAA0K,2BACAiE,EAAAY,kBACA,IAAAtF,GAAA,GACA,GAAA9I,GAAAnC,KAAA6Q,kBAAA5F,EAEA,IAAAiG,SAAApQ,EAAA0B,OAOA,IANA,GAAAK,GAAAV,EAAAU,aAMAV,KAAAU,kBACA+C,EAAAgI,MACAtL,KAAAtB,EAAAC,OAAAkB,EAAA,sBACAK,OAAAxB,EAAAC,OAAAkB,EAAA,wBACAgP,WAAAnQ,EAAAC,OAAAkB,EAAA,8BAGAA,EAAAnC,KAAA6Q,oBAAA5F,OASA,KANA,GAAAnI,GAAAX,EAAAW,eAMAX,GACAA,EAAAU,eAAAP,GACAH,EAAAW,mBACA8C,EAAAgI,MACAtL,KAAAtB,EAAAC,OAAAkB,EAAA,sBACAK,OAAAxB,EAAAC,OAAAkB,EAAA,wBACAgP,WAAAnQ,EAAAC,OAAAkB,EAAA,8BAGAA,EAAAnC,KAAA6Q,oBAAA5F,GAKA,MAAArF,IAGAhG,EAAAgB,oBAgGAoO,EAAArN,UAAAmC,OAAAC,OAAAnD,EAAAe,WACAqN,EAAArN,UAAA+N,SAAA9O,EAMAoO,EAAArN,UAAAqP,iBAAA,SAAAnM,GACA,GAAAuM,GAAAvM,CAKA,IAJA,MAAA7E,KAAA+B,aACAqP,EAAApQ,EAAA2B,SAAA3C,KAAA+B,WAAAqP,IAGApR,KAAAoB,SAAAiC,IAAA+N,GACA,MAAApR,MAAAoB,SAAA8E,QAAAkL,EAKA,IAAAtL,EACA,KAAAA,EAAA,EAAaA,EAAA9F,KAAAiP,iBAAA/K,SAAkC4B,EAC/C,GAAA9F,KAAAiP,iBAAAnJ,IAAAjB,EACA,MAAAiB,EAIA,WAYAkJ,EAAAnN,cACA,SAAA8M,EAAAC,GACA,GAAAyC,GAAAvN,OAAAC,OAAAiL,EAAArN,WAEAgF,EAAA0K,EAAA/P,OAAAD,EAAA8L,UAAAwB,EAAArN,OAAAuE,WAAA,GACA5C,EAAAoO,EAAAjQ,SAAAC,EAAA8L,UAAAwB,EAAAvN,SAAAyE,WAAA,EACAwL,GAAAtP,WAAA4M,EAAAzN,YACAmQ,EAAAzK,eAAA+H,EAAAxI,wBAAAkL,EAAAjQ,SAAAyE,UACAwL,EAAAtP,YACAsP,EAAApP,KAAA0M,EAAA5N,MACAsQ,EAAAnC,cAAAN,EACAyC,EAAApC,iBAAAoC,EAAAjQ,SAAAyE,UAAAS,IAAA,SAAAiF,GACA,MAAAvK,GAAAuL,iBAAA8E,EAAAtP,WAAAwJ,EAAAqD,IAYA,QAJA0C,GAAA3C,EAAApN,UAAAsE,UAAAsF,QACAoG,EAAAF,EAAAxB,uBACA2B,EAAAH,EAAAnB,sBAEApK,EAAA,EAAA5B,EAAAoN,EAAApN,OAAsD4B,EAAA5B,EAAY4B,IAAA,CAClE,GAAA2L,GAAAH,EAAAxL,GACA4L,EAAA,GAAAvC,EACAuC,GAAAnP,cAAAkP,EAAAlP,cACAmP,EAAAjP,gBAAAgP,EAAAhP,gBAEAgP,EAAA/O,SACAgP,EAAAhP,OAAAO,EAAAiD,QAAAuL,EAAA/O,QACAgP,EAAA7O,aAAA4O,EAAA5O,aACA6O,EAAA5O,eAAA2O,EAAA3O,eAEA2O,EAAA1O,OACA2O,EAAA3O,KAAA4D,EAAAT,QAAAuL,EAAA1O,OAGAyO,EAAA5D,KAAA8D,IAGAH,EAAA3D,KAAA8D,GAKA,MAFA9B,GAAAyB,EAAAnB,mBAAAlP,EAAA0K,4BAEA2F,GAMArC,EAAArN,UAAAC,SAAA,EAKAkC,OAAAgM,eAAAd,EAAArN,UAAA,WACAkM,IAAA,WACA,MAAA7N,MAAAiP,iBAAA9D,WAqBA6D,EAAArN,UAAAsO,eACA,SAAArI,EAAAvB,GAeA,IAdA,GAYAlE,GAAAkK,EAAAsF,EAAAC,EAAAxJ,EAZA7F,EAAA,EACA8C,EAAA,EACAG,EAAA,EACAD,EAAA,EACAG,EAAA,EACAD,EAAA,EACAvB,EAAA0D,EAAA1D,OACA+G,EAAA,EACA4G,KACAC,KACAC,KACAT,KAGArG,EAAA/G,GACA,SAAA0D,EAAAO,OAAA8C,GACA1I,IACA0I,IACA5F,EAAA,MAEA,UAAAuC,EAAAO,OAAA8C,GACAA,QAEA,CASA,IARA9I,EAAA,GAAAgN,GACAhN,EAAAI,gBAOAqP,EAAA3G,EAAyB2G,EAAA1N,IACzBlE,KAAAmQ,wBAAAvI,EAAAgK,GADuCA,KAQvC,GAHAvF,EAAAzE,EAAAuD,MAAAF,EAAA2G,GAEAD,EAAAE,EAAAxF,GAEApB,GAAAoB,EAAAnI,WACS,CAET,IADAyN,KACA1G,EAAA2G,GACAlQ,EAAAiG,OAAAC,EAAAqD,EAAA6G,GACA1J,EAAA0J,EAAA1J,MACA6C,EAAA6G,EAAAzJ,KACAsJ,EAAA/D,KAAAxF,EAGA,QAAAuJ,EAAAzN,OACA,SAAAG,OAAA,yCAGA,QAAAsN,EAAAzN,OACA,SAAAG,OAAA,yCAGAwN,GAAAxF,GAAAsF,EAIAxP,EAAAM,gBAAA4C,EAAAsM,EAAA,GACAtM,EAAAlD,EAAAM,gBAEAkP,EAAAzN,OAAA,IAEA/B,EAAAO,OAAAgD,EAAAiM,EAAA,GACAjM,GAAAiM,EAAA,GAGAxP,EAAAU,aAAA2C,EAAAmM,EAAA,GACAnM,EAAArD,EAAAU,aAEAV,EAAAU,cAAA,EAGAV,EAAAW,eAAAyC,EAAAoM,EAAA,GACApM,EAAApD,EAAAW,eAEA6O,EAAAzN,OAAA,IAEA/B,EAAAY,KAAA0C,EAAAkM,EAAA,GACAlM,GAAAkM,EAAA,KAIAL,EAAA1D,KAAAzL,GACA,gBAAAA,GAAAU,cACAkP,EAAAnE,KAAAzL,GAKAyN,EAAA0B,EAAAtQ,EAAAgL,qCACAhM,KAAA6P,oBAAAyB,EAEA1B,EAAAmC,EAAA/Q,EAAA0K,4BACA1L,KAAAkQ,mBAAA6B,GAOA/C,EAAArN,UAAAsP,aACA,SAAAe,EAAAC,EAAAC,EACAC,EAAAC,EAAAC,GAMA,GAAAL,EAAAE,IAAA,EACA,SAAAzJ,WAAA,gDACAuJ,EAAAE,GAEA,IAAAF,EAAAG,GAAA,EACA,SAAA1J,WAAA,kDACAuJ,EAAAG,GAGA,OAAAxC,GAAA2C,OAAAN,EAAAC,EAAAG,EAAAC,IAOArD,EAAArN,UAAA4Q,mBACA,WACA,OAAAtH,GAAA,EAAuBA,EAAAjL,KAAA4Q,mBAAA1M,SAAwC+G,EAAA,CAC/D,GAAA9I,GAAAnC,KAAA4Q,mBAAA3F,EAMA,IAAAA,EAAA,EAAAjL,KAAA4Q,mBAAA1M,OAAA,CACA,GAAAsO,GAAAxS,KAAA4Q,mBAAA3F,EAAA,EAEA,IAAA9I,EAAAI,gBAAAiQ,EAAAjQ,cAAA,CACAJ,EAAAsQ,oBAAAD,EAAA/P,gBAAA,CACA,WAKAN,EAAAsQ,oBAAAC,MA4BA1D,EAAArN,UAAA8C,oBACA,SAAA3D,GACA,GAAAiQ,IACAxO,cAAAvB,EAAAC,OAAAH,EAAA,QACA2B,gBAAAzB,EAAAC,OAAAH,EAAA,WAGAmK,EAAAjL,KAAAiR,aACAF,EACA/Q,KAAA4Q,mBACA,gBACA,kBACA5P,EAAAgL,oCACAhL,EAAAC,OAAAH,EAAA,OAAAF,EAAA0P,sBAGA,IAAArF,GAAA,GACA,GAAA9I,GAAAnC,KAAA4Q,mBAAA3F,EAEA,IAAA9I,EAAAI,gBAAAwO,EAAAxO,cAAA,CACA,GAAAG,GAAA1B,EAAAC,OAAAkB,EAAA,cACA,QAAAO,IACAA,EAAA1C,KAAAoB,SAAA0M,GAAApL,GACAA,EAAA1B,EAAAuL,iBAAAvM,KAAA+B,WAAAW,EAAA1C,KAAAkP,eAEA,IAAAnM,GAAA/B,EAAAC,OAAAkB,EAAA,YAIA,OAHA,QAAAY,IACAA,EAAA/C,KAAAsB,OAAAwM,GAAA/K,KAGAL,SACAJ,KAAAtB,EAAAC,OAAAkB,EAAA,qBACAK,OAAAxB,EAAAC,OAAAkB,EAAA,uBACAY,SAKA,OACAL,OAAA,KACAJ,KAAA,KACAE,OAAA,KACAO,KAAA,OAQAiM,EAAArN,UAAAgR,wBACA,WACA,QAAA3S,KAAA4G,iBAGA5G,KAAA4G,eAAA1C,QAAAlE,KAAAoB,SAAAmM,SACAvN,KAAA4G,eAAAgM,KAAA,SAAAC,GAA+C,aAAAA,MAQ/C7D,EAAArN,UAAA6B,iBACA,SAAAqB,EAAAiO,GACA,IAAA9S,KAAA4G,eACA,WAGA,IAAAqE,GAAAjL,KAAAgR,iBAAAnM,EACA,IAAAoG,GAAA,EACA,MAAAjL,MAAA4G,eAAAqE,EAGA,IAAAmG,GAAAvM,CACA,OAAA7E,KAAA+B,aACAqP,EAAApQ,EAAA2B,SAAA3C,KAAA+B,WAAAqP,GAGA,IAAAlH,EACA,UAAAlK,KAAA+B,aACAmI,EAAAlJ,EAAAuI,SAAAvJ,KAAA+B,aAAA,CAKA,GAAAgR,GAAA3B,EAAArG,QAAA,gBACA,YAAAb,EAAAP,QACA3J,KAAAoB,SAAAiC,IAAA0P,GACA,MAAA/S,MAAA4G,eAAA5G,KAAAoB,SAAA8E,QAAA6M,GAGA,MAAA7I,EAAAH,MAAA,KAAAG,EAAAH,OACA/J,KAAAoB,SAAAiC,IAAA,IAAA+N,GACA,MAAApR,MAAA4G,eAAA5G,KAAAoB,SAAA8E,QAAA,IAAAkL,IAQA,GAAA0B,EACA,WAGA,UAAAzO,OAAA,IAAA+M,EAAA,+BA2BApC,EAAArN,UAAAqR,qBACA,SAAAlS,GACA,GAAA4B,GAAA1B,EAAAC,OAAAH,EAAA,SAEA,IADA4B,EAAA1C,KAAAgR,iBAAAtO,GACAA,EAAA,EACA,OACAJ,KAAA,KACAE,OAAA,KACA2O,WAAA,KAIA,IAAAJ,IACArO,SACAG,aAAA7B,EAAAC,OAAAH,EAAA,QACAgC,eAAA9B,EAAAC,OAAAH,EAAA,WAGAmK,EAAAjL,KAAAiR,aACAF,EACA/Q,KAAA6Q,kBACA,eACA,iBACA7P,EAAA0K,2BACA1K,EAAAC,OAAAH,EAAA,OAAAF,EAAA0P,sBAGA,IAAArF,GAAA,GACA,GAAA9I,GAAAnC,KAAA6Q,kBAAA5F,EAEA,IAAA9I,EAAAO,SAAAqO,EAAArO,OACA,OACAJ,KAAAtB,EAAAC,OAAAkB,EAAA,sBACAK,OAAAxB,EAAAC,OAAAkB,EAAA,wBACAgP,WAAAnQ,EAAAC,OAAAkB,EAAA,6BAKA,OACAG,KAAA,KACAE,OAAA,KACA2O,WAAA,OAIAvR,EAAAoP,yBAmGAD,EAAApN,UAAAmC,OAAAC,OAAAnD,EAAAe,WACAoN,EAAApN,UAAAsR,YAAArS,EAKAmO,EAAApN,UAAAC,SAAA,EAKAkC,OAAAgM,eAAAf,EAAApN,UAAA,WACAkM,IAAA,WAEA,OADA5K,MACA6C,EAAA,EAAmBA,EAAA9F,KAAAqP,UAAAnL,OAA2B4B,IAC9C,OAAAoN,GAAA,EAAqBA,EAAAlT,KAAAqP,UAAAvJ,GAAA4J,SAAAzM,QAAAiB,OAA+CgP,IACpEjQ,EAAA2K,KAAA5N,KAAAqP,UAAAvJ,GAAA4J,SAAAzM,QAAAiQ,GAGA,OAAAjQ,MAuBA8L,EAAApN,UAAA8C,oBACA,SAAA3D,GACA,GAAAiQ,IACAxO,cAAAvB,EAAAC,OAAAH,EAAA,QACA2B,gBAAAzB,EAAAC,OAAAH,EAAA,WAKAqS,EAAAxD,EAAA2C,OAAAvB,EAAA/Q,KAAAqP,UACA,SAAA0B,EAAAqC,GACA,GAAAtH,GAAAiF,EAAAxO,cAAA6Q,EAAA3D,gBAAAlN,aACA,OAAAuJ,GACAA,EAGAiF,EAAAtO,gBACA2Q,EAAA3D,gBAAAhN,kBAEA2Q,EAAApT,KAAAqP,UAAA8D,EAEA,OAAAC,GASAA,EAAA1D,SAAAjL,qBACAnC,KAAAyO,EAAAxO,eACA6Q,EAAA3D,gBAAAlN,cAAA,GACAC,OAAAuO,EAAAtO,iBACA2Q,EAAA3D,gBAAAlN,gBAAAwO,EAAAxO,cACA6Q,EAAA3D,gBAAAhN,gBAAA,EACA,GACA4Q,KAAAvS,EAAAuS,QAdA3Q,OAAA,KACAJ,KAAA,KACAE,OAAA,KACAO,KAAA,OAmBAgM,EAAApN,UAAAgR,wBACA,WACA,MAAA3S,MAAAqP,UAAAiE,MAAA,SAAA/H,GACA,MAAAA,GAAAmE,SAAAiD,6BASA5D,EAAApN,UAAA6B,iBACA,SAAAqB,EAAAiO,GACA,OAAAhN,GAAA,EAAmBA,EAAA9F,KAAAqP,UAAAnL,OAA2B4B,IAAA,CAC9C,GAAAsN,GAAApT,KAAAqP,UAAAvJ,GAEAvC,EAAA6P,EAAA1D,SAAAlM,iBAAAqB,GAAA,EACA,IAAAtB,EACA,MAAAA,GAGA,GAAAuP,EACA,WAGA,UAAAzO,OAAA,IAAAQ,EAAA,+BAsBAkK,EAAApN,UAAAqR,qBACA,SAAAlS,GACA,OAAAgF,GAAA,EAAmBA,EAAA9F,KAAAqP,UAAAnL,OAA2B4B,IAAA,CAC9C,GAAAsN,GAAApT,KAAAqP,UAAAvJ,EAIA,IAAAsN,EAAA1D,SAAAsB,iBAAAhQ,EAAAC,OAAAH,EAAA,iBAGA,GAAAyS,GAAAH,EAAA1D,SAAAsD,qBAAAlS,EACA,IAAAyS,EAAA,CACA,GAAAC,IACAlR,KAAAiR,EAAAjR,MACA8Q,EAAA3D,gBAAAlN,cAAA,GACAC,OAAA+Q,EAAA/Q,QACA4Q,EAAA3D,gBAAAlN,gBAAAgR,EAAAjR,KACA8Q,EAAA3D,gBAAAhN,gBAAA,EACA,GAEA,OAAA+Q,KAIA,OACAlR,KAAA,KACAE,OAAA,OASAuM,EAAApN,UAAAsO,eACA,SAAArI,EAAAvB,GACArG,KAAA6P,uBACA7P,KAAAkQ,qBACA,QAAApK,GAAA,EAAmBA,EAAA9F,KAAAqP,UAAAnL,OAA2B4B,IAG9C,OAFAsN,GAAApT,KAAAqP,UAAAvJ,GACA2N,EAAAL,EAAA1D,SAAAkB,mBACAsC,EAAA,EAAqBA,EAAAO,EAAAvP,OAA4BgP,IAAA,CACjD,GAAA/Q,GAAAsR,EAAAP,GAEAxQ,EAAA0Q,EAAA1D,SAAAtO,SAAA0M,GAAA3L,EAAAO,OACAA,GAAA1B,EAAAuL,iBAAA6G,EAAA1D,SAAA3N,WAAAW,EAAA1C,KAAAkP,eACAlP,KAAAoB,SAAAkC,IAAAZ,GACAA,EAAA1C,KAAAoB,SAAA8E,QAAAxD,EAEA,IAAAK,GAAA,IACAZ,GAAAY,OACAA,EAAAqQ,EAAA1D,SAAApO,OAAAwM,GAAA3L,EAAAY,MACA/C,KAAAsB,OAAAgC,IAAAP,GACAA,EAAA/C,KAAAsB,OAAA4E,QAAAnD,GAOA,IAAA2Q,IACAhR,SACAH,cAAAJ,EAAAI,eACA6Q,EAAA3D,gBAAAlN,cAAA,GACAE,gBAAAN,EAAAM,iBACA2Q,EAAA3D,gBAAAlN,gBAAAJ,EAAAI,cACA6Q,EAAA3D,gBAAAhN,gBAAA,EACA,GACAI,aAAAV,EAAAU,aACAC,eAAAX,EAAAW,eACAC,OAGA/C,MAAA6P,oBAAAjC,KAAA8F,GACA,gBAAAA,GAAA7Q,cACA7C,KAAAkQ,mBAAAtC,KAAA8F,GAKA9D,EAAA5P,KAAA6P,oBAAA7O,EAAAgL,qCACA4D,EAAA5P,KAAAkQ,mBAAAlP,EAAA0K,6BAGA9L,EAAAmP,4BTu5CM,SAAUlP,EAAQD,GUx/ExB,QAAA+T,GAAAC,EAAAC,EAAA7B,EAAA8B,EAAAC,EAAA1B,GAUA,GAAA2B,GAAAC,KAAAC,OAAAL,EAAAD,GAAA,GAAAA,EACA9H,EAAAiI,EAAA/B,EAAA8B,EAAAE,IAAA,EACA,YAAAlI,EAEAkI,EAEAlI,EAAA,EAEA+H,EAAAG,EAAA,EAEAL,EAAAK,EAAAH,EAAA7B,EAAA8B,EAAAC,EAAA1B,GAKAA,GAAAzS,EAAA2Q,kBACAsD,EAAAC,EAAA5P,OAAA2P,GAAA,EAEAG,EAKAA,EAAAJ,EAAA,EAEAD,EAAAC,EAAAI,EAAAhC,EAAA8B,EAAAC,EAAA1B,GAIAA,GAAAzS,EAAA2Q,kBACAyD,EAEAJ,EAAA,KAAAA,EA1DAhU,EAAA0Q,qBAAA,EACA1Q,EAAA2Q,kBAAA,EAgFA3Q,EAAA0S,OAAA,SAAAN,EAAA8B,EAAAC,EAAA1B,GACA,OAAAyB,EAAA5P,OACA,QAGA,IAAA+G,GAAA0I,GAAA,EAAAG,EAAA5P,OAAA8N,EAAA8B,EACAC,EAAA1B,GAAAzS,EAAA0Q,qBACA,IAAArF,EAAA,EACA,QAMA,MAAAA,EAAA,MACA,IAAA8I,EAAAD,EAAA7I,GAAA6I,EAAA7I,EAAA,UAGAA,CAGA,OAAAA,KVuhFM,SAAUpL,EAAQD,GWzmFxB,QAAAuU,GAAAC,EAAAC,EAAAC,GACA,GAAAxC,GAAAsC,EAAAC,EACAD,GAAAC,GAAAD,EAAAE,GACAF,EAAAE,GAAAxC,EAWA,QAAAyC,GAAAC,EAAAC,GACA,MAAAR,MAAAS,MAAAF,EAAAP,KAAAU,UAAAF,EAAAD,IAeA,QAAAI,GAAAR,EAAAS,EAAAnU,EAAAoU,GAKA,GAAApU,EAAAoU,EAAA,CAYA,GAAAC,GAAAR,EAAA7T,EAAAoU,GACAhP,EAAApF,EAAA,CAEAyT,GAAAC,EAAAW,EAAAD,EASA,QARAE,GAAAZ,EAAAU,GAQA5B,EAAAxS,EAAmBwS,EAAA4B,EAAO5B,IAC1B2B,EAAAT,EAAAlB,GAAA8B,IAAA,IACAlP,GAAA,EACAqO,EAAAC,EAAAtO,EAAAoN,GAIAiB,GAAAC,EAAAtO,EAAA,EAAAoN,EACA,IAAA+B,GAAAnP,EAAA,CAIA8O,GAAAR,EAAAS,EAAAnU,EAAAuU,EAAA,GACAL,EAAAR,EAAAS,EAAAI,EAAA,EAAAH,IAYAlV,EAAAgQ,UAAA,SAAAwE,EAAAS,GACAD,EAAAR,EAAAS,EAAA,EAAAT,EAAAlQ,OAAA,KX4oFM,SAAUrE,EAAQD,EAASM,GY1tFjC,QAAAW,GAAAqU,EAAAC,EAAAtQ,EAAAuQ,EAAAtQ,GACA9E,KAAAqV,YACArV,KAAAsV,kBACAtV,KAAAsC,KAAA,MAAA4S,EAAA,KAAAA,EACAlV,KAAAwC,OAAA,MAAA2S,EAAA,KAAAA,EACAnV,KAAA0C,OAAA,MAAAmC,EAAA,KAAAA,EACA7E,KAAA+C,KAAA,MAAA+B,EAAA,KAAAA,EACA9E,KAAAuV,IAAA,EACA,MAAAH,GAAApV,KAAAsD,IAAA8R,GAnCA,GAAAzU,GAAAT,EAAA,GAAAS,mBACAK,EAAAd,EAAA,GAIAsV,EAAA,UAGAC,EAAA,GAKAF,EAAA,oBAiCA1U,GAAA6U,wBACA,SAAAC,EAAA7T,EAAA8T,GA+FA,QAAAC,GAAA1T,EAAA2T,GACA,UAAA3T,GAAA+O,SAAA/O,EAAAO,OACAqT,EAAAzS,IAAAwS,OACO,CACP,GAAApT,GAAAkT,EACA5U,EAAA0D,KAAAkR,EAAAzT,EAAAO,QACAP,EAAAO,MACAqT,GAAAzS,IAAA,GAAAzC,GAAAsB,EAAAU,aACAV,EAAAW,eACAJ,EACAoT,EACA3T,EAAAY,QAvGA,GAAAgT,GAAA,GAAAlV,GAMAmV,EAAAL,EAAApN,MAAAiN,GACAS,EAAA,EACAC,EAAA,WAMA,QAAAC,KACA,MAAAF,GAAAD,EAAA9R,OACA8R,EAAAC,KAAA/E,OAPA,GAAAkF,GAAAD,IAEAE,EAAAF,KAAA,EACA,OAAAC,GAAAC,GASAC,EAAA,EAAA7D,EAAA,EAKA8D,EAAA,IAgEA,OA9DAzU,GAAAI,YAAA,SAAAC,GACA,UAAAoU,EAAA,CAGA,KAAAD,EAAAnU,EAAAI,eAMS,CAIT,GAAAiU,GAAAR,EAAAC,IAAA,GACAH,EAAAU,EAAAnL,OAAA,EAAAlJ,EAAAM,gBACAgQ,EAOA,OANAuD,GAAAC,GAAAO,EAAAnL,OAAAlJ,EAAAM,gBACAgQ,GACAA,EAAAtQ,EAAAM,gBACAoT,EAAAU,EAAAT,QAEAS,EAAApU,GAhBA0T,EAAAU,EAAAL,KACAI,IACA7D,EAAA,EAqBA,KAAA6D,EAAAnU,EAAAI,eACAwT,EAAAzS,IAAA4S,KACAI,GAEA,IAAA7D,EAAAtQ,EAAAM,gBAAA,CACA,GAAA+T,GAAAR,EAAAC,IAAA,EACAF,GAAAzS,IAAAkT,EAAAnL,OAAA,EAAAlJ,EAAAM,kBACAuT,EAAAC,GAAAO,EAAAnL,OAAAlJ,EAAAM,iBACAgQ,EAAAtQ,EAAAM,gBAEA8T,EAAApU,GACKnC,MAELiW,EAAAD,EAAA9R,SACAqS,GAEAV,EAAAU,EAAAL,KAGAH,EAAAzS,IAAA0S,EAAAvL,OAAAwL,GAAAvR,KAAA,MAIA5C,EAAAmB,QAAAC,QAAA,SAAAC,GACA,GAAAI,GAAAzB,EAAA0B,iBAAAL,EACA,OAAAI,IACA,MAAAqS,IACAzS,EAAAnC,EAAA0D,KAAAkR,EAAAzS,IAEA4S,EAAAtS,iBAAAN,EAAAI,MAIAwS,GAwBAlV,EAAAc,UAAA2B,IAAA,SAAAmT,GACA,GAAArL,MAAAsL,QAAAD,GACAA,EAAAvT,QAAA,SAAAyT,GACA3W,KAAAsD,IAAAqT,IACK3W,UAEL,KAAAyW,EAAAlB,IAAA,gBAAAkB,GAMA,SAAAhO,WACA,8EAAAgO,EANAA,IACAzW,KAAAqV,SAAAzH,KAAA6I,GAQA,MAAAzW,OASAa,EAAAc,UAAAiV,QAAA,SAAAH,GACA,GAAArL,MAAAsL,QAAAD,GACA,OAAA3Q,GAAA2Q,EAAAvS,OAAA,EAAiC4B,GAAA,EAAQA,IACzC9F,KAAA4W,QAAAH,EAAA3Q,QAGA,KAAA2Q,EAAAlB,IAAA,gBAAAkB,GAIA,SAAAhO,WACA,8EAAAgO,EAJAzW,MAAAqV,SAAAwB,QAAAJ,GAOA,MAAAzW,OAUAa,EAAAc,UAAAmV,KAAA,SAAAC,GAEA,OADAJ,GACA7Q,EAAA,EAAAC,EAAA/F,KAAAqV,SAAAnR,OAA6C4B,EAAAC,EAASD,IACtD6Q,EAAA3W,KAAAqV,SAAAvP,GACA6Q,EAAApB,GACAoB,EAAAG,KAAAC,GAGA,KAAAJ,GACAI,EAAAJ,GAAoBjU,OAAA1C,KAAA0C,OACpBJ,KAAAtC,KAAAsC,KACAE,OAAAxC,KAAAwC,OACAO,KAAA/C,KAAA+C,QAYAlC,EAAAc,UAAA+C,KAAA,SAAAsS,GACA,GAAAC,GACAnR,EACAC,EAAA/F,KAAAqV,SAAAnR,MACA,IAAA6B,EAAA,GAEA,IADAkR,KACAnR,EAAA,EAAeA,EAAAC,EAAA,EAAWD,IAC1BmR,EAAArJ,KAAA5N,KAAAqV,SAAAvP,IACAmR,EAAArJ,KAAAoJ,EAEAC,GAAArJ,KAAA5N,KAAAqV,SAAAvP,IACA9F,KAAAqV,SAAA4B,EAEA,MAAAjX,OAUAa,EAAAc,UAAAuV,aAAA,SAAAC,EAAAC,GACA,GAAAC,GAAArX,KAAAqV,SAAArV,KAAAqV,SAAAnR,OAAA,EAUA,OATAmT,GAAA9B,GACA8B,EAAAH,aAAAC,EAAAC,GAEA,gBAAAC,GACArX,KAAAqV,SAAArV,KAAAqV,SAAAnR,OAAA,GAAAmT,EAAAtM,QAAAoM,EAAAC,GAGApX,KAAAqV,SAAAzH,KAAA,GAAA7C,QAAAoM,EAAAC,IAEApX,MAUAa,EAAAc,UAAA8B,iBACA,SAAAG,EAAAC,GACA7D,KAAAsV,eAAAtU,EAAAgD,YAAAJ,IAAAC,GASAhD,EAAAc,UAAA2V,mBACA,SAAAP,GACA,OAAAjR,GAAA,EAAAC,EAAA/F,KAAAqV,SAAAnR,OAA+C4B,EAAAC,EAASD,IACxD9F,KAAAqV,SAAAvP,GAAAyP,IACAvV,KAAAqV,SAAAvP,GAAAwR,mBAAAP,EAKA,QADA9T,GAAAa,OAAAG,KAAAjE,KAAAsV,gBACAxP,EAAA,EAAAC,EAAA9C,EAAAiB,OAAyC4B,EAAAC,EAASD,IAClDiR,EAAA/V,EAAAyK,cAAAxI,EAAA6C,IAAA9F,KAAAsV,eAAArS,EAAA6C,MAQAjF,EAAAc,UAAAkF,SAAA,WACA,GAAAwF,GAAA,EAIA,OAHArM,MAAA8W,KAAA,SAAAH,GACAtK,GAAAsK,IAEAtK,GAOAxL,EAAAc,UAAA4V,sBAAA,SAAAzW,GACA,GAAAuB,IACAyT,KAAA,GACAxT,KAAA,EACAE,OAAA,GAEA8D,EAAA,GAAA3F,GAAAG,GACA0W,GAAA,EACAC,EAAA,KACAC,EAAA,KACAC,EAAA,KACAC,EAAA,IAqEA,OApEA5X,MAAA8W,KAAA,SAAAH,EAAA/T,GACAP,EAAAyT,MAAAa,EACA,OAAA/T,EAAAF,QACA,OAAAE,EAAAN,MACA,OAAAM,EAAAJ,QACAiV,IAAA7U,EAAAF,QACAgV,IAAA9U,EAAAN,MACAqV,IAAA/U,EAAAJ,QACAoV,IAAAhV,EAAAG,MACAuD,EAAAtD,YACAN,OAAAE,EAAAF,OACAE,UACAN,KAAAM,EAAAN,KACAE,OAAAI,EAAAJ,QAEAH,WACAC,KAAAD,EAAAC,KACAE,OAAAH,EAAAG,QAEAO,KAAAH,EAAAG,OAGA0U,EAAA7U,EAAAF,OACAgV,EAAA9U,EAAAN,KACAqV,EAAA/U,EAAAJ,OACAoV,EAAAhV,EAAAG,KACAyU,GAAA,GACKA,IACLlR,EAAAtD,YACAX,WACAC,KAAAD,EAAAC,KACAE,OAAAH,EAAAG,UAGAiV,EAAA,KACAD,GAAA,EAEA,QAAA7J,GAAA,EAAAzJ,EAAAyS,EAAAzS,OAA4CyJ,EAAAzJ,EAAcyJ,IAC1DgJ,EAAAzO,WAAAyF,KAAA8H,GACApT,EAAAC,OACAD,EAAAG,OAAA,EAEAmL,EAAA,IAAAzJ,GACAuT,EAAA,KACAD,GAAA,GACSA,GACTlR,EAAAtD,YACAN,OAAAE,EAAAF,OACAE,UACAN,KAAAM,EAAAN,KACAE,OAAAI,EAAAJ,QAEAH,WACAC,KAAAD,EAAAC,KACAE,OAAAH,EAAAG,QAEAO,KAAAH,EAAAG,QAIAV,EAAAG,WAIAxC,KAAAsX,mBAAA,SAAAnU,EAAA0U,GACAvR,EAAA7C,iBAAAN,EAAA0U,MAGU/B,KAAAzT,EAAAyT,KAAAxP,QAGV1G,EAAAiB”,“file”:“source-map.min.js”,“sourcesContent”:[“(function webpackUniversalModuleDefinition(root, factory) {ntif(typeof exports === 'object' && typeof module === 'object')nttmodule.exports = factory();ntelse if(typeof define === 'function' && define.amd)nttdefine([], factory);ntelse if(typeof exports === 'object’)nttexports = factory();ntelsenttroot = factory();n})(this, function() {nreturn nnn// WEBPACK FOOTER //n// webpack/universalModuleDefinition”,“(function webpackUniversalModuleDefinition(root, factory) {ntif(typeof exports === 'object' && typeof module === 'object')nttmodule.exports = factory();ntelse if(typeof define === 'function' && define.amd)nttdefine([], factory);ntelse if(typeof exports === 'object’)nttexports = factory();ntelsenttroot = factory();n})(this, function() {nreturn /******/ (function(modules) { // webpackBootstrapn/******/ t// The module cachen/******/ tvar installedModules = {};n/******/n/******/ t// The require functionn/******/ tfunction webpack_require(moduleId) {n/******/n/******/ tt// Check if module is in cachen/******/ ttif(installedModules[moduleId])n/******/ tttreturn installedModules.exports;n/******/n/******/ tt// Create a new module (and put it into the cache)n/******/ ttvar module = installedModules = {n/******/ tttexports: {},n/******/ tttid: moduleId,n/******/ tttloaded: falsen/******/ tt};n/******/n/******/ tt// Execute the module functionn/******/ ttmodules[moduleId].call(module.exports, module, module.exports, webpack_require);n/******/n/******/ tt// Flag the module as loadedn/******/ ttmodule.loaded = true;n/******/n/******/ tt// Return the exports of the modulen/******/ ttreturn 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 cachen/******/ t_webpack_require_.c = installedModules;n/******/n/******/ t// webpack_public_pathn/******/ t_webpack_require_.p = "";n/******/n/******/ t// Load entry module and return exportsn/******/ treturn webpack_require(0);n/******/ })n/************************************************************************/n/******/ ([n/* 0 */n/***/ (function(module, exports, webpack_require) {nnt/*nt * Copyright 2009-2011 Mozilla Foundation and contributorsnt * Licensed under the New BSD license. See LICENSE.txt or:nt * opensource.org/licenses/BSD-3-Clausent */ntexports.SourceMapGenerator = webpack_require(1).SourceMapGenerator;ntexports.SourceMapConsumer = webpack_require(7).SourceMapConsumer;ntexports.SourceNode = webpack_require(10).SourceNode;nnn/***/ }),n/* 1 */n/***/ (function(module, exports, webpack_require) {nnt/* -*- Mode: js; js-indent-level: 2; -*- */nt/*nt * Copyright 2011 Mozilla Foundation and contributorsnt * Licensed under the New BSD license. See LICENSE or:nt * opensource.org/licenses/BSD-3-Clausent */ntntvar base64VLQ = webpack_require(2);ntvar util = webpack_require(4);ntvar ArraySet = webpack_require(5).ArraySet;ntvar MappingList = webpack_require(6).MappingList;ntnt/**nt * An instance of the SourceMapGenerator represents a source map which isnt * being built incrementally. You may pass an object with the followingnt * properties:nt *nt * - file: The filename of the generated source.nt * - sourceRoot: A root for all relative URLs in this source map.nt */ntfunction SourceMapGenerator(aArgs) {nt if (!aArgs) {nt aArgs = {};nt }nt this._file = util.getArg(aArgs, 'file', null);nt this._sourceRoot = util.getArg(aArgs, 'sourceRoot', null);nt this._skipValidation = util.getArg(aArgs, 'skipValidation', false);nt this._sources = new ArraySet();nt this._names = new ArraySet();nt this._mappings = new MappingList();nt this._sourcesContents = null;nt}ntntSourceMapGenerator.prototype._version = 3;ntnt/**nt * Creates a new SourceMapGenerator based on a SourceMapConsumernt *nt * @param aSourceMapConsumer The SourceMap.nt */ntSourceMapGenerator.fromSourceMap =nt function SourceMapGenerator_fromSourceMap(aSourceMapConsumer) {nt var sourceRoot = aSourceMapConsumer.sourceRoot;nt var generator = new SourceMapGenerator({nt file: aSourceMapConsumer.file,nt sourceRoot: sourceRootnt });nt aSourceMapConsumer.eachMapping(function (mapping) {nt var newMapping = {nt generated: {nt line: mapping.generatedLine,nt column: mapping.generatedColumnnt }nt };ntnt if (mapping.source != null) {nt newMapping.source = mapping.source;nt if (sourceRoot != null) {nt newMapping.source = util.relative(sourceRoot, newMapping.source);nt }ntnt newMapping.original = {nt line: mapping.originalLine,nt column: mapping.originalColumnnt };ntnt if (mapping.name != null) {nt newMapping.name = mapping.name;nt }nt }ntnt generator.addMapping(newMapping);nt });nt aSourceMapConsumer.sources.forEach(function (sourceFile) {nt var sourceRelative = sourceFile;nt if (sourceRoot !== null) {nt sourceRelative = util.relative(sourceRoot, sourceFile);nt }ntnt if (!generator._sources.has(sourceRelative)) {nt generator._sources.add(sourceRelative);nt }ntnt var content = aSourceMapConsumer.sourceContentFor(sourceFile);nt if (content != null) {nt generator.setSourceContent(sourceFile, content);nt }nt });nt return generator;nt };ntnt/**nt * Add a single mapping from original source line and column to the generatednt * source's line and column for this source map being created. The mappingnt * object should have the following properties:nt *nt * - generated: An object with the generated line and column positions.nt * - original: An object with the original line and column positions.nt * - source: The original source file (relative to the sourceRoot).nt * - name: An optional original token name for this mapping.nt */ntSourceMapGenerator.prototype.addMapping =nt function SourceMapGenerator_addMapping(aArgs) {nt var generated = util.getArg(aArgs, 'generated');nt var original = util.getArg(aArgs, 'original', null);nt var source = util.getArg(aArgs, 'source', null);nt var name = util.getArg(aArgs, 'name', null);ntnt if (!this._skipValidation) {nt this._validateMapping(generated, original, source, name);nt }ntnt if (source != null) {nt source = String(source);nt if (!this._sources.has(source)) {nt this._sources.add(source);nt }nt }ntnt if (name != null) {nt name = String(name);nt if (!this._names.has(name)) {nt this._names.add(name);nt }nt }ntnt this._mappings.add({nt generatedLine: generated.line,nt generatedColumn: generated.column,nt originalLine: original != null && original.line,nt originalColumn: original != null && original.column,nt source: source,nt name: nament });nt };ntnt/**nt * Set the source content for a source file.nt */ntSourceMapGenerator.prototype.setSourceContent =nt function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {nt var source = aSourceFile;nt if (this._sourceRoot != null) {nt source = util.relative(this._sourceRoot, source);nt }ntnt if (aSourceContent != null) {nt // Add the source content to the _sourcesContents map.nt // Create a new _sourcesContents map if the property is null.nt if (!this._sourcesContents) {nt this._sourcesContents = Object.create(null);nt }nt this._sourcesContents = aSourceContent;nt } else if (this._sourcesContents) {nt // Remove the source file from the _sourcesContents map.nt // If the _sourcesContents map is empty, set the property to null.nt delete this._sourcesContents;nt if (Object.keys(this._sourcesContents).length === 0) {nt this._sourcesContents = null;nt }nt }nt };ntnt/**nt * Applies the mappings of a sub-source-map for a specific source file to thent * source map being generated. Each mapping to the supplied source file isnt * rewritten using the supplied source map. Note: The resolution for thent * resulting mappings is the minimium of this map and the supplied map.nt *nt * @param aSourceMapConsumer The source map to be applied.nt * @param aSourceFile Optional. The filename of the source file.nt * If omitted, SourceMapConsumer's file property will be used.nt * @param aSourceMapPath Optional. The dirname of the path to the source mapnt * to be applied. If relative, it is relative to the SourceMapConsumer.nt * This parameter is needed when the two source maps aren't in the sament * directory, and the source map to be applied contains relative sourcent * paths. If so, those relative source paths need to be rewrittennt * relative to the SourceMapGenerator.nt */ntSourceMapGenerator.prototype.applySourceMap =nt function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {nt var sourceFile = aSourceFile;nt // If aSourceFile is omitted, we will use the file property of the SourceMapnt if (aSourceFile == null) {nt if (aSourceMapConsumer.file == null) {nt throw new Error(nt 'SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, ' +nt 'or the source map\'s "file" property. Both were omitted.'nt );nt }nt sourceFile = aSourceMapConsumer.file;nt }nt var sourceRoot = this._sourceRoot;nt // Make "sourceFile" relative if an absolute Url is passed.nt if (sourceRoot != null) {nt sourceFile = util.relative(sourceRoot, sourceFile);nt }nt // Applying the SourceMap can add and remove items from the sources andnt // the names array.nt var newSources = new ArraySet();nt var newNames = new ArraySet();ntnt // Find mappings for the "sourceFile"nt this._mappings.unsortedForEach(function (mapping) {nt if (mapping.source === sourceFile && mapping.originalLine != null) {nt // Check if it can be mapped by the source map, then update the mapping.nt var original = aSourceMapConsumer.originalPositionFor({nt line: mapping.originalLine,nt column: mapping.originalColumnnt });nt if (original.source != null) {nt // Copy mappingnt mapping.source = original.source;nt if (aSourceMapPath != null) {nt mapping.source = util.join(aSourceMapPath, mapping.source)nt }nt if (sourceRoot != null) {nt mapping.source = util.relative(sourceRoot, mapping.source);nt }nt mapping.originalLine = original.line;nt mapping.originalColumn = original.column;nt if (original.name != null) {nt mapping.name = original.name;nt }nt }nt }ntnt var source = mapping.source;nt if (source != null && !newSources.has(source)) {nt newSources.add(source);nt }ntnt var name = mapping.name;nt if (name != null && !newNames.has(name)) {nt newNames.add(name);nt }ntnt }, this);nt this._sources = newSources;nt this._names = newNames;ntnt // Copy sourcesContents of applied map.nt aSourceMapConsumer.sources.forEach(function (sourceFile) {nt var content = aSourceMapConsumer.sourceContentFor(sourceFile);nt if (content != null) {nt if (aSourceMapPath != null) {nt sourceFile = util.join(aSourceMapPath, sourceFile);nt }nt if (sourceRoot != null) {nt sourceFile = util.relative(sourceRoot, sourceFile);nt }nt this.setSourceContent(sourceFile, content);nt }nt }, this);nt };ntnt/**nt * A mapping can have one of the three levels of data:nt *nt * 1. Just the generated position.nt * 2. The Generated position, original position, and original source.nt * 3. Generated and original position, original source, as well as a nament * token.nt *nt * To maintain consistency, we validate that any new mapping being added fallsnt * in to one of these categories.nt */ntSourceMapGenerator.prototype._validateMapping =nt function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource,nt aName) {nt // When aOriginal is truthy but has empty values for .line and .column,nt // it is most likely a programmer error. In this case we throw a verynt // specific error message to try to guide them the right way.nt // For example: github.com/Polymer/polymer-bundler/pull/519nt if (aOriginal && typeof aOriginal.line !== 'number' && typeof aOriginal.column !== 'number') {nt throw new Error(nt 'original.line and original.column are not numbers – you probably meant to omit ' +nt 'the original mapping entirely and only map the generated position. If so, pass ' +nt 'null for the original mapping instead of an object with empty or null values.'nt );nt }ntnt if (aGenerated && 'line' in aGenerated && 'column' in aGeneratednt && aGenerated.line > 0 && aGenerated.column >= 0nt && !aOriginal && !aSource && !aName) {nt // Case 1.nt return;nt }nt else if (aGenerated && 'line' in aGenerated && 'column' in aGeneratednt && aOriginal && 'line' in aOriginal && 'column' in aOriginalnt && aGenerated.line > 0 && aGenerated.column >= 0nt && aOriginal.line > 0 && aOriginal.column >= 0nt && aSource) {nt // Cases 2 and 3.nt return;nt }nt else {nt throw new Error('Invalid mapping: ' + JSON.stringify({nt generated: aGenerated,nt source: aSource,nt original: aOriginal,nt name: aNament }));nt }nt };ntnt/**nt * Serialize the accumulated mappings in to the stream of base 64 VLQsnt * specified by the source map format.nt */ntSourceMapGenerator.prototype._serializeMappings =nt function SourceMapGenerator_serializeMappings() {nt var previousGeneratedColumn = 0;nt var previousGeneratedLine = 1;nt var previousOriginalColumn = 0;nt var previousOriginalLine = 0;nt var previousName = 0;nt var previousSource = 0;nt var result = '';nt var next;nt var mapping;nt var nameIdx;nt var sourceIdx;ntnt var mappings = this._mappings.toArray();nt for (var i = 0, len = mappings.length; i < len; i++) {nt mapping = mappings;nt next = ''ntnt if (mapping.generatedLine !== previousGeneratedLine) {nt previousGeneratedColumn = 0;nt while (mapping.generatedLine !== previousGeneratedLine) {nt next += ';';nt previousGeneratedLine++;nt }nt }nt else {nt if (i > 0) {nt if (!util.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) {nt continue;nt }nt next += ',';nt }nt }ntnt next += base64VLQ.encode(mapping.generatedColumnnt - previousGeneratedColumn);nt previousGeneratedColumn = mapping.generatedColumn;ntnt if (mapping.source != null) {nt sourceIdx = this._sources.indexOf(mapping.source);nt next += base64VLQ.encode(sourceIdx - previousSource);nt previousSource = sourceIdx;ntnt // lines are stored 0-based in SourceMap spec version 3nt next += base64VLQ.encode(mapping.originalLine - 1nt - previousOriginalLine);nt previousOriginalLine = mapping.originalLine - 1;ntnt next += base64VLQ.encode(mapping.originalColumnnt - previousOriginalColumn);nt previousOriginalColumn = mapping.originalColumn;ntnt if (mapping.name != null) {nt nameIdx = this._names.indexOf(mapping.name);nt next += base64VLQ.encode(nameIdx - previousName);nt previousName = nameIdx;nt }nt }ntnt result += next;nt }ntnt return result;nt };ntntSourceMapGenerator.prototype._generateSourcesContent =nt function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {nt return aSources.map(function (source) {nt if (!this._sourcesContents) {nt return null;nt }nt if (aSourceRoot != null) {nt source = util.relative(aSourceRoot, source);nt }nt var key = util.toSetString(source);nt return Object.prototype.hasOwnProperty.call(this._sourcesContents, key)nt ? this._sourcesContentsnt : null;nt }, this);nt };ntnt/**nt * Externalize the source map.nt */ntSourceMapGenerator.prototype.toJSON =nt function SourceMapGenerator_toJSON() {nt var map = {nt version: this._version,nt sources: this._sources.toArray(),nt names: this._names.toArray(),nt mappings: this._serializeMappings()nt };nt if (this._file != null) {nt map.file = this._file;nt }nt if (this._sourceRoot != null) {nt map.sourceRoot = this._sourceRoot;nt }nt if (this._sourcesContents) {nt map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);nt }ntnt return map;nt };ntnt/**nt * Render the source map being generated to a string.nt */ntSourceMapGenerator.prototype.toString =nt function SourceMapGenerator_toString() {nt return JSON.stringify(this.toJSON());nt };ntntexports.SourceMapGenerator = SourceMapGenerator;nnn/***/ }),n/* 2 */n/***/ (function(module, exports, webpack_require) {nnt/* -*- Mode: js; js-indent-level: 2; -*- */nt/*nt * Copyright 2011 Mozilla Foundation and contributorsnt * Licensed under the New BSD license. See LICENSE or:nt * opensource.org/licenses/BSD-3-Clausent *nt * Based on the Base 64 VLQ implementation in Closure Compiler:nt * code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/debugging/sourcemap/Base64VLQ.javant *nt * Copyright 2011 The Closure Compiler Authors. All rights reserved.nt * Redistribution and use in source and binary forms, with or withoutnt * modification, are permitted provided that the following conditions arent * met:nt *nt * * Redistributions of source code must retain the above copyrightnt * notice, this list of conditions and the following disclaimer.nt * * Redistributions in binary form must reproduce the abovent * copyright notice, this list of conditions and the followingnt * disclaimer in the documentation and/or other materials providednt * with the distribution.nt * * Neither the name of Google Inc. nor the names of itsnt * contributors may be used to endorse or promote products derivednt * from this software without specific prior written permission.nt *nt * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORSnt * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOTnt * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FORnt * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHTnt * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,nt * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOTnt * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,nt * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANYnt * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORTnt * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USEnt * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.nt */ntntvar base64 = webpack_require(3);ntnt// A single base 64 digit can contain 6 bits of data. For the base 64 variablent// length quantities we use in the source map spec, the first bit is the sign,nt// the next four bits are the actual value, and the 6th bit is thent// continuation bit. The continuation bit tells us whether there are morent// digits in this value following this digit.nt//nt// Continuationnt// | Signnt// | |nt// V Vnt// 101011ntntvar VLQ_BASE_SHIFT = 5;ntnt// binary: 100000ntvar VLQ_BASE = 1 << VLQ_BASE_SHIFT;ntnt// binary: 011111ntvar VLQ_BASE_MASK = VLQ_BASE - 1;ntnt// binary: 100000ntvar VLQ_CONTINUATION_BIT = VLQ_BASE;ntnt/**nt * Converts from a two-complement value to a value where the sign bit isnt * placed in the least significant bit. For example, as decimals:nt * 1 becomes 2 (10 binary), -1 becomes 3 (11 binary)nt * 2 becomes 4 (100 binary), -2 becomes 5 (101 binary)nt */ntfunction toVLQSigned(aValue) {nt return aValue < 0nt ? ((-aValue) << 1) + 1nt : (aValue << 1) + 0;nt}ntnt/**nt * Converts to a two-complement value from a value where the sign bit isnt * placed in the least significant bit. For example, as decimals:nt * 2 (10 binary) becomes 1, 3 (11 binary) becomes -1nt * 4 (100 binary) becomes 2, 5 (101 binary) becomes -2nt */ntfunction fromVLQSigned(aValue) {nt var isNegative = (aValue & 1) === 1;nt var shifted = aValue >> 1;nt return isNegativent ? -shiftednt : shifted;nt}ntnt/**nt * Returns the base 64 VLQ encoded value.nt */ntexports.encode = function base64VLQ_encode(aValue) {nt var encoded = "";nt var digit;ntnt var vlq = toVLQSigned(aValue);ntnt do {nt digit = vlq & VLQ_BASE_MASK;nt vlq >>>= VLQ_BASE_SHIFT;nt if (vlq > 0) {nt // There are still more digits in this value, so we must make sure thent // continuation bit is marked.nt digit |= VLQ_CONTINUATION_BIT;nt }nt encoded += base64.encode(digit);nt } while (vlq > 0);ntnt return encoded;nt};ntnt/**nt * Decodes the next base 64 VLQ value from the given string and returns thent * value and the rest of the string via the out parameter.nt */ntexports.decode = function base64VLQ_decode(aStr, aIndex, aOutParam) {nt var strLen = aStr.length;nt var result = 0;nt var shift = 0;nt var continuation, digit;ntnt do {nt if (aIndex >= strLen) {nt throw new Error("Expected more digits in base 64 VLQ value.");nt }ntnt digit = base64.decode(aStr.charCodeAt(aIndex++));nt if (digit === -1) {nt throw new Error("Invalid base64 digit: " + aStr.charAt(aIndex - 1));nt }ntnt continuation = !!(digit & VLQ_CONTINUATION_BIT);nt digit &= VLQ_BASE_MASK;nt result = result + (digit << shift);nt shift += VLQ_BASE_SHIFT;nt } while (continuation);ntnt aOutParam.value = fromVLQSigned(result);nt aOutParam.rest = aIndex;nt};nnn/***/ }),n/* 3 */n/***/ (function(module, exports) {nnt/* -*- Mode: js; js-indent-level: 2; -*- */nt/*nt * Copyright 2011 Mozilla Foundation and contributorsnt * Licensed under the New BSD license. See LICENSE or:nt * opensource.org/licenses/BSD-3-Clausent */ntntvar intToCharMap = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split('');ntnt/**nt * Encode an integer in the range of 0 to 63 to a single base 64 digit.nt */ntexports.encode = function (number) {nt if (0 <= number && number < intToCharMap.length) {nt return intToCharMap;nt }nt throw new TypeError("Must be between 0 and 63: " + number);nt};ntnt/**nt * Decode a single base 64 character code digit to an integer. Returns -1 onnt * failure.nt */ntexports.decode = function (charCode) {nt var bigA = 65; // 'A'nt var bigZ = 90; // 'Z'ntnt var littleA = 97; // 'a'nt var littleZ = 122; // 'z'ntnt var zero = 48; // '0'nt var nine = 57; // '9'ntnt var plus = 43; // '+'nt var slash = 47; // '/'ntnt var littleOffset = 26;nt var numberOffset = 52;ntnt // 0 - 25: ABCDEFGHIJKLMNOPQRSTUVWXYZnt if (bigA <= charCode && charCode <= bigZ) {nt return (charCode - bigA);nt }ntnt // 26 - 51: abcdefghijklmnopqrstuvwxyznt if (littleA <= charCode && charCode <= littleZ) {nt return (charCode - littleA + littleOffset);nt }ntnt // 52 - 61: 0123456789nt if (zero <= charCode && charCode <= nine) {nt return (charCode - zero + numberOffset);nt }ntnt // 62: +nt if (charCode == plus) {nt return 62;nt }ntnt // 63: /nt if (charCode == slash) {nt return 63;nt }ntnt // Invalid base64 digit.nt return -1;nt};nnn/***/ }),n/* 4 */n/***/ (function(module, exports) {nnt/* -*- Mode: js; js-indent-level: 2; -*- */nt/*nt * Copyright 2011 Mozilla Foundation and contributorsnt * Licensed under the New BSD license. See LICENSE or:nt * opensource.org/licenses/BSD-3-Clausent */ntnt/**nt * This is a helper function for getting values from parameter/optionsnt * objects.nt *nt * @param args The object we are extracting values fromnt * @param name The name of the property we are getting.nt * @param defaultValue An optional value to return if the property is missingnt * from the object. If this is not specified and the property is missing, annt * error will be thrown.nt */ntfunction getArg(aArgs, aName, aDefaultValue) {nt if (aName in aArgs) {nt return aArgs;nt } else if (arguments.length === 3) {nt return aDefaultValue;nt } else {nt throw new Error('"' + aName + '" is a required argument.');nt }nt}ntexports.getArg = getArg;ntntvar urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?(*)(?::(\d+))?(.*)$/;ntvar dataUrlRegexp = /^data:.+\,.+$/;ntntfunction urlParse(aUrl) {nt var match = aUrl.match(urlRegexp);nt if (!match) {nt return null;nt }nt return {nt scheme: match,nt auth: match,nt host: match,nt port: match,nt path: matchnt };nt}ntexports.urlParse = urlParse;ntntfunction urlGenerate(aParsedUrl) {nt var url = '';nt if (aParsedUrl.scheme) {nt url += aParsedUrl.scheme + ':';nt }nt url += '//';nt if (aParsedUrl.auth) {nt url += aParsedUrl.auth + '@';nt }nt if (aParsedUrl.host) {nt url += aParsedUrl.host;nt }nt if (aParsedUrl.port) {nt url += ":" + aParsedUrl.portnt }nt if (aParsedUrl.path) {nt url += aParsedUrl.path;nt }nt return url;nt}ntexports.urlGenerate = urlGenerate;ntnt/**nt * Normalizes a path, or the path portion of a URL:nt *nt * - Replaces consecutive slashes with one slash.nt * - Removes unnecessary '.' parts.nt * - Removes unnecessary '<dir>/..' parts.nt *nt * Based on code in the Node.js 'path' core module.nt *nt * @param aPath The path or url to normalize.nt */ntfunction normalize(aPath) {nt var path = aPath;nt var url = urlParse(aPath);nt if (url) {nt if (!url.path) {nt return aPath;nt }nt path = url.path;nt }nt var isAbsolute = exports.isAbsolute(path);ntnt var parts = path.split(/\/+/);nt for (var part, up = 0, i = parts.length - 1; i >= 0; i–) {nt part = parts;nt if (part === '.') {nt parts.splice(i, 1);nt } else if (part === '..') {nt up++;nt } else if (up > 0) {nt if (part === '') {nt // The first part is blank if the path is absolute. Trying to gont // above the root is a no-op. Therefore we can remove all '..' partsnt // directly after the root.nt parts.splice(i + 1, up);nt up = 0;nt } else {nt parts.splice(i, 2);nt up–;nt }nt }nt }nt path = parts.join('/');ntnt if (path === '') {nt path = isAbsolute ? '/' : '.';nt }ntnt if (url) {nt url.path = path;nt return urlGenerate(url);nt }nt return path;nt}ntexports.normalize = normalize;ntnt/**nt * Joins two paths/URLs.nt *nt * @param aRoot The root path or URL.nt * @param aPath The path or URL to be joined with the root.nt *nt * - If aPath is a URL or a data URI, aPath is returned, unless aPath is ant * scheme-relative URL: Then the scheme of aRoot, if any, is prependednt * first.nt * - Otherwise aPath is a path. If aRoot is a URL, then its path portionnt * is updated with the result and aRoot is returned. Otherwise the resultnt * is returned.nt * - If aPath is absolute, the result is aPath.nt * - Otherwise the two paths are joined with a slash.nt * - Joining for example 'http://' and 'www.example.com' is also supported.nt */ntfunction join(aRoot, aPath) {nt if (aRoot === "") {nt aRoot = ".";nt }nt if (aPath === "") {nt aPath = ".";nt }nt var aPathUrl = urlParse(aPath);nt var aRootUrl = urlParse(aRoot);nt if (aRootUrl) {nt aRoot = aRootUrl.path || '/';nt }ntnt // `join(foo, '//www.example.org’)`nt if (aPathUrl && !aPathUrl.scheme) {nt if (aRootUrl) {nt aPathUrl.scheme = aRootUrl.scheme;nt }nt return urlGenerate(aPathUrl);nt }ntnt if (aPathUrl || aPath.match(dataUrlRegexp)) {nt return aPath;nt }ntnt // `join('http://', 'www.example.com’)`nt if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {nt aRootUrl.host = aPath;nt return urlGenerate(aRootUrl);nt }ntnt var joined = aPath.charAt(0) === '/'nt ? aPathnt : normalize(aRoot.replace(/\/+$/, '') + '/' + aPath);ntnt if (aRootUrl) {nt aRootUrl.path = joined;nt return urlGenerate(aRootUrl);nt }nt return joined;nt}ntexports.join = join;ntntexports.isAbsolute = function (aPath) {nt return aPath.charAt(0) === '/' || urlRegexp.test(aPath);nt};ntnt/**nt * Make a path relative to a URL or another path.nt *nt * @param aRoot The root path or URL.nt * @param aPath The path or URL to be made relative to aRoot.nt */ntfunction relative(aRoot, aPath) {nt if (aRoot === "") {nt aRoot = ".";nt }ntnt aRoot = aRoot.replace(/\/$/, '');ntnt // It is possible for the path to be above the root. In this case, simplynt // checking whether the root is a prefix of the path won't work. Instead, went // need to remove components from the root one by one, until either we findnt // a prefix that fits, or we run out of components to remove.nt var level = 0;nt while (aPath.indexOf(aRoot + '/') !== 0) {nt var index = aRoot.lastIndexOf("/");nt if (index < 0) {nt return aPath;nt }ntnt // If the only part of the root that is left is the scheme (i.e. ,nt // file:///, etc.), one or more slashes (/), or simply nothing at all, went // have exhausted all components, so the path is not relative to the root.nt aRoot = aRoot.slice(0, index);nt if (aRoot.match(/^(+:\/)?\/*$/)) {nt return aPath;nt }ntnt ++level;nt }ntnt // Make sure we add a "../" for each component we removed from the root.nt return Array(level + 1).join("../") + aPath.substr(aRoot.length + 1);nt}ntexports.relative = relative;ntntvar supportsNullProto = (function () {nt var obj = Object.create(null);nt return !('__proto__' in obj);nt}());ntntfunction identity (s) {nt return s;nt}ntnt/**nt * Because behavior goes wacky when you set `__proto__` on objects, went * have to prefix all the strings in our set with an arbitrary character.nt *nt * See github.com/mozilla/source-map/pull/31 andnt * github.com/mozilla/source-map/issues/30nt *nt * @param String aStrnt */ntfunction toSetString(aStr) {nt if (isProtoString(aStr)) {nt return '$' + aStr;nt }ntnt return aStr;nt}ntexports.toSetString = supportsNullProto ? identity : toSetString;ntntfunction fromSetString(aStr) {nt if (isProtoString(aStr)) {nt return aStr.slice(1);nt }ntnt return aStr;nt}ntexports.fromSetString = supportsNullProto ? identity : fromSetString;ntntfunction isProtoString(s) {nt if (!s) {nt return false;nt }ntnt var length = s.length;ntnt if (length < 9 /* "__proto__".length */) {nt return false;nt }ntnt if (s.charCodeAt(length - 1) !== 95 /* '_' */ ||nt s.charCodeAt(length - 2) !== 95 /* '_' */ ||nt s.charCodeAt(length - 3) !== 111 /* 'o' */ ||nt s.charCodeAt(length - 4) !== 116 /* 't' */ ||nt s.charCodeAt(length - 5) !== 111 /* 'o' */ ||nt s.charCodeAt(length - 6) !== 114 /* 'r' */ ||nt s.charCodeAt(length - 7) !== 112 /* 'p' */ ||nt s.charCodeAt(length - 8) !== 95 /* '_' */ ||nt s.charCodeAt(length - 9) !== 95 /* '_' */) {nt return false;nt }ntnt for (var i = length - 10; i >= 0; i–) {nt if (s.charCodeAt(i) !== 36 /* '$' */) {nt return false;nt }nt }ntnt return true;nt}ntnt/**nt * Comparator between two mappings where the original positions are compared.nt *nt * Optionally pass in `true` as `onlyCompareGenerated` to consider twont * mappings with the same original source/line/column, but different generatednt * line and column the same. Useful when searching for a mapping with ant * stubbed out mapping.nt */ntfunction compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {nt var cmp = strcmp(mappingA.source, mappingB.source);nt if (cmp !== 0) {nt return cmp;nt }ntnt cmp = mappingA.originalLine - mappingB.originalLine;nt if (cmp !== 0) {nt return cmp;nt }ntnt cmp = mappingA.originalColumn - mappingB.originalColumn;nt if (cmp !== 0 || onlyCompareOriginal) {nt return cmp;nt }ntnt cmp = mappingA.generatedColumn - mappingB.generatedColumn;nt if (cmp !== 0) {nt return cmp;nt }ntnt cmp = mappingA.generatedLine - mappingB.generatedLine;nt if (cmp !== 0) {nt return cmp;nt }ntnt return strcmp(mappingA.name, mappingB.name);nt}ntexports.compareByOriginalPositions = compareByOriginalPositions;ntnt/**nt * Comparator between two mappings with deflated source and name indices wherent * the generated positions are compared.nt *nt * Optionally pass in `true` as `onlyCompareGenerated` to consider twont * mappings with the same generated line and column, but differentnt * source/name/original line and column the same. Useful when searching for ant * mapping with a stubbed out mapping.nt */ntfunction compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {nt var cmp = mappingA.generatedLine - mappingB.generatedLine;nt if (cmp !== 0) {nt return cmp;nt }ntnt cmp = mappingA.generatedColumn - mappingB.generatedColumn;nt if (cmp !== 0 || onlyCompareGenerated) {nt return cmp;nt }ntnt cmp = strcmp(mappingA.source, mappingB.source);nt if (cmp !== 0) {nt return cmp;nt }ntnt cmp = mappingA.originalLine - mappingB.originalLine;nt if (cmp !== 0) {nt return cmp;nt }ntnt cmp = mappingA.originalColumn - mappingB.originalColumn;nt if (cmp !== 0) {nt return cmp;nt }ntnt return strcmp(mappingA.name, mappingB.name);nt}ntexports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;ntntfunction strcmp(aStr1, aStr2) {nt if (aStr1 === aStr2) {nt return 0;nt }ntnt if (aStr1 === null) {nt return 1; // aStr2 !== nullnt }ntnt if (aStr2 === null) {nt return -1; // aStr1 !== nullnt }ntnt if (aStr1 > aStr2) {nt return 1;nt }ntnt return -1;nt}ntnt/**nt * Comparator between two mappings with inflated source and name strings wherent * the generated positions are compared.nt */ntfunction compareByGeneratedPositionsInflated(mappingA, mappingB) {nt var cmp = mappingA.generatedLine - mappingB.generatedLine;nt if (cmp !== 0) {nt return cmp;nt }ntnt cmp = mappingA.generatedColumn - mappingB.generatedColumn;nt if (cmp !== 0) {nt return cmp;nt }ntnt cmp = strcmp(mappingA.source, mappingB.source);nt if (cmp !== 0) {nt return cmp;nt }ntnt cmp = mappingA.originalLine - mappingB.originalLine;nt if (cmp !== 0) {nt return cmp;nt }ntnt cmp = mappingA.originalColumn - mappingB.originalColumn;nt if (cmp !== 0) {nt return cmp;nt }ntnt return strcmp(mappingA.name, mappingB.name);nt}ntexports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;ntnt/**nt * Strip any JSON XSSI avoidance prefix from the string (as documentednt * in the source maps specification), and then parse the string asnt * JSON.nt */ntfunction parseSourceMapInput(str) {nt return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, ''));nt}ntexports.parseSourceMapInput = parseSourceMapInput;ntnt/**nt * Compute the URL of a source given the the source root, the source'snt * URL, and the source map's URL.nt */ntfunction computeSourceURL(sourceRoot, sourceURL, sourceMapURL) {nt sourceURL = sourceURL || '';ntnt if (sourceRoot) {nt // This follows what Chrome does.nt if (sourceRoot[sourceRoot.length - 1] !== '/' && sourceURL !== '/') {nt sourceRoot += '/';nt }nt // The spec says:nt // Line 4: An optional source root, useful for relocating sourcent // files on a server or removing repeated values in thent // “sources” entry. This value is prepended to the individualnt // entries in the “source” field.nt sourceURL = sourceRoot + sourceURL;nt }ntnt // Historically, SourceMapConsumer did not take the sourceMapURL asnt // a parameter. This mode is still somewhat supported, which is whynt // this code block is conditional. However, it's preferable to passnt // the source map URL to SourceMapConsumer, so that this functionnt // can implement the source URL resolution algorithm as outlined innt // the spec. This block is basically the equivalent of:nt // new URL(sourceURL, sourceMapURL).toString()nt // … except it avoids using URL, which wasn't available in thent // older releases of node still supported by this library.nt //nt // The spec says:nt // If the sources are not absolute URLs after prepending of thent // “sourceRoot”, the sources are resolved relative to thent // SourceMap (like resolving script src in a html document).nt if (sourceMapURL) {nt var parsed = urlParse(sourceMapURL);nt if (!parsed) {nt throw new Error("sourceMapURL could not be parsed");nt }nt if (parsed.path) {nt // Strip the last path component, but keep the "/".nt var index = parsed.path.lastIndexOf('/');nt if (index >= 0) {nt parsed.path = parsed.path.substring(0, index + 1);nt }nt }nt sourceURL = join(urlGenerate(parsed), sourceURL);nt }ntnt return normalize(sourceURL);nt}ntexports.computeSourceURL = computeSourceURL;nnn/***/ }),n/* 5 */n/***/ (function(module, exports, webpack_require) {nnt/* -*- Mode: js; js-indent-level: 2; -*- */nt/*nt * Copyright 2011 Mozilla Foundation and contributorsnt * Licensed under the New BSD license. See LICENSE or:nt * opensource.org/licenses/BSD-3-Clausent */ntntvar util = webpack_require(4);ntvar has = Object.prototype.hasOwnProperty;ntvar hasNativeMap = typeof Map !== "undefined";ntnt/**nt * A data structure which is a combination of an array and a set. Adding a newnt * member is O(1), testing for membership is O(1), and finding the index of annt * element is O(1). Removing elements from the set is not supported. Onlynt * strings are supported for membership.nt */ntfunction ArraySet() {nt this._array = [];nt this._set = hasNativeMap ? new Map() : Object.create(null);nt}ntnt/**nt * Static method for creating ArraySet instances from an existing array.nt */ntArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {nt var set = new ArraySet();nt for (var i = 0, len = aArray.length; i < len; i++) {nt set.add(aArray, aAllowDuplicates);nt }nt return set;nt};ntnt/**nt * Return how many unique items are in this ArraySet. If duplicates have beennt * added, than those do not count towards the size.nt *nt * @returns Numbernt */ntArraySet.prototype.size = function ArraySet_size() {nt return hasNativeMap ? this._set.size : Object.getOwnPropertyNames(this._set).length;nt};ntnt/**nt * Add the given string to this set.nt *nt * @param String aStrnt */ntArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {nt var sStr = hasNativeMap ? aStr : util.toSetString(aStr);nt var isDuplicate = hasNativeMap ? this.has(aStr) : has.call(this._set, sStr);nt var idx = this._array.length;nt if (!isDuplicate || aAllowDuplicates) {nt this._array.push(aStr);nt }nt if (!isDuplicate) {nt if (hasNativeMap) {nt this._set.set(aStr, idx);nt } else {nt this._set = idx;nt }nt }nt};ntnt/**nt * Is the given string a member of this set?nt *nt * @param String aStrnt */ntArraySet.prototype.has = function ArraySet_has(aStr) {nt if (hasNativeMap) {nt return this._set.has(aStr);nt } else {nt var sStr = util.toSetString(aStr);nt return has.call(this._set, sStr);nt }nt};ntnt/**nt * What is the index of the given string in the array?nt *nt * @param String aStrnt */ntArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {nt if (hasNativeMap) {nt var idx = this._set.get(aStr);nt if (idx >= 0) {nt return idx;nt }nt } else {nt var sStr = util.toSetString(aStr);nt if (has.call(this._set, sStr)) {nt return this._set;nt }nt }ntnt throw new Error('"' + aStr + '" is not in the set.');nt};ntnt/**nt * What is the element at the given index?nt *nt * @param Number aIdxnt */ntArraySet.prototype.at = function ArraySet_at(aIdx) {nt if (aIdx >= 0 && aIdx < this._array.length) {nt return this._array;nt }nt throw new Error('No element indexed by ' + aIdx);nt};ntnt/**nt * Returns the array representation of this set (which has the proper indicesnt * indicated by indexOf). Note that this is a copy of the internal array usednt * for storing the members so that no one can mess with internal state.nt */ntArraySet.prototype.toArray = function ArraySet_toArray() {nt return this._array.slice();nt};ntntexports.ArraySet = ArraySet;nnn/***/ }),n/* 6 */n/***/ (function(module, exports, webpack_require) {nnt/* -*- Mode: js; js-indent-level: 2; -*- */nt/*nt * Copyright 2014 Mozilla Foundation and contributorsnt * Licensed under the New BSD license. See LICENSE or:nt * opensource.org/licenses/BSD-3-Clausent */ntntvar util = webpack_require(4);ntnt/**nt * Determine whether mappingB is after mappingA with respect to generatednt * position.nt */ntfunction generatedPositionAfter(mappingA, mappingB) {nt // Optimized for most common casent var lineA = mappingA.generatedLine;nt var lineB = mappingB.generatedLine;nt var columnA = mappingA.generatedColumn;nt var columnB = mappingB.generatedColumn;nt return lineB > lineA || lineB == lineA && columnB >= columnA ||nt util.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0;nt}ntnt/**nt * A data structure to provide a sorted view of accumulated mappings in ant * performance conscious manner. It trades a neglibable overhead in generalnt * case for a large speedup in case of mappings being added in order.nt */ntfunction MappingList() {nt this._array = [];nt this._sorted = true;nt // Serves as infimumnt this._last = {generatedLine: -1, generatedColumn: 0};nt}ntnt/**nt * Iterate through internal items. This method takes the same arguments thatnt * `Array.prototype.forEach` takes.nt *nt * NOTE: The order of the mappings is NOT guaranteed.nt */ntMappingList.prototype.unsortedForEach =nt function MappingList_forEach(aCallback, aThisArg) {nt this._array.forEach(aCallback, aThisArg);nt };ntnt/**nt * Add the given source mapping.nt *nt * @param Object aMappingnt */ntMappingList.prototype.add = function MappingList_add(aMapping) {nt if (generatedPositionAfter(this._last, aMapping)) {nt this._last = aMapping;nt this._array.push(aMapping);nt } else {nt this._sorted = false;nt this._array.push(aMapping);nt }nt};ntnt/**nt * Returns the flat, sorted array of mappings. The mappings are sorted bynt * generated position.nt *nt * WARNING: This method returns internal data without copying, fornt * performance. The return value must NOT be mutated, and should be treated asnt * an immutable borrow. If you want to take ownership, you must make your ownnt * copy.nt */ntMappingList.prototype.toArray = function MappingList_toArray() {nt if (!this._sorted) {nt this._array.sort(util.compareByGeneratedPositionsInflated);nt this._sorted = true;nt }nt return this._array;nt};ntntexports.MappingList = MappingList;nnn/***/ }),n/* 7 */n/***/ (function(module, exports, webpack_require) {nnt/* -*- Mode: js; js-indent-level: 2; -*- */nt/*nt * Copyright 2011 Mozilla Foundation and contributorsnt * Licensed under the New BSD license. See LICENSE or:nt * opensource.org/licenses/BSD-3-Clausent */ntntvar util = webpack_require(4);ntvar binarySearch = webpack_require(8);ntvar ArraySet = webpack_require(5).ArraySet;ntvar base64VLQ = webpack_require(2);ntvar quickSort = webpack_require(9).quickSort;ntntfunction SourceMapConsumer(aSourceMap, aSourceMapURL) {nt var sourceMap = aSourceMap;nt if (typeof aSourceMap === 'string') {nt sourceMap = util.parseSourceMapInput(aSourceMap);nt }ntnt return sourceMap.sections != nullnt ? new IndexedSourceMapConsumer(sourceMap, aSourceMapURL)nt : new BasicSourceMapConsumer(sourceMap, aSourceMapURL);nt}ntntSourceMapConsumer.fromSourceMap = function(aSourceMap, aSourceMapURL) {nt return BasicSourceMapConsumer.fromSourceMap(aSourceMap, aSourceMapURL);nt}ntnt/**nt * The version of the source mapping spec that we are consuming.nt */ntSourceMapConsumer.prototype._version = 3;ntnt// `__generatedMappings` and `__originalMappings` are arrays that hold thent// parsed mapping coordinates from the source map's "mappings" attribute. Theynt// are lazily instantiated, accessed via the `_generatedMappings` andnt// `_originalMappings` getters respectively, and we only parse the mappingsnt// and create these arrays once queried for a source location. We jump throughnt// these hoops because there can be many thousands of mappings, and parsingnt// them is expensive, so we only want to do it if we must.nt//nt// Each object in the arrays is of the form:nt//nt// {nt// generatedLine: The line number in the generated code,nt// generatedColumn: The column number in the generated code,nt// source: The path to the original source file that generated thisnt// chunk of code,nt// originalLine: The line number in the original source thatnt// corresponds to this chunk of generated code,nt// originalColumn: The column number in the original source thatnt// corresponds to this chunk of generated code,nt// name: The name of the original symbol which generated this chunk ofnt// code.nt// }nt//nt// All properties except for `generatedLine` and `generatedColumn` can bent// `null`.nt//nt// `_generatedMappings` is ordered by the generated positions.nt//nt// `_originalMappings` is ordered by the original positions.ntntSourceMapConsumer.prototype.__generatedMappings = null;ntObject.defineProperty(SourceMapConsumer.prototype, '_generatedMappings', {nt configurable: true,nt enumerable: true,nt get: function () {nt if (!this.__generatedMappings) {nt this._parseMappings(this._mappings, this.sourceRoot);nt }ntnt return this.__generatedMappings;nt }nt});ntntSourceMapConsumer.prototype.__originalMappings = null;ntObject.defineProperty(SourceMapConsumer.prototype, '_originalMappings', {nt configurable: true,nt enumerable: true,nt get: function () {nt if (!this.__originalMappings) {nt this._parseMappings(this._mappings, this.sourceRoot);nt }ntnt return this.__originalMappings;nt }nt});ntntSourceMapConsumer.prototype._charIsMappingSeparator =nt function SourceMapConsumer_charIsMappingSeparator(aStr, index) {nt var c = aStr.charAt(index);nt return c === ";" || c === ",";nt };ntnt/**nt * Parse the mappings in a string in to a data structure which we can easilynt * query (the ordered arrays in the `this.__generatedMappings` andnt * `this.__originalMappings` properties).nt */ntSourceMapConsumer.prototype._parseMappings =nt function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {nt throw new Error("Subclasses must implement _parseMappings");nt };ntntSourceMapConsumer.GENERATED_ORDER = 1;ntSourceMapConsumer.ORIGINAL_ORDER = 2;ntntSourceMapConsumer.GREATEST_LOWER_BOUND = 1;ntSourceMapConsumer.LEAST_UPPER_BOUND = 2;ntnt/**nt * Iterate over each mapping between an original source/line/column and ant * generated line/column in this source map.nt *nt * @param Function aCallbacknt * The function that is called with each mapping.nt * @param Object aContextnt * Optional. If specified, this object will be the value of `this` everynt * time that `aCallback` is called.nt * @param aOrdernt * Either `SourceMapConsumer.GENERATED_ORDER` ornt * `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want tont * iterate over the mappings sorted by the generated file's line/columnnt * order or the original's source/line/column order, respectively. Defaults tont * `SourceMapConsumer.GENERATED_ORDER`.nt */ntSourceMapConsumer.prototype.eachMapping =nt function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {nt var context = aContext || null;nt var order = aOrder || SourceMapConsumer.GENERATED_ORDER;ntnt var mappings;nt switch (order) {nt case SourceMapConsumer.GENERATED_ORDER:nt mappings = this._generatedMappings;nt break;nt case SourceMapConsumer.ORIGINAL_ORDER:nt mappings = this._originalMappings;nt break;nt default:nt throw new Error("Unknown order of iteration.");nt }ntnt var sourceRoot = this.sourceRoot;nt mappings.map(function (mapping) {nt var source = mapping.source === null ? null : this._sources.at(mapping.source);nt source = util.computeSourceURL(sourceRoot, source, this._sourceMapURL);nt return {nt source: source,nt generatedLine: mapping.generatedLine,nt generatedColumn: mapping.generatedColumn,nt originalLine: mapping.originalLine,nt originalColumn: mapping.originalColumn,nt name: mapping.name === null ? null : this._names.at(mapping.name)nt };nt }, this).forEach(aCallback, context);nt };ntnt/**nt * Returns all generated line and column information for the original source,nt * line, and column provided. If no column is provided, returns all mappingsnt * corresponding to a either the line we are searching for or the nextnt * closest line that has any mappings. Otherwise, returns all mappingsnt * corresponding to the given line and either the column we are searching fornt * or the next closest column that has any offsets.nt *nt * The only argument is an object with the following properties:nt *nt * - source: The filename of the original source.nt * - line: The line number in the original source. The line number is 1-based.nt * - column: Optional. the column number in the original source.nt * The column number is 0-based.nt *nt * and an array of objects is returned, each with the following properties:nt *nt * - line: The line number in the generated source, or null. Thent * line number is 1-based.nt * - column: The column number in the generated source, or null.nt * The column number is 0-based.nt */ntSourceMapConsumer.prototype.allGeneratedPositionsFor =nt function SourceMapConsumer_allGeneratedPositionsFor(aArgs) {nt var line = util.getArg(aArgs, 'line');ntnt // When there is no exact match, BasicSourceMapConsumer.prototype._findMappingnt // returns the index of the closest mapping less than the needle. Bynt // setting needle.originalColumn to 0, we thus find the last mapping fornt // the given line, provided such a mapping exists.nt var needle = {nt source: util.getArg(aArgs, 'source'),nt originalLine: line,nt originalColumn: util.getArg(aArgs, 'column', 0)nt };ntnt needle.source = this._findSourceIndex(needle.source);nt if (needle.source < 0) {nt return [];nt }ntnt var mappings = [];ntnt var index = this._findMapping(needle,nt this._originalMappings,nt "originalLine",nt "originalColumn",nt util.compareByOriginalPositions,nt binarySearch.LEAST_UPPER_BOUND);nt if (index >= 0) {nt var mapping = this._originalMappings;ntnt if (aArgs.column === undefined) {nt var originalLine = mapping.originalLine;ntnt // Iterate until either we run out of mappings, or we run intont // a mapping for a different line than the one we found. Sincent // mappings are sorted, this is guaranteed to find all mappings fornt // the line we found.nt while (mapping && mapping.originalLine === originalLine) {nt mappings.push({nt line: util.getArg(mapping, 'generatedLine', null),nt column: util.getArg(mapping, 'generatedColumn', null),nt lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)nt });ntnt mapping = this._originalMappings;nt }nt } else {nt var originalColumn = mapping.originalColumn;ntnt // Iterate until either we run out of mappings, or we run intont // a mapping for a different line than the one we were searching for.nt // Since mappings are sorted, this is guaranteed to find all mappings fornt // the line we are searching for.nt while (mapping &&nt mapping.originalLine === line &&nt mapping.originalColumn == originalColumn) {nt mappings.push({nt line: util.getArg(mapping, 'generatedLine', null),nt column: util.getArg(mapping, 'generatedColumn', null),nt lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)nt });ntnt mapping = this._originalMappings;nt }nt }nt }ntnt return mappings;nt };ntntexports.SourceMapConsumer = SourceMapConsumer;ntnt/**nt * A BasicSourceMapConsumer instance represents a parsed source map which we cannt * query for information about the original file positions by giving it a filent * position in the generated source.nt *nt * The first parameter is the raw source map (either as a JSON string, ornt * already parsed to an object). According to the spec, source maps have thent * following attributes:nt *nt * - version: Which version of the source map spec this map is following.nt * - sources: An array of URLs to the original source files.nt * - names: An array of identifiers which can be referrenced by individual mappings.nt * - sourceRoot: Optional. The URL root from which all sources are relative.nt * - sourcesContent: Optional. An array of contents of the original source files.nt * - mappings: A string of base64 VLQs which contain the actual mappings.nt * - file: Optional. The generated file this source map is associated with.nt *nt * Here is an example source map, taken from the source map spec:nt *nt * {nt * version : 3,nt * file: "out.js",nt * sourceRoot : "",nt * sources: ["foo.js", "bar.js"],nt * names: ["src", "maps", "are", "fun"],nt * mappings: "AA,AB;;ABCDE;"nt * }nt *nt * The second parameter, if given, is a string whose value is the URLnt * at which the source map was found. This URL is used to compute thent * sources array.nt *nt * [0]: docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit?pli=1#nt */ntfunction BasicSourceMapConsumer(aSourceMap, aSourceMapURL) {nt var sourceMap = aSourceMap;nt if (typeof aSourceMap === 'string') {nt sourceMap = util.parseSourceMapInput(aSourceMap);nt }ntnt var version = util.getArg(sourceMap, 'version');nt var sources = util.getArg(sourceMap, 'sources');nt // Sass 3.3 leaves out the 'names' array, so we deviate from the spec (whichnt // requires the array) to play nice here.nt var names = util.getArg(sourceMap, 'names', []);nt var sourceRoot = util.getArg(sourceMap, 'sourceRoot', null);nt var sourcesContent = util.getArg(sourceMap, 'sourcesContent', null);nt var mappings = util.getArg(sourceMap, 'mappings');nt var file = util.getArg(sourceMap, 'file', null);ntnt // Once again, Sass deviates from the spec and supplies the version as ant // string rather than a number, so we use loose equality checking here.nt if (version != this._version) {nt throw new Error('Unsupported version: ' + version);nt }ntnt if (sourceRoot) {nt sourceRoot = util.normalize(sourceRoot);nt }ntnt sources = sourcesnt .map(String)nt // Some source maps produce relative source paths like "./foo.js" instead ofnt // "foo.js". Normalize these first so that future comparisons will succeed.nt // See bugzil.la/1090768.nt .map(util.normalize)nt // Always ensure that absolute sources are internally stored relative tont // the source root, if the source root is absolute. Not doing this wouldnt // be particularly problematic when the source root is a prefix of thent // source (valid, but why??). See github issue #199 and bugzil.la/1188982.nt .map(function (source) {nt return sourceRoot && util.isAbsolute(sourceRoot) && util.isAbsolute(source)nt ? util.relative(sourceRoot, source)nt : source;nt });ntnt // Pass `true` below to allow duplicate names and sources. While source mapsnt // are intended to be compressed and deduplicated, the TypeScript compilernt // sometimes generates source maps with duplicates in them. See Github issuent // #72 and bugzil.la/889492.nt this._names = ArraySet.fromArray(names.map(String), true);nt this._sources = ArraySet.fromArray(sources, true);ntnt this._absoluteSources = this._sources.toArray().map(function (s) {nt return util.computeSourceURL(sourceRoot, s, aSourceMapURL);nt });ntnt this.sourceRoot = sourceRoot;nt this.sourcesContent = sourcesContent;nt this._mappings = mappings;nt this._sourceMapURL = aSourceMapURL;nt this.file = file;nt}ntntBasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);ntBasicSourceMapConsumer.prototype.consumer = SourceMapConsumer;ntnt/**nt * Utility function to find the index of a source. Returns -1 if notnt * found.nt */ntBasicSourceMapConsumer.prototype._findSourceIndex = function(aSource) {nt var relativeSource = aSource;nt if (this.sourceRoot != null) {nt relativeSource = util.relative(this.sourceRoot, relativeSource);nt }ntnt if (this._sources.has(relativeSource)) {nt return this._sources.indexOf(relativeSource);nt }ntnt // Maybe aSource is an absolute URL as returned by |sources|. Innt // this case we can't simply undo the transform.nt var i;nt for (i = 0; i < this._absoluteSources.length; ++i) {nt if (this._absoluteSources == aSource) {nt return i;nt }nt }ntnt return -1;nt};ntnt/**nt * Create a BasicSourceMapConsumer from a SourceMapGenerator.nt *nt * @param SourceMapGenerator aSourceMapnt * The source map that will be consumed.nt * @param String aSourceMapURLnt * The URL at which the source map can be found (optional)nt * @returns BasicSourceMapConsumernt */ntBasicSourceMapConsumer.fromSourceMap =nt function SourceMapConsumer_fromSourceMap(aSourceMap, aSourceMapURL) {nt var smc = Object.create(BasicSourceMapConsumer.prototype);ntnt var names = smc._names = ArraySet.fromArray(aSourceMap._names.toArray(), true);nt var sources = smc._sources = ArraySet.fromArray(aSourceMap._sources.toArray(), true);nt smc.sourceRoot = aSourceMap._sourceRoot;nt smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(),nt smc.sourceRoot);nt smc.file = aSourceMap._file;nt smc._sourceMapURL = aSourceMapURL;nt smc._absoluteSources = smc._sources.toArray().map(function (s) {nt return util.computeSourceURL(smc.sourceRoot, s, aSourceMapURL);nt });ntnt // Because we are modifying the entries (by converting string sources andnt // names to indices into the sources and names ArraySets), we have to makent // a copy of the entry or else bad things happen. Shared mutable statent // strikes again! See github issue #191.ntnt var generatedMappings = aSourceMap._mappings.toArray().slice();nt var destGeneratedMappings = smc.__generatedMappings = [];nt var destOriginalMappings = smc.__originalMappings = [];ntnt for (var i = 0, length = generatedMappings.length; i < length; i++) {nt var srcMapping = generatedMappings;nt var destMapping = new Mapping;nt destMapping.generatedLine = srcMapping.generatedLine;nt destMapping.generatedColumn = srcMapping.generatedColumn;ntnt if (srcMapping.source) {nt destMapping.source = sources.indexOf(srcMapping.source);nt destMapping.originalLine = srcMapping.originalLine;nt destMapping.originalColumn = srcMapping.originalColumn;ntnt if (srcMapping.name) {nt destMapping.name = names.indexOf(srcMapping.name);nt }ntnt destOriginalMappings.push(destMapping);nt }ntnt destGeneratedMappings.push(destMapping);nt }ntnt quickSort(smc.__originalMappings, util.compareByOriginalPositions);ntnt return smc;nt };ntnt/**nt * The version of the source mapping spec that we are consuming.nt */ntBasicSourceMapConsumer.prototype._version = 3;ntnt/**nt * The list of original sources.nt */ntObject.defineProperty(BasicSourceMapConsumer.prototype, 'sources', {nt get: function () {nt return this._absoluteSources.slice();nt }nt});ntnt/**nt * Provide the JIT with a nice shape / hidden class.nt */ntfunction Mapping() {nt this.generatedLine = 0;nt this.generatedColumn = 0;nt this.source = null;nt this.originalLine = null;nt this.originalColumn = null;nt this.name = null;nt}ntnt/**nt * Parse the mappings in a string in to a data structure which we can easilynt * query (the ordered arrays in the `this.__generatedMappings` andnt * `this.__originalMappings` properties).nt */ntBasicSourceMapConsumer.prototype._parseMappings =nt function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {nt var generatedLine = 1;nt var previousGeneratedColumn = 0;nt var previousOriginalLine = 0;nt var previousOriginalColumn = 0;nt var previousSource = 0;nt var previousName = 0;nt var length = aStr.length;nt var index = 0;nt var cachedSegments = {};nt var temp = {};nt var originalMappings = [];nt var generatedMappings = [];nt var mapping, str, segment, end, value;ntnt while (index < length) {nt if (aStr.charAt(index) === ';') {nt generatedLine++;nt index++;nt previousGeneratedColumn = 0;nt }nt else if (aStr.charAt(index) === ',') {nt index++;nt }nt else {nt mapping = new Mapping();nt mapping.generatedLine = generatedLine;ntnt // Because each offset is encoded relative to the previous one,nt // many segments often have the same encoding. We can exploit thisnt // fact by caching the parsed variable length fields of each segment,nt // allowing us to avoid a second parse if we encounter the sament // segment again.nt for (end = index; end < length; end++) {nt if (this._charIsMappingSeparator(aStr, end)) {nt break;nt }nt }nt str = aStr.slice(index, end);ntnt segment = cachedSegments;nt if (segment) {nt index += str.length;nt } else {nt segment = [];nt while (index < end) {nt base64VLQ.decode(aStr, index, temp);nt value = temp.value;nt index = temp.rest;nt segment.push(value);nt }ntnt if (segment.length === 2) {nt throw new Error('Found a source, but no line and column');nt }ntnt if (segment.length === 3) {nt throw new Error('Found a source and line, but no column');nt }ntnt cachedSegments = segment;nt }ntnt // Generated column.nt mapping.generatedColumn = previousGeneratedColumn + segment;nt previousGeneratedColumn = mapping.generatedColumn;ntnt if (segment.length > 1) {nt // Original source.nt mapping.source = previousSource + segment;nt previousSource += segment;ntnt // Original line.nt mapping.originalLine = previousOriginalLine + segment;nt previousOriginalLine = mapping.originalLine;nt // Lines are stored 0-basednt mapping.originalLine += 1;ntnt // Original column.nt mapping.originalColumn = previousOriginalColumn + segment;nt previousOriginalColumn = mapping.originalColumn;ntnt if (segment.length > 4) {nt // Original name.nt mapping.name = previousName + segment;nt previousName += segment;nt }nt }ntnt generatedMappings.push(mapping);nt if (typeof mapping.originalLine === 'number') {nt originalMappings.push(mapping);nt }nt }nt }ntnt quickSort(generatedMappings, util.compareByGeneratedPositionsDeflated);nt this.__generatedMappings = generatedMappings;ntnt quickSort(originalMappings, util.compareByOriginalPositions);nt this.__originalMappings = originalMappings;nt };ntnt/**nt * Find the mapping that best matches the hypothetical "needle" mapping thatnt * we are searching for in the given "haystack" of mappings.nt */ntBasicSourceMapConsumer.prototype._findMapping =nt function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName,nt aColumnName, aComparator, aBias) {nt // To return the position we are searching for, we must first find thent // mapping for the given position and then return the opposite position itnt // points to. Because the mappings are sorted, we can use binary search tont // find the best mapping.ntnt if (aNeedle <= 0) {nt throw new TypeError('Line must be greater than or equal to 1, got 'nt + aNeedle);nt }nt if (aNeedle < 0) {nt throw new TypeError('Column must be greater than or equal to 0, got 'nt + aNeedle);nt }ntnt return binarySearch.search(aNeedle, aMappings, aComparator, aBias);nt };ntnt/**nt * Compute the last column for each generated mapping. The last column isnt * inclusive.nt */ntBasicSourceMapConsumer.prototype.computeColumnSpans =nt function SourceMapConsumer_computeColumnSpans() {nt for (var index = 0; index < this._generatedMappings.length; ++index) {nt var mapping = this._generatedMappings;ntnt // Mappings do not contain a field for the last generated columnt. Went // can come up with an optimistic estimate, however, by assuming thatnt // mappings are contiguous (i.e. given two consecutive mappings, thent // first mapping ends where the second one starts).nt if (index + 1 < this._generatedMappings.length) {nt var nextMapping = this._generatedMappings[index + 1];ntnt if (mapping.generatedLine === nextMapping.generatedLine) {nt mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1;nt continue;nt }nt }ntnt // The last mapping for each line spans the entire line.nt mapping.lastGeneratedColumn = Infinity;nt }nt };ntnt/**nt * Returns the original source, line, and column information for the generatednt * source's line and column positions provided. The only argument is an objectnt * with the following properties:nt *nt * - line: The line number in the generated source. The line numbernt * is 1-based.nt * - column: The column number in the generated source. The columnnt * number is 0-based.nt * - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' ornt * 'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return thent * closest element that is smaller than or greater than the one we arent * searching for, respectively, if the exact element cannot be found.nt * Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.nt *nt * and an object is returned with the following properties:nt *nt * - source: The original source file, or null.nt * - line: The line number in the original source, or null. Thent * line number is 1-based.nt * - column: The column number in the original source, or null. Thent * column number is 0-based.nt * - name: The original identifier, or null.nt */ntBasicSourceMapConsumer.prototype.originalPositionFor =nt function SourceMapConsumer_originalPositionFor(aArgs) {nt var needle = {nt generatedLine: util.getArg(aArgs, 'line'),nt generatedColumn: util.getArg(aArgs, 'column')nt };ntnt var index = this._findMapping(nt needle,nt this._generatedMappings,nt "generatedLine",nt "generatedColumn",nt util.compareByGeneratedPositionsDeflated,nt util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)nt );ntnt if (index >= 0) {nt var mapping = this._generatedMappings;ntnt if (mapping.generatedLine === needle.generatedLine) {nt var source = util.getArg(mapping, 'source', null);nt if (source !== null) {nt source = this._sources.at(source);nt source = util.computeSourceURL(this.sourceRoot, source, this._sourceMapURL);nt }nt var name = util.getArg(mapping, 'name', null);nt if (name !== null) {nt name = this._names.at(name);nt }nt return {nt source: source,nt line: util.getArg(mapping, 'originalLine', null),nt column: util.getArg(mapping, 'originalColumn', null),nt name: nament };nt }nt }ntnt return {nt source: null,nt line: null,nt column: null,nt name: nullnt };nt };ntnt/**nt * Return true if we have the source content for every source in the sourcent * map, false otherwise.nt */ntBasicSourceMapConsumer.prototype.hasContentsOfAllSources =nt function BasicSourceMapConsumer_hasContentsOfAllSources() {nt if (!this.sourcesContent) {nt return false;nt }nt return this.sourcesContent.length >= this._sources.size() &&nt !this.sourcesContent.some(function (sc) { return sc == null; });nt };ntnt/**nt * Returns the original source content. The only argument is the url of thent * original source file. Returns null if no original source content isnt * available.nt */ntBasicSourceMapConsumer.prototype.sourceContentFor =nt function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {nt if (!this.sourcesContent) {nt return null;nt }ntnt var index = this._findSourceIndex(aSource);nt if (index >= 0) {nt return this.sourcesContent;nt }ntnt var relativeSource = aSource;nt if (this.sourceRoot != null) {nt relativeSource = util.relative(this.sourceRoot, relativeSource);nt }ntnt var url;nt if (this.sourceRoot != nullnt && (url = util.urlParse(this.sourceRoot))) {nt // XXX: file:// URIs and absolute paths lead to unexpected behavior fornt // many users. We can help them out when they expect file:// URIs tont // behave like it would if they were running a local HTTP server. Seent // bugzilla.mozilla.org/show_bug.cgi?id=885597.nt var fileUriAbsPath = relativeSource.replace(/^file:\/\//, "");nt if (url.scheme == "file"nt && this._sources.has(fileUriAbsPath)) {nt return this.sourcesContentnt }ntnt if ((!url.path || url.path == "/")nt && this._sources.has("/" + relativeSource)) {nt return this.sourcesContent[this._sources.indexOf("/" + relativeSource)];nt }nt }ntnt // This function is used recursively fromnt // IndexedSourceMapConsumer.prototype.sourceContentFor. In that case, went // don't want to throw if we can't find the source - we just want tont // return null, so we provide a flag to exit gracefully.nt if (nullOnMissing) {nt return null;nt }nt else {nt throw new Error('"' + relativeSource + '" is not in the SourceMap.');nt }nt };ntnt/**nt * Returns the generated line and column information for the original source,nt * line, and column positions provided. The only argument is an object withnt * the following properties:nt *nt * - source: The filename of the original source.nt * - line: The line number in the original source. The line numbernt * is 1-based.nt * - column: The column number in the original source. The columnnt * number is 0-based.nt * - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' ornt * 'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return thent * closest element that is smaller than or greater than the one we arent * searching for, respectively, if the exact element cannot be found.nt * Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.nt *nt * and an object is returned with the following properties:nt *nt * - line: The line number in the generated source, or null. Thent * line number is 1-based.nt * - column: The column number in the generated source, or null.nt * The column number is 0-based.nt */ntBasicSourceMapConsumer.prototype.generatedPositionFor =nt function SourceMapConsumer_generatedPositionFor(aArgs) {nt var source = util.getArg(aArgs, 'source');nt source = this._findSourceIndex(source);nt if (source < 0) {nt return {nt line: null,nt column: null,nt lastColumn: nullnt };nt }ntnt var needle = {nt source: source,nt originalLine: util.getArg(aArgs, 'line'),nt originalColumn: util.getArg(aArgs, 'column')nt };ntnt var index = this._findMapping(nt needle,nt this._originalMappings,nt "originalLine",nt "originalColumn",nt util.compareByOriginalPositions,nt util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)nt );ntnt if (index >= 0) {nt var mapping = this._originalMappings;ntnt if (mapping.source === needle.source) {nt return {nt line: util.getArg(mapping, 'generatedLine', null),nt column: util.getArg(mapping, 'generatedColumn', null),nt lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)nt };nt }nt }ntnt return {nt line: null,nt column: null,nt lastColumn: nullnt };nt };ntntexports.BasicSourceMapConsumer = BasicSourceMapConsumer;ntnt/**nt * An IndexedSourceMapConsumer instance represents a parsed source map whichnt * we can query for information. It differs from BasicSourceMapConsumer innt * that it takes "indexed" source maps (i.e. ones with a "sections" field) asnt * input.nt *nt * The first parameter is a raw source map (either as a JSON string, or alreadynt * parsed to an object). According to the spec for indexed source maps, theynt * have the following attributes:nt *nt * - version: Which version of the source map spec this map is following.nt * - file: Optional. The generated file this source map is associated with.nt * - sections: A list of section definitions.nt *nt * Each value under the "sections" field has two fields:nt * - offset: The offset into the original specified at which this sectionnt * begins to apply, defined as an object with a "line" and "column"nt * field.nt * - map: A source map definition. This source map could also be indexed,nt * but doesn't have to be.nt *nt * Instead of the "map" field, it's also possible to have a "url" fieldnt * specifying a URL to retrieve a source map from, but that's currentlynt * unsupported.nt *nt * Here's an example source map, taken from the source map spec, butnt * modified to omit a section which uses the "url" field.nt *nt * {nt * version : 3,nt * file: "app.js",nt * sections: [{nt * offset: {line:100, column:10},nt * map: {nt * version : 3,nt * file: "section.js",nt * sources: ["foo.js", "bar.js"],nt * names: ["src", "maps", "are", "fun"],nt * mappings: "AAAA,E;;ABCDE;"nt * }nt * }],nt * }nt *nt * The second parameter, if given, is a string whose value is the URLnt * at which the source map was found. This URL is used to compute thent * sources array.nt *nt * [0]: docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit#heading=h.535es3xeprgtnt */ntfunction IndexedSourceMapConsumer(aSourceMap, aSourceMapURL) {nt var sourceMap = aSourceMap;nt if (typeof aSourceMap === 'string') {nt sourceMap = util.parseSourceMapInput(aSourceMap);nt }ntnt var version = util.getArg(sourceMap, 'version');nt var sections = util.getArg(sourceMap, 'sections');ntnt if (version != this._version) {nt throw new Error('Unsupported version: ' + version);nt }ntnt this._sources = new ArraySet();nt this._names = new ArraySet();ntnt var lastOffset = {nt line: -1,nt column: 0nt };nt this._sections = sections.map(function (s) {nt if (s.url) {nt // The url field will require support for asynchronicity.nt // See github.com/mozilla/source-map/issues/16nt throw new Error('Support for url field in sections not implemented.');nt }nt var offset = util.getArg(s, 'offset');nt var offsetLine = util.getArg(offset, 'line');nt var offsetColumn = util.getArg(offset, 'column');ntnt if (offsetLine < lastOffset.line ||nt (offsetLine === lastOffset.line && offsetColumn < lastOffset.column)) {nt throw new Error('Section offsets must be ordered and non-overlapping.');nt }nt lastOffset = offset;ntnt return {nt generatedOffset: {nt // The offset fields are 0-based, but we use 1-based indices whennt // encoding/decoding from VLQ.nt generatedLine: offsetLine + 1,nt generatedColumn: offsetColumn + 1nt },nt consumer: new SourceMapConsumer(util.getArg(s, 'map'), aSourceMapURL)nt }nt });nt}ntntIndexedSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);ntIndexedSourceMapConsumer.prototype.constructor = SourceMapConsumer;ntnt/**nt * The version of the source mapping spec that we are consuming.nt */ntIndexedSourceMapConsumer.prototype._version = 3;ntnt/**nt * The list of original sources.nt */ntObject.defineProperty(IndexedSourceMapConsumer.prototype, 'sources', {nt get: function () {nt var sources = [];nt for (var i = 0; i < this._sections.length; i++) {nt for (var j = 0; j < this._sections.consumer.sources.length; j++) {nt sources.push(this._sections.consumer.sources);nt }nt }nt return sources;nt }nt});ntnt/**nt * Returns the original source, line, and column information for the generatednt * source's line and column positions provided. The only argument is an objectnt * with the following properties:nt *nt * - line: The line number in the generated source. The line numbernt * is 1-based.nt * - column: The column number in the generated source. The columnnt * number is 0-based.nt *nt * and an object is returned with the following properties:nt *nt * - source: The original source file, or null.nt * - line: The line number in the original source, or null. Thent * line number is 1-based.nt * - column: The column number in the original source, or null. Thent * column number is 0-based.nt * - name: The original identifier, or null.nt */ntIndexedSourceMapConsumer.prototype.originalPositionFor =nt function IndexedSourceMapConsumer_originalPositionFor(aArgs) {nt var needle = {nt generatedLine: util.getArg(aArgs, 'line'),nt generatedColumn: util.getArg(aArgs, 'column')nt };ntnt // Find the section containing the generated position we're trying to mapnt // to an original position.nt var sectionIndex = binarySearch.search(needle, this._sections,nt function(needle, section) {nt var cmp = needle.generatedLine - section.generatedOffset.generatedLine;nt if (cmp) {nt return cmp;nt }ntnt return (needle.generatedColumn -nt section.generatedOffset.generatedColumn);nt });nt var section = this._sections;ntnt if (!section) {nt return {nt source: null,nt line: null,nt column: null,nt name: nullnt };nt }ntnt return section.consumer.originalPositionFor({nt line: needle.generatedLine -nt (section.generatedOffset.generatedLine - 1),nt column: needle.generatedColumn -nt (section.generatedOffset.generatedLine === needle.generatedLinent ? section.generatedOffset.generatedColumn - 1nt : 0),nt bias: aArgs.biasnt });nt };ntnt/**nt * Return true if we have the source content for every source in the sourcent * map, false otherwise.nt */ntIndexedSourceMapConsumer.prototype.hasContentsOfAllSources =nt function IndexedSourceMapConsumer_hasContentsOfAllSources() {nt return this._sections.every(function (s) {nt return s.consumer.hasContentsOfAllSources();nt });nt };ntnt/**nt * Returns the original source content. The only argument is the url of thent * original source file. Returns null if no original source content isnt * available.nt */ntIndexedSourceMapConsumer.prototype.sourceContentFor =nt function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {nt for (var i = 0; i < this._sections.length; i++) {nt var section = this._sections;ntnt var content = section.consumer.sourceContentFor(aSource, true);nt if (content) {nt return content;nt }nt }nt if (nullOnMissing) {nt return null;nt }nt else {nt throw new Error('"' + aSource + '" is not in the SourceMap.');nt }nt };ntnt/**nt * Returns the generated line and column information for the original source,nt * line, and column positions provided. The only argument is an object withnt * the following properties:nt *nt * - source: The filename of the original source.nt * - line: The line number in the original source. The line numbernt * is 1-based.nt * - column: The column number in the original source. The columnnt * number is 0-based.nt *nt * and an object is returned with the following properties:nt *nt * - line: The line number in the generated source, or null. Thent * line number is 1-based. nt * - column: The column number in the generated source, or null.nt * The column number is 0-based.nt */ntIndexedSourceMapConsumer.prototype.generatedPositionFor =nt function IndexedSourceMapConsumer_generatedPositionFor(aArgs) {nt for (var i = 0; i < this._sections.length; i++) {nt var section = this._sections;ntnt // Only consider this section if the requested source is in the list ofnt // sources of the consumer.nt if (section.consumer._findSourceIndex(util.getArg(aArgs, 'source')) === -1) {nt continue;nt }nt var generatedPosition = section.consumer.generatedPositionFor(aArgs);nt if (generatedPosition) {nt var ret = {nt line: generatedPosition.line +nt (section.generatedOffset.generatedLine - 1),nt column: generatedPosition.column +nt (section.generatedOffset.generatedLine === generatedPosition.linent ? section.generatedOffset.generatedColumn - 1nt : 0)nt };nt return ret;nt }nt }ntnt return {nt line: null,nt column: nullnt };nt };ntnt/**nt * Parse the mappings in a string in to a data structure which we can easilynt * query (the ordered arrays in the `this.__generatedMappings` andnt * `this.__originalMappings` properties).nt */ntIndexedSourceMapConsumer.prototype._parseMappings =nt function IndexedSourceMapConsumer_parseMappings(aStr, aSourceRoot) {nt this.__generatedMappings = [];nt this.__originalMappings = [];nt for (var i = 0; i < this._sections.length; i++) {nt var section = this._sections;nt var sectionMappings = section.consumer._generatedMappings;nt for (var j = 0; j < sectionMappings.length; j++) {nt var mapping = sectionMappings;ntnt var source = section.consumer._sources.at(mapping.source);nt source = util.computeSourceURL(section.consumer.sourceRoot, source, this._sourceMapURL);nt this._sources.add(source);nt source = this._sources.indexOf(source);ntnt var name = null;nt if (mapping.name) {nt name = section.consumer._names.at(mapping.name);nt this._names.add(name);nt name = this._names.indexOf(name);nt }ntnt // The mappings coming from the consumer for the section havent // generated positions relative to the start of the section, so went // need to offset them to be relative to the start of the concatenatednt // generated file.nt var adjustedMapping = {nt source: source,nt generatedLine: mapping.generatedLine +nt (section.generatedOffset.generatedLine - 1),nt generatedColumn: mapping.generatedColumn +nt (section.generatedOffset.generatedLine === mapping.generatedLinent ? section.generatedOffset.generatedColumn - 1nt : 0),nt originalLine: mapping.originalLine,nt originalColumn: mapping.originalColumn,nt name: nament };ntnt this.__generatedMappings.push(adjustedMapping);nt if (typeof adjustedMapping.originalLine === 'number') {nt this.__originalMappings.push(adjustedMapping);nt }nt }nt }ntnt quickSort(this.__generatedMappings, util.compareByGeneratedPositionsDeflated);nt quickSort(this.__originalMappings, util.compareByOriginalPositions);nt };ntntexports.IndexedSourceMapConsumer = IndexedSourceMapConsumer;nnn/***/ }),n/* 8 */n/***/ (function(module, exports) {nnt/* -*- Mode: js; js-indent-level: 2; -*- */nt/*nt * Copyright 2011 Mozilla Foundation and contributorsnt * Licensed under the New BSD license. See LICENSE or:nt * opensource.org/licenses/BSD-3-Clausent */ntntexports.GREATEST_LOWER_BOUND = 1;ntexports.LEAST_UPPER_BOUND = 2;ntnt/**nt * Recursive implementation of binary search.nt *nt * @param aLow Indices here and lower do not contain the needle.nt * @param aHigh Indices here and higher do not contain the needle.nt * @param aNeedle The element being searched for.nt * @param aHaystack The non-empty array being searched.nt * @param aCompare Function which takes two elements and returns -1, 0, or 1.nt * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' ornt * 'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return thent * closest element that is smaller than or greater than the one we arent * searching for, respectively, if the exact element cannot be found.nt */ntfunction recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare, aBias) {nt // This function terminates when one of the following is true:nt //nt // 1. We find the exact element we are looking for.nt //nt // 2. We did not find the exact element, but we can return the index ofnt // the next-closest element.nt //nt // 3. We did not find the exact element, and there is no next-closestnt // element than the one we are searching for, so we return -1.nt var mid = Math.floor((aHigh - aLow) / 2) + aLow;nt var cmp = aCompare(aNeedle, aHaystack, true);nt if (cmp === 0) {nt // Found the element we are looking for.nt return mid;nt }nt else if (cmp > 0) {nt // Our needle is greater than aHaystack.nt if (aHigh - mid > 1) {nt // The element is in the upper half.nt return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias);nt }ntnt // The exact needle element was not found in this haystack. Determine ifnt // we are in termination case (3) or (2) and return the appropriate thing.nt if (aBias == exports.LEAST_UPPER_BOUND) {nt return aHigh < aHaystack.length ? aHigh : -1;nt } else {nt return mid;nt }nt }nt else {nt // Our needle is less than aHaystack.nt if (mid - aLow > 1) {nt // The element is in the lower half.nt return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias);nt }ntnt // we are in termination case (3) or (2) and return the appropriate thing.nt if (aBias == exports.LEAST_UPPER_BOUND) {nt return mid;nt } else {nt return aLow < 0 ? -1 : aLow;nt }nt }nt}ntnt/**nt * This is an implementation of binary search which will always try and returnnt * the index of the closest element if there is no exact hit. This is becausent * mappings between original and generated line/col pairs are single points,nt * and there is an implicit region between each of them, so a miss just meansnt * that you aren't on the very start of a region.nt *nt * @param aNeedle The element you are looking for.nt * @param aHaystack The array that is being searched.nt * @param aCompare A function which takes the needle and an element in thent * array and returns -1, 0, or 1 depending on whether the needle is lessnt * than, equal to, or greater than the element, respectively.nt * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' ornt * 'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return thent * closest element that is smaller than or greater than the one we arent * searching for, respectively, if the exact element cannot be found.nt * Defaults to 'binarySearch.GREATEST_LOWER_BOUND'.nt */ntexports.search = function search(aNeedle, aHaystack, aCompare, aBias) {nt if (aHaystack.length === 0) {nt return -1;nt }ntnt var index = recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack,nt aCompare, aBias || exports.GREATEST_LOWER_BOUND);nt if (index < 0) {nt return -1;nt }ntnt // We have found either the exact element, or the next-closest element thannt // the one we are searching for. However, there may be more than one suchnt // element. Make sure we always return the smallest of these.nt while (index - 1 >= 0) {nt if (aCompare(aHaystack, aHaystack[index - 1], true) !== 0) {nt break;nt }nt –index;nt }ntnt return index;nt};nnn/***/ }),n/* 9 */n/***/ (function(module, exports) {nnt/* -*- Mode: js; js-indent-level: 2; -*- */nt/*nt * Copyright 2011 Mozilla Foundation and contributorsnt * Licensed under the New BSD license. See LICENSE or:nt * opensource.org/licenses/BSD-3-Clausent */ntnt// It turns out that some (most?) JavaScript engines don't self-hostnt// `Array.prototype.sort`. This makes sense because C++ will likely remainnt// faster than JS when doing raw CPU-intensive sorting. However, when using ant// custom comparator function, calling back and forth between the VM's C++ andnt// JIT'd JS is rather slow and loses JIT type information, resulting innt// worse generated code for the comparator function than would be optimal. Innt// fact, when sorting with a comparator, these costs outweigh the benefits ofnt// sorting in C++. By using our own JS-implemented Quick Sort (below), we getnt// a ~3500ms mean speed-up in `bench/bench.html`.ntnt/**nt * Swap the elements indexed by `x` and `y` in the array `ary`.nt *nt * @param {Array} arynt * The array.nt * @param {Number} xnt * The index of the first item.nt * @param {Number} ynt * The index of the second item.nt */ntfunction swap(ary, x, y) {nt var temp = ary;nt ary = ary;nt ary = temp;nt}ntnt/**nt * Returns a random integer within the range `low .. high` inclusive.nt *nt * @param {Number} lownt * The lower bound on the range.nt * @param {Number} highnt * The upper bound on the range.nt */ntfunction randomIntInRange(low, high) {nt return Math.round(low + (Math.random() * (high - low)));nt}ntnt/**nt * The Quick Sort algorithm.nt *nt * @param {Array} arynt * An array to sort.nt * @param {function} comparatornt * Function to use to compare two items.nt * @param {Number} pnt * Start index of the arraynt * @param {Number} rnt * End index of the arraynt */ntfunction doQuickSort(ary, comparator, p, r) {nt // If our lower bound is less than our upper bound, we (1) partition thent // array into two pieces and (2) recurse on each half. If it is not, this isnt // the empty array and our base case.ntnt if (p < r) {nt // (1) Partitioning.nt //nt // The partitioning chooses a pivot between `p` and `r` and moves allnt // elements that are less than or equal to the pivot to the before it, andnt // all the elements that are greater than it after it. The effect is thatnt // once partition is done, the pivot is in the exact place it will be whennt // the array is put in sorted order, and it will not need to be movednt // again. This runs in O(n) time.ntnt // Always choose a random pivot so that an input array which is reversent // sorted does not cause O(n^2) running time.nt var pivotIndex = randomIntInRange(p, r);nt var i = p - 1;ntnt swap(ary, pivotIndex, r);nt var pivot = ary;ntnt // Immediately after `j` is incremented in this loop, the following holdnt // true:nt //nt // * Every element in `ary[p .. i]` is less than or equal to the pivot.nt //nt // * Every element in `ary[i+1 .. j-1]` is greater than the pivot.nt for (var j = p; j < r; j++) {nt if (comparator(ary, pivot) <= 0) {nt i += 1;nt swap(ary, i, j);nt }nt }ntnt swap(ary, i + 1, j);nt var q = i + 1;ntnt // (2) Recurse on each half.ntnt doQuickSort(ary, comparator, p, q - 1);nt doQuickSort(ary, comparator, q + 1, r);nt }nt}ntnt/**nt * Sort the given array in-place with the given comparator function.nt *nt * @param {Array} arynt * An array to sort.nt * @param {function} comparatornt * Function to use to compare two items.nt */ntexports.quickSort = function (ary, comparator) {nt doQuickSort(ary, comparator, 0, ary.length - 1);nt};nnn/***/ }),n/* 10 */n/***/ (function(module, exports, webpack_require) {nnt/* -*- Mode: js; js-indent-level: 2; -*- */nt/*nt * Copyright 2011 Mozilla Foundation and contributorsnt * Licensed under the New BSD license. See LICENSE or:nt * opensource.org/licenses/BSD-3-Clausent */ntntvar SourceMapGenerator = webpack_require(1).SourceMapGenerator;ntvar util = webpack_require(4);ntnt// Matches a Windows-style `\r\n` newline or a `\n` newline used by all othernt// operating systems these days (capturing the result).ntvar REGEX_NEWLINE = /(\r?\n)/;ntnt// Newline character code for charCodeAt() comparisonsntvar NEWLINE_CODE = 10;ntnt// Private symbol for identifying `SourceNode`s when multiple versions ofnt// the source-map library are loaded. This MUST NOT CHANGE acrossnt// versions!ntvar isSourceNode = "$$$isSourceNode$$$";ntnt/**nt * SourceNodes provide a way to abstract over interpolating/concatenatingnt * snippets of generated JavaScript source code while maintaining the line andnt * column information associated with the original source code.nt *nt * @param aLine The original line number.nt * @param aColumn The original column number.nt * @param aSource The original source's filename.nt * @param aChunks Optional. An array of strings which are snippets ofnt * generated JS, or other SourceNodes.nt * @param aName The original identifier.nt */ntfunction SourceNode(aLine, aColumn, aSource, aChunks, aName) {nt this.children = [];nt this.sourceContents = {};nt this.line = aLine == null ? null : aLine;nt this.column = aColumn == null ? null : aColumn;nt this.source = aSource == null ? null : aSource;nt this.name = aName == null ? null : aName;nt this = true;nt if (aChunks != null) this.add(aChunks);nt}ntnt/**nt * Creates a SourceNode from generated code and a SourceMapConsumer.nt *nt * @param aGeneratedCode The generated codent * @param aSourceMapConsumer The SourceMap for the generated codent * @param aRelativePath Optional. The path that relative sources in thent * SourceMapConsumer should be relative to.nt */ntSourceNode.fromStringWithSourceMap =nt function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {nt // The SourceNode we want to fill with the generated codent // and the SourceMapnt var node = new SourceNode();ntnt // All even indices of this array are one line of the generated code,nt // while all odd indices are the newlines between two adjacent linesnt // (since `REGEX_NEWLINE` captures its match).nt // Processed fragments are accessed by calling `shiftNextLine`.nt var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);nt var remainingLinesIndex = 0;nt var shiftNextLine = function() {nt var lineContents = getNextLine();nt // The last line of a file might not have a newline.nt var newLine = getNextLine() || "";nt return lineContents + newLine;ntnt function getNextLine() {nt return remainingLinesIndex < remainingLines.length ?nt remainingLines : undefined;nt }nt };ntnt // We need to remember the position of "remainingLines"nt var lastGeneratedLine = 1, lastGeneratedColumn = 0;ntnt // The generate SourceNodes we need a code range.nt // To extract it current and last mapping is used.nt // Here we store the last mapping.nt var lastMapping = null;ntnt aSourceMapConsumer.eachMapping(function (mapping) {nt if (lastMapping !== null) {nt // We add the code from "lastMapping" to "mapping":nt // First check if there is a new line in between.nt if (lastGeneratedLine < mapping.generatedLine) {nt // Associate first line with "lastMapping"nt addMappingWithCode(lastMapping, shiftNextLine());nt lastGeneratedLine++;nt lastGeneratedColumn = 0;nt // The remaining code is added without mappingnt } else {nt // There is no new line in between.nt // Associate the code between "lastGeneratedColumn" andnt // "mapping.generatedColumn" with "lastMapping"nt var nextLine = remainingLines || '';nt var code = nextLine.substr(0, mapping.generatedColumn -nt lastGeneratedColumn);nt remainingLines = nextLine.substr(mapping.generatedColumn -nt lastGeneratedColumn);nt lastGeneratedColumn = mapping.generatedColumn;nt addMappingWithCode(lastMapping, code);nt // No more remaining code, continuent lastMapping = mapping;nt return;nt }nt }nt // We add the generated code until the first mappingnt // to the SourceNode without any mapping.nt // Each line is added as separate string.nt while (lastGeneratedLine < mapping.generatedLine) {nt node.add(shiftNextLine());nt lastGeneratedLine++;nt }nt if (lastGeneratedColumn < mapping.generatedColumn) {nt var nextLine = remainingLines || '';nt node.add(nextLine.substr(0, mapping.generatedColumn));nt remainingLines = nextLine.substr(mapping.generatedColumn);nt lastGeneratedColumn = mapping.generatedColumn;nt }nt lastMapping = mapping;nt }, this);nt // We have processed all mappings.nt if (remainingLinesIndex < remainingLines.length) {nt if (lastMapping) {nt // Associate the remaining code in the current line with "lastMapping"nt addMappingWithCode(lastMapping, shiftNextLine());nt }nt // and add the remaining lines without any mappingnt node.add(remainingLines.splice(remainingLinesIndex).join(""));nt }ntnt // Copy sourcesContent into SourceNodent aSourceMapConsumer.sources.forEach(function (sourceFile) {nt var content = aSourceMapConsumer.sourceContentFor(sourceFile);nt if (content != null) {nt if (aRelativePath != null) {nt sourceFile = util.join(aRelativePath, sourceFile);nt }nt node.setSourceContent(sourceFile, content);nt }nt });ntnt return node;ntnt function addMappingWithCode(mapping, code) {nt if (mapping === null || mapping.source === undefined) {nt node.add(code);nt } else {nt var source = aRelativePathnt ? util.join(aRelativePath, mapping.source)nt : mapping.source;nt node.add(new SourceNode(mapping.originalLine,nt mapping.originalColumn,nt source,nt code,nt mapping.name));nt }nt }nt };ntnt/**nt * Add a chunk of generated JS to this source node.nt *nt * @param aChunk A string snippet of generated JS code, another instance ofnt * SourceNode, or an array where each member is one of those things.nt */ntSourceNode.prototype.add = function SourceNode_add(aChunk) {nt if (Array.isArray(aChunk)) {nt aChunk.forEach(function (chunk) {nt this.add(chunk);nt }, this);nt }nt else if (aChunk || typeof aChunk === "string") {nt if (aChunk) {nt this.children.push(aChunk);nt }nt }nt else {nt throw new TypeError(nt "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunknt );nt }nt return this;nt};ntnt/**nt * Add a chunk of generated JS to the beginning of this source node.nt *nt * @param aChunk A string snippet of generated JS code, another instance ofnt * SourceNode, or an array where each member is one of those things.nt */ntSourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {nt if (Array.isArray(aChunk)) {nt for (var i = aChunk.length-1; i >= 0; i–) {nt this.prepend(aChunk);nt }nt }nt else if (aChunk || typeof aChunk === "string") {nt this.children.unshift(aChunk);nt }nt else {nt throw new TypeError(nt "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunknt );nt }nt return this;nt};ntnt/**nt * Walk over the tree of JS snippets in this node and its children. Thent * walking function is called once for each snippet of JS and is passed thatnt * snippet and the its original associated source's line/column location.nt *nt * @param aFn The traversal function.nt */ntSourceNode.prototype.walk = function SourceNode_walk(aFn) {nt var chunk;nt for (var i = 0, len = this.children.length; i < len; i++) {nt chunk = this.children;nt if (chunk) {nt chunk.walk(aFn);nt }nt else {nt if (chunk !== '') {nt aFn(chunk, { source: this.source,nt line: this.line,nt column: this.column,nt name: this.name });nt }nt }nt }nt};ntnt/**nt * Like `String.prototype.join` except for SourceNodes. Inserts `aStr` betweennt * each of `this.children`.nt *nt * @param aSep The separator.nt */ntSourceNode.prototype.join = function SourceNode_join(aSep) {nt var newChildren;nt var i;nt var len = this.children.length;nt if (len > 0) {nt newChildren = [];nt for (i = 0; i < len-1; i++) {nt newChildren.push(this.children);nt newChildren.push(aSep);nt }nt newChildren.push(this.children);nt this.children = newChildren;nt }nt return this;nt};ntnt/**nt * Call String.prototype.replace on the very right-most source snippet. Usefulnt * for trimming whitespace from the end of a source node, etc.nt *nt * @param aPattern The pattern to replace.nt * @param aReplacement The thing to replace the pattern with.nt */ntSourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {nt var lastChild = this.children[this.children.length - 1];nt if (lastChild) {nt lastChild.replaceRight(aPattern, aReplacement);nt }nt else if (typeof lastChild === 'string') {nt this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);nt }nt else {nt this.children.push(''.replace(aPattern, aReplacement));nt }nt return this;nt};ntnt/**nt * Set the source content for a source file. This will be added to the SourceMapGeneratornt * in the sourcesContent field.nt *nt * @param aSourceFile The filename of the source filent * @param aSourceContent The content of the source filent */ntSourceNode.prototype.setSourceContent =nt function SourceNode_setSourceContent(aSourceFile, aSourceContent) {nt this.sourceContents = aSourceContent;nt };ntnt/**nt * Walk over the tree of SourceNodes. The walking function is called for eachnt * source file content and is passed the filename and source content.nt *nt * @param aFn The traversal function.nt */ntSourceNode.prototype.walkSourceContents =nt function SourceNode_walkSourceContents(aFn) {nt for (var i = 0, len = this.children.length; i < len; i++) {nt if (this.children[isSourceNode]) {nt this.children.walkSourceContents(aFn);nt }nt }ntnt var sources = Object.keys(this.sourceContents);nt for (var i = 0, len = sources.length; i < len; i++) {nt aFn(util.fromSetString(sources), this.sourceContents[sources]);nt }nt };ntnt/**nt * Return the string representation of this source node. Walks over the treent * and concatenates all the various snippets together to one string.nt */ntSourceNode.prototype.toString = function SourceNode_toString() {nt var str = "";nt this.walk(function (chunk) {nt str += chunk;nt });nt return str;nt};ntnt/**nt * Returns the string representation of this source node along with a sourcent * map.nt */ntSourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {nt var generated = {nt code: "",nt line: 1,nt column: 0nt };nt var map = new SourceMapGenerator(aArgs);nt var sourceMappingActive = false;nt var lastOriginalSource = null;nt var lastOriginalLine = null;nt var lastOriginalColumn = null;nt var lastOriginalName = null;nt this.walk(function (chunk, original) {nt generated.code += chunk;nt if (original.source !== nullnt && original.line !== nullnt && original.column !== null) {nt if(lastOriginalSource !== original.sourcent || lastOriginalLine !== original.linent || lastOriginalColumn !== original.columnnt || lastOriginalName !== original.name) {nt map.addMapping({nt source: original.source,nt original: {nt line: original.line,nt column: original.columnnt },nt generated: {nt line: generated.line,nt column: generated.columnnt },nt name: original.nament });nt }nt lastOriginalSource = original.source;nt lastOriginalLine = original.line;nt lastOriginalColumn = original.column;nt lastOriginalName = original.name;nt sourceMappingActive = true;nt } else if (sourceMappingActive) {nt map.addMapping({nt generated: {nt line: generated.line,nt column: generated.columnnt }nt });nt lastOriginalSource = null;nt sourceMappingActive = false;nt }nt for (var idx = 0, length = chunk.length; idx < length; idx++) {nt if (chunk.charCodeAt(idx) === NEWLINE_CODE) {nt generated.line++;nt generated.column = 0;nt // Mappings end at eolnt if (idx + 1 === length) {nt lastOriginalSource = null;nt sourceMappingActive = false;nt } else if (sourceMappingActive) {nt map.addMapping({nt source: original.source,nt original: {nt line: original.line,nt column: original.columnnt },nt generated: {nt line: generated.line,nt column: generated.columnnt },nt name: original.nament });nt }nt } else {nt generated.column++;nt }nt }nt });nt this.walkSourceContents(function (sourceFile, sourceContent) {nt map.setSourceContent(sourceFile, sourceContent);nt });ntnt return { code: generated.code, map: map };nt};ntntexports.SourceNode = SourceNode;nnn/***/ })n/******/ ])n});n;nnn// WEBPACK FOOTER //n// source-map.min.js”,“ t// The module cachen tvar installedModules = {};nn t// The require functionn tfunction webpack_require(moduleId) {nn tt// Check if module is in cachen ttif(installedModules[moduleId])n tttreturn installedModules.exports;nn tt// Create a new module (and put it into the cache)n ttvar module = installedModules = {n tttexports: {},n tttid: moduleId,n tttloaded: falsen tt};nn tt// Execute the module functionn ttmodules[moduleId].call(module.exports, module, module.exports, webpack_require);nn tt// Flag the module as loadedn ttmodule.loaded = true;nn tt// Return the exports of the modulen ttreturn module.exports;n t}nnn t// expose the modules object (webpack_modules)n t_webpack_require_.m = modules;nn t// expose the module cachen t_webpack_require_.c = installedModules;nn t// webpack_public_pathn t_webpack_require_.p = "";nn t// Load entry module and return exportsn treturn webpack_require(0);nnnn// WEBPACK FOOTER //n// webpack/bootstrap 0fd5815da764db5fb9fe”,“/*n * Copyright 2009-2011 Mozilla Foundation and contributorsn * Licensed under the New BSD license. See LICENSE.txt or:n * opensource.org/licenses/BSD-3-Clausen */nexports.SourceMapGenerator = require('./lib/source-map-generator').SourceMapGenerator;nexports.SourceMapConsumer = require('./lib/source-map-consumer').SourceMapConsumer;nexports.SourceNode = require('./lib/source-node').SourceNode;nnnn//////////////////n// WEBPACK FOOTERn// ./source-map.jsn// module id = 0n// module chunks = 0”,“/* -*- Mode: js; js-indent-level: 2; -*- */n/*n * Copyright 2011 Mozilla Foundation and contributorsn * Licensed under the New BSD license. See LICENSE or:n * opensource.org/licenses/BSD-3-Clausen */nnvar base64VLQ = require('./base64-vlq');nvar util = require('./util');nvar ArraySet = require('./array-set').ArraySet;nvar MappingList = require('./mapping-list').MappingList;nn/**n * An instance of the SourceMapGenerator represents a source map which isn * being built incrementally. You may pass an object with the followingn * properties:n *n * - file: The filename of the generated source.n * - sourceRoot: A root for all relative URLs in this source map.n */nfunction SourceMapGenerator(aArgs) {n if (!aArgs) {n aArgs = {};n }n this._file = util.getArg(aArgs, 'file', null);n this._sourceRoot = util.getArg(aArgs, 'sourceRoot', null);n this._skipValidation = util.getArg(aArgs, 'skipValidation', false);n this._sources = new ArraySet();n this._names = new ArraySet();n this._mappings = new MappingList();n this._sourcesContents = null;n}nnSourceMapGenerator.prototype._version = 3;nn/**n * Creates a new SourceMapGenerator based on a SourceMapConsumern *n * @param aSourceMapConsumer The SourceMap.n */nSourceMapGenerator.fromSourceMap =n function SourceMapGenerator_fromSourceMap(aSourceMapConsumer) {n var sourceRoot = aSourceMapConsumer.sourceRoot;n var generator = new SourceMapGenerator({n file: aSourceMapConsumer.file,n sourceRoot: sourceRootn });n aSourceMapConsumer.eachMapping(function (mapping) {n var newMapping = {n generated: {n line: mapping.generatedLine,n column: mapping.generatedColumnn }n };nn if (mapping.source != null) {n newMapping.source = mapping.source;n if (sourceRoot != null) {n newMapping.source = util.relative(sourceRoot, newMapping.source);n }nn newMapping.original = {n line: mapping.originalLine,n column: mapping.originalColumnn };nn if (mapping.name != null) {n newMapping.name = mapping.name;n }n }nn generator.addMapping(newMapping);n });n aSourceMapConsumer.sources.forEach(function (sourceFile) {n var sourceRelative = sourceFile;n if (sourceRoot !== null) {n sourceRelative = util.relative(sourceRoot, sourceFile);n }nn if (!generator._sources.has(sourceRelative)) {n generator._sources.add(sourceRelative);n }nn var content = aSourceMapConsumer.sourceContentFor(sourceFile);n if (content != null) {n generator.setSourceContent(sourceFile, content);n }n });n return generator;n };nn/**n * Add a single mapping from original source line and column to the generatedn * source's line and column for this source map being created. The mappingn * object should have the following properties:n *n * - generated: An object with the generated line and column positions.n * - original: An object with the original line and column positions.n * - source: The original source file (relative to the sourceRoot).n * - name: An optional original token name for this mapping.n */nSourceMapGenerator.prototype.addMapping =n function SourceMapGenerator_addMapping(aArgs) {n var generated = util.getArg(aArgs, 'generated');n var original = util.getArg(aArgs, 'original', null);n var source = util.getArg(aArgs, 'source', null);n var name = util.getArg(aArgs, 'name', null);nn if (!this._skipValidation) {n this._validateMapping(generated, original, source, name);n }nn if (source != null) {n source = String(source);n if (!this._sources.has(source)) {n this._sources.add(source);n }n }nn if (name != null) {n name = String(name);n if (!this._names.has(name)) {n this._names.add(name);n }n }nn this._mappings.add({n generatedLine: generated.line,n generatedColumn: generated.column,n originalLine: original != null && original.line,n originalColumn: original != null && original.column,n source: source,n name: namen });n };nn/**n * Set the source content for a source file.n */nSourceMapGenerator.prototype.setSourceContent =n function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {n var source = aSourceFile;n if (this._sourceRoot != null) {n source = util.relative(this._sourceRoot, source);n }nn if (aSourceContent != null) {n // Add the source content to the _sourcesContents map.n // Create a new _sourcesContents map if the property is null.n if (!this._sourcesContents) {n this._sourcesContents = Object.create(null);n }n this._sourcesContents = aSourceContent;n } else if (this._sourcesContents) {n // Remove the source file from the _sourcesContents map.n // If the _sourcesContents map is empty, set the property to null.n delete this._sourcesContents;n if (Object.keys(this._sourcesContents).length === 0) {n this._sourcesContents = null;n }n }n };nn/**n * Applies the mappings of a sub-source-map for a specific source file to then * source map being generated. Each mapping to the supplied source file isn * rewritten using the supplied source map. Note: The resolution for then * resulting mappings is the minimium of this map and the supplied map.n *n * @param aSourceMapConsumer The source map to be applied.n * @param aSourceFile Optional. The filename of the source file.n * If omitted, SourceMapConsumer's file property will be used.n * @param aSourceMapPath Optional. The dirname of the path to the source mapn * to be applied. If relative, it is relative to the SourceMapConsumer.n * This parameter is needed when the two source maps aren't in the samen * directory, and the source map to be applied contains relative sourcen * paths. If so, those relative source paths need to be rewrittenn * relative to the SourceMapGenerator.n */nSourceMapGenerator.prototype.applySourceMap =n function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {n var sourceFile = aSourceFile;n // If aSourceFile is omitted, we will use the file property of the SourceMapn if (aSourceFile == null) {n if (aSourceMapConsumer.file == null) {n throw new Error(n 'SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, ' +n 'or the source map\'s "file" property. Both were omitted.'n );n }n sourceFile = aSourceMapConsumer.file;n }n var sourceRoot = this._sourceRoot;n // Make "sourceFile" relative if an absolute Url is passed.n if (sourceRoot != null) {n sourceFile = util.relative(sourceRoot, sourceFile);n }n // Applying the SourceMap can add and remove items from the sources andn // the names array.n var newSources = new ArraySet();n var newNames = new ArraySet();nn // Find mappings for the "sourceFile"n this._mappings.unsortedForEach(function (mapping) {n if (mapping.source === sourceFile && mapping.originalLine != null) {n // Check if it can be mapped by the source map, then update the mapping.n var original = aSourceMapConsumer.originalPositionFor({n line: mapping.originalLine,n column: mapping.originalColumnn });n if (original.source != null) {n // Copy mappingn mapping.source = original.source;n if (aSourceMapPath != null) {n mapping.source = util.join(aSourceMapPath, mapping.source)n }n if (sourceRoot != null) {n mapping.source = util.relative(sourceRoot, mapping.source);n }n mapping.originalLine = original.line;n mapping.originalColumn = original.column;n if (original.name != null) {n mapping.name = original.name;n }n }n }nn var source = mapping.source;n if (source != null && !newSources.has(source)) {n newSources.add(source);n }nn var name = mapping.name;n if (name != null && !newNames.has(name)) {n newNames.add(name);n }nn }, this);n this._sources = newSources;n this._names = newNames;nn // Copy sourcesContents of applied map.n aSourceMapConsumer.sources.forEach(function (sourceFile) {n var content = aSourceMapConsumer.sourceContentFor(sourceFile);n if (content != null) {n if (aSourceMapPath != null) {n sourceFile = util.join(aSourceMapPath, sourceFile);n }n if (sourceRoot != null) {n sourceFile = util.relative(sourceRoot, sourceFile);n }n this.setSourceContent(sourceFile, content);n }n }, this);n };nn/**n * A mapping can have one of the three levels of data:n *n * 1. Just the generated position.n * 2. The Generated position, original position, and original source.n * 3. Generated and original position, original source, as well as a namen * token.n *n * To maintain consistency, we validate that any new mapping being added fallsn * in to one of these categories.n */nSourceMapGenerator.prototype._validateMapping =n function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource,n aName) {n // When aOriginal is truthy but has empty values for .line and .column,n // it is most likely a programmer error. In this case we throw a veryn // specific error message to try to guide them the right way.n // For example: github.com/Polymer/polymer-bundler/pull/519n if (aOriginal && typeof aOriginal.line !== 'number' && typeof aOriginal.column !== 'number') {n throw new Error(n 'original.line and original.column are not numbers – you probably meant to omit ' +n 'the original mapping entirely and only map the generated position. If so, pass ' +n 'null for the original mapping instead of an object with empty or null values.'n );n }nn if (aGenerated && 'line' in aGenerated && 'column' in aGeneratedn && aGenerated.line > 0 && aGenerated.column >= 0n && !aOriginal && !aSource && !aName) {n // Case 1.n return;n }n else if (aGenerated && 'line' in aGenerated && 'column' in aGeneratedn && aOriginal && 'line' in aOriginal && 'column' in aOriginaln && aGenerated.line > 0 && aGenerated.column >= 0n && aOriginal.line > 0 && aOriginal.column >= 0n && aSource) {n // Cases 2 and 3.n return;n }n else {n throw new Error('Invalid mapping: ' + JSON.stringify({n generated: aGenerated,n source: aSource,n original: aOriginal,n name: aNamen }));n }n };nn/**n * Serialize the accumulated mappings in to the stream of base 64 VLQsn * specified by the source map format.n */nSourceMapGenerator.prototype._serializeMappings =n function SourceMapGenerator_serializeMappings() {n var previousGeneratedColumn = 0;n var previousGeneratedLine = 1;n var previousOriginalColumn = 0;n var previousOriginalLine = 0;n var previousName = 0;n var previousSource = 0;n var result = '';n var next;n var mapping;n var nameIdx;n var sourceIdx;nn var mappings = this._mappings.toArray();n for (var i = 0, len = mappings.length; i < len; i++) {n mapping = mappings;n next = ''nn if (mapping.generatedLine !== previousGeneratedLine) {n previousGeneratedColumn = 0;n while (mapping.generatedLine !== previousGeneratedLine) {n next += ';';n previousGeneratedLine++;n }n }n else {n if (i > 0) {n if (!util.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) {n continue;n }n next += ',';n }n }nn next += base64VLQ.encode(mapping.generatedColumnn - previousGeneratedColumn);n previousGeneratedColumn = mapping.generatedColumn;nn if (mapping.source != null) {n sourceIdx = this._sources.indexOf(mapping.source);n next += base64VLQ.encode(sourceIdx - previousSource);n previousSource = sourceIdx;nn // lines are stored 0-based in SourceMap spec version 3n next += base64VLQ.encode(mapping.originalLine - 1n - previousOriginalLine);n previousOriginalLine = mapping.originalLine - 1;nn next += base64VLQ.encode(mapping.originalColumnn - previousOriginalColumn);n previousOriginalColumn = mapping.originalColumn;nn if (mapping.name != null) {n nameIdx = this._names.indexOf(mapping.name);n next += base64VLQ.encode(nameIdx - previousName);n previousName = nameIdx;n }n }nn result += next;n }nn return result;n };nnSourceMapGenerator.prototype._generateSourcesContent =n function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {n return aSources.map(function (source) {n if (!this._sourcesContents) {n return null;n }n if (aSourceRoot != null) {n source = util.relative(aSourceRoot, source);n }n var key = util.toSetString(source);n return Object.prototype.hasOwnProperty.call(this._sourcesContents, key)n ? this._sourcesContentsn : null;n }, this);n };nn/**n * Externalize the source map.n */nSourceMapGenerator.prototype.toJSON =n function SourceMapGenerator_toJSON() {n var map = {n version: this._version,n sources: this._sources.toArray(),n names: this._names.toArray(),n mappings: this._serializeMappings()n };n if (this._file != null) {n map.file = this._file;n }n if (this._sourceRoot != null) {n map.sourceRoot = this._sourceRoot;n }n if (this._sourcesContents) {n map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);n }nn return map;n };nn/**n * Render the source map being generated to a string.n */nSourceMapGenerator.prototype.toString =n function SourceMapGenerator_toString() {n return JSON.stringify(this.toJSON());n };nnexports.SourceMapGenerator = SourceMapGenerator;nnnn//////////////////n// WEBPACK FOOTERn// ./lib/source-map-generator.jsn// module id = 1n// module chunks = 0”,“/* -*- Mode: js; js-indent-level: 2; -*- */n/*n * Copyright 2011 Mozilla Foundation and contributorsn * Licensed under the New BSD license. See LICENSE or:n * opensource.org/licenses/BSD-3-Clausen *n * Based on the Base 64 VLQ implementation in Closure Compiler:n * code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/debugging/sourcemap/Base64VLQ.javan *n * Copyright 2011 The Closure Compiler Authors. All rights reserved.n * Redistribution and use in source and binary forms, with or withoutn * modification, are permitted provided that the following conditions aren * met:n *n * * Redistributions of source code must retain the above copyrightn * notice, this list of conditions and the following disclaimer.n * * Redistributions in binary form must reproduce the aboven * copyright notice, this list of conditions and the followingn * disclaimer in the documentation and/or other materials providedn * with the distribution.n * * Neither the name of Google Inc. nor the names of itsn * contributors may be used to endorse or promote products derivedn * from this software without specific prior written permission.n *n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORSn * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOTn * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FORn * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHTn * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOTn * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANYn * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORTn * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USEn * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.n */nnvar base64 = require('./base64');nn// A single base 64 digit can contain 6 bits of data. For the base 64 variablen// length quantities we use in the source map spec, the first bit is the sign,n// the next four bits are the actual value, and the 6th bit is then// continuation bit. The continuation bit tells us whether there are moren// digits in this value following this digit.n//n// Continuationn// | Signn// | |n// V Vn// 101011nnvar VLQ_BASE_SHIFT = 5;nn// binary: 100000nvar VLQ_BASE = 1 << VLQ_BASE_SHIFT;nn// binary: 011111nvar VLQ_BASE_MASK = VLQ_BASE - 1;nn// binary: 100000nvar VLQ_CONTINUATION_BIT = VLQ_BASE;nn/**n * Converts from a two-complement value to a value where the sign bit isn * placed in the least significant bit. For example, as decimals:n * 1 becomes 2 (10 binary), -1 becomes 3 (11 binary)n * 2 becomes 4 (100 binary), -2 becomes 5 (101 binary)n */nfunction toVLQSigned(aValue) {n return aValue < 0n ? ((-aValue) << 1) + 1n : (aValue << 1) + 0;n}nn/**n * Converts to a two-complement value from a value where the sign bit isn * placed in the least significant bit. For example, as decimals:n * 2 (10 binary) becomes 1, 3 (11 binary) becomes -1n * 4 (100 binary) becomes 2, 5 (101 binary) becomes -2n */nfunction fromVLQSigned(aValue) {n var isNegative = (aValue & 1) === 1;n var shifted = aValue >> 1;n return isNegativen ? -shiftedn : shifted;n}nn/**n * Returns the base 64 VLQ encoded value.n */nexports.encode = function base64VLQ_encode(aValue) {n var encoded = "";n var digit;nn var vlq = toVLQSigned(aValue);nn do {n digit = vlq & VLQ_BASE_MASK;n vlq >>>= VLQ_BASE_SHIFT;n if (vlq > 0) {n // There are still more digits in this value, so we must make sure then // continuation bit is marked.n digit |= VLQ_CONTINUATION_BIT;n }n encoded += base64.encode(digit);n } while (vlq > 0);nn return encoded;n};nn/**n * Decodes the next base 64 VLQ value from the given string and returns then * value and the rest of the string via the out parameter.n */nexports.decode = function base64VLQ_decode(aStr, aIndex, aOutParam) {n var strLen = aStr.length;n var result = 0;n var shift = 0;n var continuation, digit;nn do {n if (aIndex >= strLen) {n throw new Error("Expected more digits in base 64 VLQ value.");n }nn digit = base64.decode(aStr.charCodeAt(aIndex++));n if (digit === -1) {n throw new Error("Invalid base64 digit: " + aStr.charAt(aIndex - 1));n }nn continuation = !!(digit & VLQ_CONTINUATION_BIT);n digit &= VLQ_BASE_MASK;n result = result + (digit << shift);n shift += VLQ_BASE_SHIFT;n } while (continuation);nn aOutParam.value = fromVLQSigned(result);n aOutParam.rest = aIndex;n};nnnn//////////////////n// WEBPACK FOOTERn// ./lib/base64-vlq.jsn// module id = 2n// module chunks = 0”,“/* -*- Mode: js; js-indent-level: 2; -*- */n/*n * Copyright 2011 Mozilla Foundation and contributorsn * Licensed under the New BSD license. See LICENSE or:n * opensource.org/licenses/BSD-3-Clausen */nnvar intToCharMap = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split('');nn/**n * Encode an integer in the range of 0 to 63 to a single base 64 digit.n */nexports.encode = function (number) {n if (0 <= number && number < intToCharMap.length) {n return intToCharMap;n }n throw new TypeError("Must be between 0 and 63: " + number);n};nn/**n * Decode a single base 64 character code digit to an integer. Returns -1 onn * failure.n */nexports.decode = function (charCode) {n var bigA = 65; // 'A'n var bigZ = 90; // 'Z'nn var littleA = 97; // 'a'n var littleZ = 122; // 'z'nn var zero = 48; // '0'n var nine = 57; // '9'nn var plus = 43; // '+'n var slash = 47; // '/'nn var littleOffset = 26;n var numberOffset = 52;nn // 0 - 25: ABCDEFGHIJKLMNOPQRSTUVWXYZn if (bigA <= charCode && charCode <= bigZ) {n return (charCode - bigA);n }nn // 26 - 51: abcdefghijklmnopqrstuvwxyzn if (littleA <= charCode && charCode <= littleZ) {n return (charCode - littleA + littleOffset);n }nn // 52 - 61: 0123456789n if (zero <= charCode && charCode <= nine) {n return (charCode - zero + numberOffset);n }nn // 62: +n if (charCode == plus) {n return 62;n }nn // 63: /n if (charCode == slash) {n return 63;n }nn // Invalid base64 digit.n return -1;n};nnnn//////////////////n// WEBPACK FOOTERn// ./lib/base64.jsn// module id = 3n// module chunks = 0”,“/* -*- Mode: js; js-indent-level: 2; -*- */n/*n * Copyright 2011 Mozilla Foundation and contributorsn * Licensed under the New BSD license. See LICENSE or:n * opensource.org/licenses/BSD-3-Clausen */nn/**n * This is a helper function for getting values from parameter/optionsn * objects.n *n * @param args The object we are extracting values fromn * @param name The name of the property we are getting.n * @param defaultValue An optional value to return if the property is missingn * from the object. If this is not specified and the property is missing, ann * error will be thrown.n */nfunction getArg(aArgs, aName, aDefaultValue) {n if (aName in aArgs) {n return aArgs;n } else if (arguments.length === 3) {n return aDefaultValue;n } else {n throw new Error('"' + aName + '" is a required argument.');n }n}nexports.getArg = getArg;nnvar urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?(*)(?::(\d+))?(.*)$/;nvar dataUrlRegexp = /^data:.+\,.+$/;nnfunction urlParse(aUrl) {n var match = aUrl.match(urlRegexp);n if (!match) {n return null;n }n return {n scheme: match,n auth: match,n host: match,n port: match,n path: matchn };n}nexports.urlParse = urlParse;nnfunction urlGenerate(aParsedUrl) {n var url = '';n if (aParsedUrl.scheme) {n url += aParsedUrl.scheme + ':';n }n url += '//';n if (aParsedUrl.auth) {n url += aParsedUrl.auth + '@';n }n if (aParsedUrl.host) {n url += aParsedUrl.host;n }n if (aParsedUrl.port) {n url += ":" + aParsedUrl.portn }n if (aParsedUrl.path) {n url += aParsedUrl.path;n }n return url;n}nexports.urlGenerate = urlGenerate;nn/**n * Normalizes a path, or the path portion of a URL:n *n * - Replaces consecutive slashes with one slash.n * - Removes unnecessary '.' parts.n * - Removes unnecessary '<dir>/..' parts.n *n * Based on code in the Node.js 'path' core module.n *n * @param aPath The path or url to normalize.n */nfunction normalize(aPath) {n var path = aPath;n var url = urlParse(aPath);n if (url) {n if (!url.path) {n return aPath;n }n path = url.path;n }n var isAbsolute = exports.isAbsolute(path);nn var parts = path.split(/\/+/);n for (var part, up = 0, i = parts.length - 1; i >= 0; i–) {n part = parts;n if (part === '.') {n parts.splice(i, 1);n } else if (part === '..') {n up++;n } else if (up > 0) {n if (part === '') {n // The first part is blank if the path is absolute. Trying to gon // above the root is a no-op. Therefore we can remove all '..' partsn // directly after the root.n parts.splice(i + 1, up);n up = 0;n } else {n parts.splice(i, 2);n up–;n }n }n }n path = parts.join('/');nn if (path === '') {n path = isAbsolute ? '/' : '.';n }nn if (url) {n url.path = path;n return urlGenerate(url);n }n return path;n}nexports.normalize = normalize;nn/**n * Joins two paths/URLs.n *n * @param aRoot The root path or URL.n * @param aPath The path or URL to be joined with the root.n *n * - If aPath is a URL or a data URI, aPath is returned, unless aPath is an * scheme-relative URL: Then the scheme of aRoot, if any, is prependedn * first.n * - Otherwise aPath is a path. If aRoot is a URL, then its path portionn * is updated with the result and aRoot is returned. Otherwise the resultn * is returned.n * - If aPath is absolute, the result is aPath.n * - Otherwise the two paths are joined with a slash.n * - Joining for example 'http://' and 'www.example.com' is also supported.n */nfunction join(aRoot, aPath) {n if (aRoot === "") {n aRoot = ".";n }n if (aPath === "") {n aPath = ".";n }n var aPathUrl = urlParse(aPath);n var aRootUrl = urlParse(aRoot);n if (aRootUrl) {n aRoot = aRootUrl.path || '/';n }nn // `join(foo, '//www.example.org’)`n if (aPathUrl && !aPathUrl.scheme) {n if (aRootUrl) {n aPathUrl.scheme = aRootUrl.scheme;n }n return urlGenerate(aPathUrl);n }nn if (aPathUrl || aPath.match(dataUrlRegexp)) {n return aPath;n }nn // `join('http://', 'www.example.com’)`n if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {n aRootUrl.host = aPath;n return urlGenerate(aRootUrl);n }nn var joined = aPath.charAt(0) === '/'n ? aPathn : normalize(aRoot.replace(/\/+$/, '') + '/' + aPath);nn if (aRootUrl) {n aRootUrl.path = joined;n return urlGenerate(aRootUrl);n }n return joined;n}nexports.join = join;nnexports.isAbsolute = function (aPath) {n return aPath.charAt(0) === '/' || urlRegexp.test(aPath);n};nn/**n * Make a path relative to a URL or another path.n *n * @param aRoot The root path or URL.n * @param aPath The path or URL to be made relative to aRoot.n */nfunction relative(aRoot, aPath) {n if (aRoot === "") {n aRoot = ".";n }nn aRoot = aRoot.replace(/\/$/, '');nn // It is possible for the path to be above the root. In this case, simplyn // checking whether the root is a prefix of the path won't work. Instead, wen // need to remove components from the root one by one, until either we findn // a prefix that fits, or we run out of components to remove.n var level = 0;n while (aPath.indexOf(aRoot + '/') !== 0) {n var index = aRoot.lastIndexOf("/");n if (index < 0) {n return aPath;n }nn // If the only part of the root that is left is the scheme (i.e. ,n // file:///, etc.), one or more slashes (/), or simply nothing at all, wen // have exhausted all components, so the path is not relative to the root.n aRoot = aRoot.slice(0, index);n if (aRoot.match(/^(+:\/)?\/*$/)) {n return aPath;n }nn ++level;n }nn // Make sure we add a "../" for each component we removed from the root.n return Array(level + 1).join("../") + aPath.substr(aRoot.length + 1);n}nexports.relative = relative;nnvar supportsNullProto = (function () {n var obj = Object.create(null);n return !('__proto__' in obj);n}());nnfunction identity (s) {n return s;n}nn/**n * Because behavior goes wacky when you set `__proto__` on objects, wen * have to prefix all the strings in our set with an arbitrary character.n *n * See github.com/mozilla/source-map/pull/31 andn * github.com/mozilla/source-map/issues/30n *n * @param String aStrn */nfunction toSetString(aStr) {n if (isProtoString(aStr)) {n return '$' + aStr;n }nn return aStr;n}nexports.toSetString = supportsNullProto ? identity : toSetString;nnfunction fromSetString(aStr) {n if (isProtoString(aStr)) {n return aStr.slice(1);n }nn return aStr;n}nexports.fromSetString = supportsNullProto ? identity : fromSetString;nnfunction isProtoString(s) {n if (!s) {n return false;n }nn var length = s.length;nn if (length < 9 /* "__proto__".length */) {n return false;n }nn if (s.charCodeAt(length - 1) !== 95 /* '_' */ ||n s.charCodeAt(length - 2) !== 95 /* '_' */ ||n s.charCodeAt(length - 3) !== 111 /* 'o' */ ||n s.charCodeAt(length - 4) !== 116 /* 't' */ ||n s.charCodeAt(length - 5) !== 111 /* 'o' */ ||n s.charCodeAt(length - 6) !== 114 /* 'r' */ ||n s.charCodeAt(length - 7) !== 112 /* 'p' */ ||n s.charCodeAt(length - 8) !== 95 /* '_' */ ||n s.charCodeAt(length - 9) !== 95 /* '_' */) {n return false;n }nn for (var i = length - 10; i >= 0; i–) {n if (s.charCodeAt(i) !== 36 /* '$' */) {n return false;n }n }nn return true;n}nn/**n * Comparator between two mappings where the original positions are compared.n *n * Optionally pass in `true` as `onlyCompareGenerated` to consider twon * mappings with the same original source/line/column, but different generatedn * line and column the same. Useful when searching for a mapping with an * stubbed out mapping.n */nfunction compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {n var cmp = strcmp(mappingA.source, mappingB.source);n if (cmp !== 0) {n return cmp;n }nn cmp = mappingA.originalLine - mappingB.originalLine;n if (cmp !== 0) {n return cmp;n }nn cmp = mappingA.originalColumn - mappingB.originalColumn;n if (cmp !== 0 || onlyCompareOriginal) {n return cmp;n }nn cmp = mappingA.generatedColumn - mappingB.generatedColumn;n if (cmp !== 0) {n return cmp;n }nn cmp = mappingA.generatedLine - mappingB.generatedLine;n if (cmp !== 0) {n return cmp;n }nn return strcmp(mappingA.name, mappingB.name);n}nexports.compareByOriginalPositions = compareByOriginalPositions;nn/**n * Comparator between two mappings with deflated source and name indices wheren * the generated positions are compared.n *n * Optionally pass in `true` as `onlyCompareGenerated` to consider twon * mappings with the same generated line and column, but differentn * source/name/original line and column the same. Useful when searching for an * mapping with a stubbed out mapping.n */nfunction compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {n var cmp = mappingA.generatedLine - mappingB.generatedLine;n if (cmp !== 0) {n return cmp;n }nn cmp = mappingA.generatedColumn - mappingB.generatedColumn;n if (cmp !== 0 || onlyCompareGenerated) {n return cmp;n }nn cmp = strcmp(mappingA.source, mappingB.source);n if (cmp !== 0) {n return cmp;n }nn cmp = mappingA.originalLine - mappingB.originalLine;n if (cmp !== 0) {n return cmp;n }nn cmp = mappingA.originalColumn - mappingB.originalColumn;n if (cmp !== 0) {n return cmp;n }nn return strcmp(mappingA.name, mappingB.name);n}nexports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;nnfunction strcmp(aStr1, aStr2) {n if (aStr1 === aStr2) {n return 0;n }nn if (aStr1 === null) {n return 1; // aStr2 !== nulln }nn if (aStr2 === null) {n return -1; // aStr1 !== nulln }nn if (aStr1 > aStr2) {n return 1;n }nn return -1;n}nn/**n * Comparator between two mappings with inflated source and name strings wheren * the generated positions are compared.n */nfunction compareByGeneratedPositionsInflated(mappingA, mappingB) {n var cmp = mappingA.generatedLine - mappingB.generatedLine;n if (cmp !== 0) {n return cmp;n }nn cmp = mappingA.generatedColumn - mappingB.generatedColumn;n if (cmp !== 0) {n return cmp;n }nn cmp = strcmp(mappingA.source, mappingB.source);n if (cmp !== 0) {n return cmp;n }nn cmp = mappingA.originalLine - mappingB.originalLine;n if (cmp !== 0) {n return cmp;n }nn cmp = mappingA.originalColumn - mappingB.originalColumn;n if (cmp !== 0) {n return cmp;n }nn return strcmp(mappingA.name, mappingB.name);n}nexports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;nn/**n * Strip any JSON XSSI avoidance prefix from the string (as documentedn * in the source maps specification), and then parse the string asn * JSON.n */nfunction parseSourceMapInput(str) {n return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, ''));n}nexports.parseSourceMapInput = parseSourceMapInput;nn/**n * Compute the URL of a source given the the source root, the source'sn * URL, and the source map's URL.n */nfunction computeSourceURL(sourceRoot, sourceURL, sourceMapURL) {n sourceURL = sourceURL || '';nn if (sourceRoot) {n // This follows what Chrome does.n if (sourceRoot[sourceRoot.length - 1] !== '/' && sourceURL !== '/') {n sourceRoot += '/';n }n // The spec says:n // Line 4: An optional source root, useful for relocating sourcen // files on a server or removing repeated values in then // “sources” entry. This value is prepended to the individualn // entries in the “source” field.n sourceURL = sourceRoot + sourceURL;n }nn // Historically, SourceMapConsumer did not take the sourceMapURL asn // a parameter. This mode is still somewhat supported, which is whyn // this code block is conditional. However, it's preferable to passn // the source map URL to SourceMapConsumer, so that this functionn // can implement the source URL resolution algorithm as outlined inn // the spec. This block is basically the equivalent of:n // new URL(sourceURL, sourceMapURL).toString()n // … except it avoids using URL, which wasn't available in then // older releases of node still supported by this library.n //n // The spec says:n // If the sources are not absolute URLs after prepending of then // “sourceRoot”, the sources are resolved relative to then // SourceMap (like resolving script src in a html document).n if (sourceMapURL) {n var parsed = urlParse(sourceMapURL);n if (!parsed) {n throw new Error("sourceMapURL could not be parsed");n }n if (parsed.path) {n // Strip the last path component, but keep the "/".n var index = parsed.path.lastIndexOf('/');n if (index >= 0) {n parsed.path = parsed.path.substring(0, index + 1);n }n }n sourceURL = join(urlGenerate(parsed), sourceURL);n }nn return normalize(sourceURL);n}nexports.computeSourceURL = computeSourceURL;nnnn//////////////////n// WEBPACK FOOTERn// ./lib/util.jsn// module id = 4n// module chunks = 0”,“/* -*- Mode: js; js-indent-level: 2; -*- */n/*n * Copyright 2011 Mozilla Foundation and contributorsn * Licensed under the New BSD license. See LICENSE or:n * opensource.org/licenses/BSD-3-Clausen */nnvar util = require('./util');nvar has = Object.prototype.hasOwnProperty;nvar hasNativeMap = typeof Map !== "undefined";nn/**n * A data structure which is a combination of an array and a set. Adding a newn * member is O(1), testing for membership is O(1), and finding the index of ann * element is O(1). Removing elements from the set is not supported. Onlyn * strings are supported for membership.n */nfunction ArraySet() {n this._array = [];n this._set = hasNativeMap ? new Map() : Object.create(null);n}nn/**n * Static method for creating ArraySet instances from an existing array.n */nArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {n var set = new ArraySet();n for (var i = 0, len = aArray.length; i < len; i++) {n set.add(aArray, aAllowDuplicates);n }n return set;n};nn/**n * Return how many unique items are in this ArraySet. If duplicates have beenn * added, than those do not count towards the size.n *n * @returns Numbern */nArraySet.prototype.size = function ArraySet_size() {n return hasNativeMap ? this._set.size : Object.getOwnPropertyNames(this._set).length;n};nn/**n * Add the given string to this set.n *n * @param String aStrn */nArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {n var sStr = hasNativeMap ? aStr : util.toSetString(aStr);n var isDuplicate = hasNativeMap ? this.has(aStr) : has.call(this._set, sStr);n var idx = this._array.length;n if (!isDuplicate || aAllowDuplicates) {n this._array.push(aStr);n }n if (!isDuplicate) {n if (hasNativeMap) {n this._set.set(aStr, idx);n } else {n this._set = idx;n }n }n};nn/**n * Is the given string a member of this set?n *n * @param String aStrn */nArraySet.prototype.has = function ArraySet_has(aStr) {n if (hasNativeMap) {n return this._set.has(aStr);n } else {n var sStr = util.toSetString(aStr);n return has.call(this._set, sStr);n }n};nn/**n * What is the index of the given string in the array?n *n * @param String aStrn */nArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {n if (hasNativeMap) {n var idx = this._set.get(aStr);n if (idx >= 0) {n return idx;n }n } else {n var sStr = util.toSetString(aStr);n if (has.call(this._set, sStr)) {n return this._set;n }n }nn throw new Error('"' + aStr + '" is not in the set.');n};nn/**n * What is the element at the given index?n *n * @param Number aIdxn */nArraySet.prototype.at = function ArraySet_at(aIdx) {n if (aIdx >= 0 && aIdx < this._array.length) {n return this._array;n }n throw new Error('No element indexed by ' + aIdx);n};nn/**n * Returns the array representation of this set (which has the proper indicesn * indicated by indexOf). Note that this is a copy of the internal array usedn * for storing the members so that no one can mess with internal state.n */nArraySet.prototype.toArray = function ArraySet_toArray() {n return this._array.slice();n};nnexports.ArraySet = ArraySet;nnnn//////////////////n// WEBPACK FOOTERn// ./lib/array-set.jsn// module id = 5n// module chunks = 0”,“/* -*- Mode: js; js-indent-level: 2; -*- */n/*n * Copyright 2014 Mozilla Foundation and contributorsn * Licensed under the New BSD license. See LICENSE or:n * opensource.org/licenses/BSD-3-Clausen */nnvar util = require('./util');nn/**n * Determine whether mappingB is after mappingA with respect to generatedn * position.n */nfunction generatedPositionAfter(mappingA, mappingB) {n // Optimized for most common casen var lineA = mappingA.generatedLine;n var lineB = mappingB.generatedLine;n var columnA = mappingA.generatedColumn;n var columnB = mappingB.generatedColumn;n return lineB > lineA || lineB == lineA && columnB >= columnA ||n util.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0;n}nn/**n * A data structure to provide a sorted view of accumulated mappings in an * performance conscious manner. It trades a neglibable overhead in generaln * case for a large speedup in case of mappings being added in order.n */nfunction MappingList() {n this._array = [];n this._sorted = true;n // Serves as infimumn this._last = {generatedLine: -1, generatedColumn: 0};n}nn/**n * Iterate through internal items. This method takes the same arguments thatn * `Array.prototype.forEach` takes.n *n * NOTE: The order of the mappings is NOT guaranteed.n */nMappingList.prototype.unsortedForEach =n function MappingList_forEach(aCallback, aThisArg) {n this._array.forEach(aCallback, aThisArg);n };nn/**n * Add the given source mapping.n *n * @param Object aMappingn */nMappingList.prototype.add = function MappingList_add(aMapping) {n if (generatedPositionAfter(this._last, aMapping)) {n this._last = aMapping;n this._array.push(aMapping);n } else {n this._sorted = false;n this._array.push(aMapping);n }n};nn/**n * Returns the flat, sorted array of mappings. The mappings are sorted byn * generated position.n *n * WARNING: This method returns internal data without copying, forn * performance. The return value must NOT be mutated, and should be treated asn * an immutable borrow. If you want to take ownership, you must make your ownn * copy.n */nMappingList.prototype.toArray = function MappingList_toArray() {n if (!this._sorted) {n this._array.sort(util.compareByGeneratedPositionsInflated);n this._sorted = true;n }n return this._array;n};nnexports.MappingList = MappingList;nnnn//////////////////n// WEBPACK FOOTERn// ./lib/mapping-list.jsn// module id = 6n// module chunks = 0”,“/* -*- Mode: js; js-indent-level: 2; -*- */n/*n * Copyright 2011 Mozilla Foundation and contributorsn * Licensed under the New BSD license. See LICENSE or:n * opensource.org/licenses/BSD-3-Clausen */nnvar util = require('./util');nvar binarySearch = require('./binary-search');nvar ArraySet = require('./array-set').ArraySet;nvar base64VLQ = require('./base64-vlq');nvar quickSort = require('./quick-sort').quickSort;nnfunction SourceMapConsumer(aSourceMap, aSourceMapURL) {n var sourceMap = aSourceMap;n if (typeof aSourceMap === 'string') {n sourceMap = util.parseSourceMapInput(aSourceMap);n }nn return sourceMap.sections != nulln ? new IndexedSourceMapConsumer(sourceMap, aSourceMapURL)n : new BasicSourceMapConsumer(sourceMap, aSourceMapURL);n}nnSourceMapConsumer.fromSourceMap = function(aSourceMap, aSourceMapURL) {n return BasicSourceMapConsumer.fromSourceMap(aSourceMap, aSourceMapURL);n}nn/**n * The version of the source mapping spec that we are consuming.n */nSourceMapConsumer.prototype._version = 3;nn// `__generatedMappings` and `__originalMappings` are arrays that hold then// parsed mapping coordinates from the source map's "mappings" attribute. Theyn// are lazily instantiated, accessed via the `_generatedMappings` andn// `_originalMappings` getters respectively, and we only parse the mappingsn// and create these arrays once queried for a source location. We jump throughn// these hoops because there can be many thousands of mappings, and parsingn// them is expensive, so we only want to do it if we must.n//n// Each object in the arrays is of the form:n//n// {n// generatedLine: The line number in the generated code,n// generatedColumn: The column number in the generated code,n// source: The path to the original source file that generated thisn// chunk of code,n// originalLine: The line number in the original source thatn// corresponds to this chunk of generated code,n// originalColumn: The column number in the original source thatn// corresponds to this chunk of generated code,n// name: The name of the original symbol which generated this chunk ofn// code.n// }n//n// All properties except for `generatedLine` and `generatedColumn` can ben// `null`.n//n// `_generatedMappings` is ordered by the generated positions.n//n// `_originalMappings` is ordered by the original positions.nnSourceMapConsumer.prototype.__generatedMappings = null;nObject.defineProperty(SourceMapConsumer.prototype, '_generatedMappings', {n configurable: true,n enumerable: true,n get: function () {n if (!this.__generatedMappings) {n this._parseMappings(this._mappings, this.sourceRoot);n }nn return this.__generatedMappings;n }n});nnSourceMapConsumer.prototype.__originalMappings = null;nObject.defineProperty(SourceMapConsumer.prototype, '_originalMappings', {n configurable: true,n enumerable: true,n get: function () {n if (!this.__originalMappings) {n this._parseMappings(this._mappings, this.sourceRoot);n }nn return this.__originalMappings;n }n});nnSourceMapConsumer.prototype._charIsMappingSeparator =n function SourceMapConsumer_charIsMappingSeparator(aStr, index) {n var c = aStr.charAt(index);n return c === ";" || c === ",";n };nn/**n * Parse the mappings in a string in to a data structure which we can easilyn * query (the ordered arrays in the `this.__generatedMappings` andn * `this.__originalMappings` properties).n */nSourceMapConsumer.prototype._parseMappings =n function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {n throw new Error("Subclasses must implement _parseMappings");n };nnSourceMapConsumer.GENERATED_ORDER = 1;nSourceMapConsumer.ORIGINAL_ORDER = 2;nnSourceMapConsumer.GREATEST_LOWER_BOUND = 1;nSourceMapConsumer.LEAST_UPPER_BOUND = 2;nn/**n * Iterate over each mapping between an original source/line/column and an * generated line/column in this source map.n *n * @param Function aCallbackn * The function that is called with each mapping.n * @param Object aContextn * Optional. If specified, this object will be the value of `this` everyn * time that `aCallback` is called.n * @param aOrdern * Either `SourceMapConsumer.GENERATED_ORDER` orn * `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want ton * iterate over the mappings sorted by the generated file's line/columnn * order or the original's source/line/column order, respectively. Defaults ton * `SourceMapConsumer.GENERATED_ORDER`.n */nSourceMapConsumer.prototype.eachMapping =n function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {n var context = aContext || null;n var order = aOrder || SourceMapConsumer.GENERATED_ORDER;nn var mappings;n switch (order) {n case SourceMapConsumer.GENERATED_ORDER:n mappings = this._generatedMappings;n break;n case SourceMapConsumer.ORIGINAL_ORDER:n mappings = this._originalMappings;n break;n default:n throw new Error("Unknown order of iteration.");n }nn var sourceRoot = this.sourceRoot;n mappings.map(function (mapping) {n var source = mapping.source === null ? null : this._sources.at(mapping.source);n source = util.computeSourceURL(sourceRoot, source, this._sourceMapURL);n return {n source: source,n generatedLine: mapping.generatedLine,n generatedColumn: mapping.generatedColumn,n originalLine: mapping.originalLine,n originalColumn: mapping.originalColumn,n name: mapping.name === null ? null : this._names.at(mapping.name)n };n }, this).forEach(aCallback, context);n };nn/**n * Returns all generated line and column information for the original source,n * line, and column provided. If no column is provided, returns all mappingsn * corresponding to a either the line we are searching for or the nextn * closest line that has any mappings. Otherwise, returns all mappingsn * corresponding to the given line and either the column we are searching forn * or the next closest column that has any offsets.n *n * The only argument is an object with the following properties:n *n * - source: The filename of the original source.n * - line: The line number in the original source. The line number is 1-based.n * - column: Optional. the column number in the original source.n * The column number is 0-based.n *n * and an array of objects is returned, each with the following properties:n *n * - line: The line number in the generated source, or null. Then * line number is 1-based.n * - column: The column number in the generated source, or null.n * The column number is 0-based.n */nSourceMapConsumer.prototype.allGeneratedPositionsFor =n function SourceMapConsumer_allGeneratedPositionsFor(aArgs) {n var line = util.getArg(aArgs, 'line');nn // When there is no exact match, BasicSourceMapConsumer.prototype._findMappingn // returns the index of the closest mapping less than the needle. Byn // setting needle.originalColumn to 0, we thus find the last mapping forn // the given line, provided such a mapping exists.n var needle = {n source: util.getArg(aArgs, 'source'),n originalLine: line,n originalColumn: util.getArg(aArgs, 'column', 0)n };nn needle.source = this._findSourceIndex(needle.source);n if (needle.source < 0) {n return [];n }nn var mappings = [];nn var index = this._findMapping(needle,n this._originalMappings,n "originalLine",n "originalColumn",n util.compareByOriginalPositions,n binarySearch.LEAST_UPPER_BOUND);n if (index >= 0) {n var mapping = this._originalMappings;nn if (aArgs.column === undefined) {n var originalLine = mapping.originalLine;nn // Iterate until either we run out of mappings, or we run inton // a mapping for a different line than the one we found. Sincen // mappings are sorted, this is guaranteed to find all mappings forn // the line we found.n while (mapping && mapping.originalLine === originalLine) {n mappings.push({n line: util.getArg(mapping, 'generatedLine', null),n column: util.getArg(mapping, 'generatedColumn', null),n lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)n });nn mapping = this._originalMappings;n }n } else {n var originalColumn = mapping.originalColumn;nn // Iterate until either we run out of mappings, or we run inton // a mapping for a different line than the one we were searching for.n // Since mappings are sorted, this is guaranteed to find all mappings forn // the line we are searching for.n while (mapping &&n mapping.originalLine === line &&n mapping.originalColumn == originalColumn) {n mappings.push({n line: util.getArg(mapping, 'generatedLine', null),n column: util.getArg(mapping, 'generatedColumn', null),n lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)n });nn mapping = this._originalMappings;n }n }n }nn return mappings;n };nnexports.SourceMapConsumer = SourceMapConsumer;nn/**n * A BasicSourceMapConsumer instance represents a parsed source map which we cann * query for information about the original file positions by giving it a filen * position in the generated source.n *n * The first parameter is the raw source map (either as a JSON string, orn * already parsed to an object). According to the spec, source maps have then * following attributes:n *n * - version: Which version of the source map spec this map is following.n * - sources: An array of URLs to the original source files.n * - names: An array of identifiers which can be referrenced by individual mappings.n * - sourceRoot: Optional. The URL root from which all sources are relative.n * - sourcesContent: Optional. An array of contents of the original source files.n * - mappings: A string of base64 VLQs which contain the actual mappings.n * - file: Optional. The generated file this source map is associated with.n *n * Here is an example source map, taken from the source map spec:n *n * {n * version : 3,n * file: "out.js",n * sourceRoot : "",n * sources: ["foo.js", "bar.js"],n * names: ["src", "maps", "are", "fun"],n * mappings: "AA,AB;;ABCDE;"n * }n *n * The second parameter, if given, is a string whose value is the URLn * at which the source map was found. This URL is used to compute then * sources array.n *n * [0]: docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit?pli=1#n */nfunction BasicSourceMapConsumer(aSourceMap, aSourceMapURL) {n var sourceMap = aSourceMap;n if (typeof aSourceMap === 'string') {n sourceMap = util.parseSourceMapInput(aSourceMap);n }nn var version = util.getArg(sourceMap, 'version');n var sources = util.getArg(sourceMap, 'sources');n // Sass 3.3 leaves out the 'names' array, so we deviate from the spec (whichn // requires the array) to play nice here.n var names = util.getArg(sourceMap, 'names', []);n var sourceRoot = util.getArg(sourceMap, 'sourceRoot', null);n var sourcesContent = util.getArg(sourceMap, 'sourcesContent', null);n var mappings = util.getArg(sourceMap, 'mappings');n var file = util.getArg(sourceMap, 'file', null);nn // Once again, Sass deviates from the spec and supplies the version as an // string rather than a number, so we use loose equality checking here.n if (version != this._version) {n throw new Error('Unsupported version: ' + version);n }nn if (sourceRoot) {n sourceRoot = util.normalize(sourceRoot);n }nn sources = sourcesn .map(String)n // Some source maps produce relative source paths like "./foo.js" instead ofn // "foo.js". Normalize these first so that future comparisons will succeed.n // See bugzil.la/1090768.n .map(util.normalize)n // Always ensure that absolute sources are internally stored relative ton // the source root, if the source root is absolute. Not doing this wouldn // be particularly problematic when the source root is a prefix of then // source (valid, but why??). See github issue #199 and bugzil.la/1188982.n .map(function (source) {n return sourceRoot && util.isAbsolute(sourceRoot) && util.isAbsolute(source)n ? util.relative(sourceRoot, source)n : source;n });nn // Pass `true` below to allow duplicate names and sources. While source mapsn // are intended to be compressed and deduplicated, the TypeScript compilern // sometimes generates source maps with duplicates in them. See Github issuen // #72 and bugzil.la/889492.n this._names = ArraySet.fromArray(names.map(String), true);n this._sources = ArraySet.fromArray(sources, true);nn this._absoluteSources = this._sources.toArray().map(function (s) {n return util.computeSourceURL(sourceRoot, s, aSourceMapURL);n });nn this.sourceRoot = sourceRoot;n this.sourcesContent = sourcesContent;n this._mappings = mappings;n this._sourceMapURL = aSourceMapURL;n this.file = file;n}nnBasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);nBasicSourceMapConsumer.prototype.consumer = SourceMapConsumer;nn/**n * Utility function to find the index of a source. Returns -1 if notn * found.n */nBasicSourceMapConsumer.prototype._findSourceIndex = function(aSource) {n var relativeSource = aSource;n if (this.sourceRoot != null) {n relativeSource = util.relative(this.sourceRoot, relativeSource);n }nn if (this._sources.has(relativeSource)) {n return this._sources.indexOf(relativeSource);n }nn // Maybe aSource is an absolute URL as returned by |sources|. Inn // this case we can't simply undo the transform.n var i;n for (i = 0; i < this._absoluteSources.length; ++i) {n if (this._absoluteSources == aSource) {n return i;n }n }nn return -1;n};nn/**n * Create a BasicSourceMapConsumer from a SourceMapGenerator.n *n * @param SourceMapGenerator aSourceMapn * The source map that will be consumed.n * @param String aSourceMapURLn * The URL at which the source map can be found (optional)n * @returns BasicSourceMapConsumern */nBasicSourceMapConsumer.fromSourceMap =n function SourceMapConsumer_fromSourceMap(aSourceMap, aSourceMapURL) {n var smc = Object.create(BasicSourceMapConsumer.prototype);nn var names = smc._names = ArraySet.fromArray(aSourceMap._names.toArray(), true);n var sources = smc._sources = ArraySet.fromArray(aSourceMap._sources.toArray(), true);n smc.sourceRoot = aSourceMap._sourceRoot;n smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(),n smc.sourceRoot);n smc.file = aSourceMap._file;n smc._sourceMapURL = aSourceMapURL;n smc._absoluteSources = smc._sources.toArray().map(function (s) {n return util.computeSourceURL(smc.sourceRoot, s, aSourceMapURL);n });nn // Because we are modifying the entries (by converting string sources andn // names to indices into the sources and names ArraySets), we have to maken // a copy of the entry or else bad things happen. Shared mutable staten // strikes again! See github issue #191.nn var generatedMappings = aSourceMap._mappings.toArray().slice();n var destGeneratedMappings = smc.__generatedMappings = [];n var destOriginalMappings = smc.__originalMappings = [];nn for (var i = 0, length = generatedMappings.length; i < length; i++) {n var srcMapping = generatedMappings;n var destMapping = new Mapping;n destMapping.generatedLine = srcMapping.generatedLine;n destMapping.generatedColumn = srcMapping.generatedColumn;nn if (srcMapping.source) {n destMapping.source = sources.indexOf(srcMapping.source);n destMapping.originalLine = srcMapping.originalLine;n destMapping.originalColumn = srcMapping.originalColumn;nn if (srcMapping.name) {n destMapping.name = names.indexOf(srcMapping.name);n }nn destOriginalMappings.push(destMapping);n }nn destGeneratedMappings.push(destMapping);n }nn quickSort(smc.__originalMappings, util.compareByOriginalPositions);nn return smc;n };nn/**n * The version of the source mapping spec that we are consuming.n */nBasicSourceMapConsumer.prototype._version = 3;nn/**n * The list of original sources.n */nObject.defineProperty(BasicSourceMapConsumer.prototype, 'sources', {n get: function () {n return this._absoluteSources.slice();n }n});nn/**n * Provide the JIT with a nice shape / hidden class.n */nfunction Mapping() {n this.generatedLine = 0;n this.generatedColumn = 0;n this.source = null;n this.originalLine = null;n this.originalColumn = null;n this.name = null;n}nn/**n * Parse the mappings in a string in to a data structure which we can easilyn * query (the ordered arrays in the `this.__generatedMappings` andn * `this.__originalMappings` properties).n */nBasicSourceMapConsumer.prototype._parseMappings =n function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {n var generatedLine = 1;n var previousGeneratedColumn = 0;n var previousOriginalLine = 0;n var previousOriginalColumn = 0;n var previousSource = 0;n var previousName = 0;n var length = aStr.length;n var index = 0;n var cachedSegments = {};n var temp = {};n var originalMappings = [];n var generatedMappings = [];n var mapping, str, segment, end, value;nn while (index < length) {n if (aStr.charAt(index) === ';') {n generatedLine++;n index++;n previousGeneratedColumn = 0;n }n else if (aStr.charAt(index) === ',') {n index++;n }n else {n mapping = new Mapping();n mapping.generatedLine = generatedLine;nn // Because each offset is encoded relative to the previous one,n // many segments often have the same encoding. We can exploit thisn // fact by caching the parsed variable length fields of each segment,n // allowing us to avoid a second parse if we encounter the samen // segment again.n for (end = index; end < length; end++) {n if (this._charIsMappingSeparator(aStr, end)) {n break;n }n }n str = aStr.slice(index, end);nn segment = cachedSegments;n if (segment) {n index += str.length;n } else {n segment = [];n while (index < end) {n base64VLQ.decode(aStr, index, temp);n value = temp.value;n index = temp.rest;n segment.push(value);n }nn if (segment.length === 2) {n throw new Error('Found a source, but no line and column');n }nn if (segment.length === 3) {n throw new Error('Found a source and line, but no column');n }nn cachedSegments = segment;n }nn // Generated column.n mapping.generatedColumn = previousGeneratedColumn + segment;n previousGeneratedColumn = mapping.generatedColumn;nn if (segment.length > 1) {n // Original source.n mapping.source = previousSource + segment;n previousSource += segment;nn // Original line.n mapping.originalLine = previousOriginalLine + segment;n previousOriginalLine = mapping.originalLine;n // Lines are stored 0-basedn mapping.originalLine += 1;nn // Original column.n mapping.originalColumn = previousOriginalColumn + segment;n previousOriginalColumn = mapping.originalColumn;nn if (segment.length > 4) {n // Original name.n mapping.name = previousName + segment;n previousName += segment;n }n }nn generatedMappings.push(mapping);n if (typeof mapping.originalLine === 'number') {n originalMappings.push(mapping);n }n }n }nn quickSort(generatedMappings, util.compareByGeneratedPositionsDeflated);n this.__generatedMappings = generatedMappings;nn quickSort(originalMappings, util.compareByOriginalPositions);n this.__originalMappings = originalMappings;n };nn/**n * Find the mapping that best matches the hypothetical "needle" mapping thatn * we are searching for in the given "haystack" of mappings.n */nBasicSourceMapConsumer.prototype._findMapping =n function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName,n aColumnName, aComparator, aBias) {n // To return the position we are searching for, we must first find then // mapping for the given position and then return the opposite position itn // points to. Because the mappings are sorted, we can use binary search ton // find the best mapping.nn if (aNeedle <= 0) {n throw new TypeError('Line must be greater than or equal to 1, got 'n + aNeedle);n }n if (aNeedle < 0) {n throw new TypeError('Column must be greater than or equal to 0, got 'n + aNeedle);n }nn return binarySearch.search(aNeedle, aMappings, aComparator, aBias);n };nn/**n * Compute the last column for each generated mapping. The last column isn * inclusive.n */nBasicSourceMapConsumer.prototype.computeColumnSpans =n function SourceMapConsumer_computeColumnSpans() {n for (var index = 0; index < this._generatedMappings.length; ++index) {n var mapping = this._generatedMappings;nn // Mappings do not contain a field for the last generated columnt. Wen // can come up with an optimistic estimate, however, by assuming thatn // mappings are contiguous (i.e. given two consecutive mappings, then // first mapping ends where the second one starts).n if (index + 1 < this._generatedMappings.length) {n var nextMapping = this._generatedMappings[index + 1];nn if (mapping.generatedLine === nextMapping.generatedLine) {n mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1;n continue;n }n }nn // The last mapping for each line spans the entire line.n mapping.lastGeneratedColumn = Infinity;n }n };nn/**n * Returns the original source, line, and column information for the generatedn * source's line and column positions provided. The only argument is an objectn * with the following properties:n *n * - line: The line number in the generated source. The line numbern * is 1-based.n * - column: The column number in the generated source. The columnn * number is 0-based.n * - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' orn * 'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return then * closest element that is smaller than or greater than the one we aren * searching for, respectively, if the exact element cannot be found.n * Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.n *n * and an object is returned with the following properties:n *n * - source: The original source file, or null.n * - line: The line number in the original source, or null. Then * line number is 1-based.n * - column: The column number in the original source, or null. Then * column number is 0-based.n * - name: The original identifier, or null.n */nBasicSourceMapConsumer.prototype.originalPositionFor =n function SourceMapConsumer_originalPositionFor(aArgs) {n var needle = {n generatedLine: util.getArg(aArgs, 'line'),n generatedColumn: util.getArg(aArgs, 'column')n };nn var index = this._findMapping(n needle,n this._generatedMappings,n "generatedLine",n "generatedColumn",n util.compareByGeneratedPositionsDeflated,n util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)n );nn if (index >= 0) {n var mapping = this._generatedMappings;nn if (mapping.generatedLine === needle.generatedLine) {n var source = util.getArg(mapping, 'source', null);n if (source !== null) {n source = this._sources.at(source);n source = util.computeSourceURL(this.sourceRoot, source, this._sourceMapURL);n }n var name = util.getArg(mapping, 'name', null);n if (name !== null) {n name = this._names.at(name);n }n return {n source: source,n line: util.getArg(mapping, 'originalLine', null),n column: util.getArg(mapping, 'originalColumn', null),n name: namen };n }n }nn return {n source: null,n line: null,n column: null,n name: nulln };n };nn/**n * Return true if we have the source content for every source in the sourcen * map, false otherwise.n */nBasicSourceMapConsumer.prototype.hasContentsOfAllSources =n function BasicSourceMapConsumer_hasContentsOfAllSources() {n if (!this.sourcesContent) {n return false;n }n return this.sourcesContent.length >= this._sources.size() &&n !this.sourcesContent.some(function (sc) { return sc == null; });n };nn/**n * Returns the original source content. The only argument is the url of then * original source file. Returns null if no original source content isn * available.n */nBasicSourceMapConsumer.prototype.sourceContentFor =n function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {n if (!this.sourcesContent) {n return null;n }nn var index = this._findSourceIndex(aSource);n if (index >= 0) {n return this.sourcesContent;n }nn var relativeSource = aSource;n if (this.sourceRoot != null) {n relativeSource = util.relative(this.sourceRoot, relativeSource);n }nn var url;n if (this.sourceRoot != nulln && (url = util.urlParse(this.sourceRoot))) {n // XXX: file:// URIs and absolute paths lead to unexpected behavior forn // many users. We can help them out when they expect file:// URIs ton // behave like it would if they were running a local HTTP server. Seen // bugzilla.mozilla.org/show_bug.cgi?id=885597.n var fileUriAbsPath = relativeSource.replace(/^file:\/\//, "");n if (url.scheme == "file"n && this._sources.has(fileUriAbsPath)) {n return this.sourcesContentn }nn if ((!url.path || url.path == "/")n && this._sources.has("/" + relativeSource)) {n return this.sourcesContent[this._sources.indexOf("/" + relativeSource)];n }n }nn // This function is used recursively fromn // IndexedSourceMapConsumer.prototype.sourceContentFor. In that case, wen // don't want to throw if we can't find the source - we just want ton // return null, so we provide a flag to exit gracefully.n if (nullOnMissing) {n return null;n }n else {n throw new Error('"' + relativeSource + '" is not in the SourceMap.');n }n };nn/**n * Returns the generated line and column information for the original source,n * line, and column positions provided. The only argument is an object withn * the following properties:n *n * - source: The filename of the original source.n * - line: The line number in the original source. The line numbern * is 1-based.n * - column: The column number in the original source. The columnn * number is 0-based.n * - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' orn * 'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return then * closest element that is smaller than or greater than the one we aren * searching for, respectively, if the exact element cannot be found.n * Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.n *n * and an object is returned with the following properties:n *n * - line: The line number in the generated source, or null. Then * line number is 1-based.n * - column: The column number in the generated source, or null.n * The column number is 0-based.n */nBasicSourceMapConsumer.prototype.generatedPositionFor =n function SourceMapConsumer_generatedPositionFor(aArgs) {n var source = util.getArg(aArgs, 'source');n source = this._findSourceIndex(source);n if (source < 0) {n return {n line: null,n column: null,n lastColumn: nulln };n }nn var needle = {n source: source,n originalLine: util.getArg(aArgs, 'line'),n originalColumn: util.getArg(aArgs, 'column')n };nn var index = this._findMapping(n needle,n this._originalMappings,n "originalLine",n "originalColumn",n util.compareByOriginalPositions,n util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)n );nn if (index >= 0) {n var mapping = this._originalMappings;nn if (mapping.source === needle.source) {n return {n line: util.getArg(mapping, 'generatedLine', null),n column: util.getArg(mapping, 'generatedColumn', null),n lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)n };n }n }nn return {n line: null,n column: null,n lastColumn: nulln };n };nnexports.BasicSourceMapConsumer = BasicSourceMapConsumer;nn/**n * An IndexedSourceMapConsumer instance represents a parsed source map whichn * we can query for information. It differs from BasicSourceMapConsumer inn * that it takes "indexed" source maps (i.e. ones with a "sections" field) asn * input.n *n * The first parameter is a raw source map (either as a JSON string, or alreadyn * parsed to an object). According to the spec for indexed source maps, theyn * have the following attributes:n *n * - version: Which version of the source map spec this map is following.n * - file: Optional. The generated file this source map is associated with.n * - sections: A list of section definitions.n *n * Each value under the "sections" field has two fields:n * - offset: The offset into the original specified at which this sectionn * begins to apply, defined as an object with a "line" and "column"n * field.n * - map: A source map definition. This source map could also be indexed,n * but doesn't have to be.n *n * Instead of the "map" field, it's also possible to have a "url" fieldn * specifying a URL to retrieve a source map from, but that's currentlyn * unsupported.n *n * Here's an example source map, taken from the source map spec, butn * modified to omit a section which uses the "url" field.n *n * {n * version : 3,n * file: "app.js",n * sections: [{n * offset: {line:100, column:10},n * map: {n * version : 3,n * file: "section.js",n * sources: ["foo.js", "bar.js"],n * names: ["src", "maps", "are", "fun"],n * mappings: "AAAA,E;;ABCDE;"n * }n * }],n * }n *n * The second parameter, if given, is a string whose value is the URLn * at which the source map was found. This URL is used to compute then * sources array.n *n * [0]: docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit#heading=h.535es3xeprgtn */nfunction IndexedSourceMapConsumer(aSourceMap, aSourceMapURL) {n var sourceMap = aSourceMap;n if (typeof aSourceMap === 'string') {n sourceMap = util.parseSourceMapInput(aSourceMap);n }nn var version = util.getArg(sourceMap, 'version');n var sections = util.getArg(sourceMap, 'sections');nn if (version != this._version) {n throw new Error('Unsupported version: ' + version);n }nn this._sources = new ArraySet();n this._names = new ArraySet();nn var lastOffset = {n line: -1,n column: 0n };n this._sections = sections.map(function (s) {n if (s.url) {n // The url field will require support for asynchronicity.n // See github.com/mozilla/source-map/issues/16n throw new Error('Support for url field in sections not implemented.');n }n var offset = util.getArg(s, 'offset');n var offsetLine = util.getArg(offset, 'line');n var offsetColumn = util.getArg(offset, 'column');nn if (offsetLine < lastOffset.line ||n (offsetLine === lastOffset.line && offsetColumn < lastOffset.column)) {n throw new Error('Section offsets must be ordered and non-overlapping.');n }n lastOffset = offset;nn return {n generatedOffset: {n // The offset fields are 0-based, but we use 1-based indices whenn // encoding/decoding from VLQ.n generatedLine: offsetLine + 1,n generatedColumn: offsetColumn + 1n },n consumer: new SourceMapConsumer(util.getArg(s, 'map'), aSourceMapURL)n }n });n}nnIndexedSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);nIndexedSourceMapConsumer.prototype.constructor = SourceMapConsumer;nn/**n * The version of the source mapping spec that we are consuming.n */nIndexedSourceMapConsumer.prototype._version = 3;nn/**n * The list of original sources.n */nObject.defineProperty(IndexedSourceMapConsumer.prototype, 'sources', {n get: function () {n var sources = [];n for (var i = 0; i < this._sections.length; i++) {n for (var j = 0; j < this._sections.consumer.sources.length; j++) {n sources.push(this._sections.consumer.sources);n }n }n return sources;n }n});nn/**n * Returns the original source, line, and column information for the generatedn * source's line and column positions provided. The only argument is an objectn * with the following properties:n *n * - line: The line number in the generated source. The line numbern * is 1-based.n * - column: The column number in the generated source. The columnn * number is 0-based.n *n * and an object is returned with the following properties:n *n * - source: The original source file, or null.n * - line: The line number in the original source, or null. Then * line number is 1-based.n * - column: The column number in the original source, or null. Then * column number is 0-based.n * - name: The original identifier, or null.n */nIndexedSourceMapConsumer.prototype.originalPositionFor =n function IndexedSourceMapConsumer_originalPositionFor(aArgs) {n var needle = {n generatedLine: util.getArg(aArgs, 'line'),n generatedColumn: util.getArg(aArgs, 'column')n };nn // Find the section containing the generated position we're trying to mapn // to an original position.n var sectionIndex = binarySearch.search(needle, this._sections,n function(needle, section) {n var cmp = needle.generatedLine - section.generatedOffset.generatedLine;n if (cmp) {n return cmp;n }nn return (needle.generatedColumn -n section.generatedOffset.generatedColumn);n });n var section = this._sections;nn if (!section) {n return {n source: null,n line: null,n column: null,n name: nulln };n }nn return section.consumer.originalPositionFor({n line: needle.generatedLine -n (section.generatedOffset.generatedLine - 1),n column: needle.generatedColumn -n (section.generatedOffset.generatedLine === needle.generatedLinen ? section.generatedOffset.generatedColumn - 1n : 0),n bias: aArgs.biasn });n };nn/**n * Return true if we have the source content for every source in the sourcen * map, false otherwise.n */nIndexedSourceMapConsumer.prototype.hasContentsOfAllSources =n function IndexedSourceMapConsumer_hasContentsOfAllSources() {n return this._sections.every(function (s) {n return s.consumer.hasContentsOfAllSources();n });n };nn/**n * Returns the original source content. The only argument is the url of then * original source file. Returns null if no original source content isn * available.n */nIndexedSourceMapConsumer.prototype.sourceContentFor =n function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {n for (var i = 0; i < this._sections.length; i++) {n var section = this._sections;nn var content = section.consumer.sourceContentFor(aSource, true);n if (content) {n return content;n }n }n if (nullOnMissing) {n return null;n }n else {n throw new Error('"' + aSource + '" is not in the SourceMap.');n }n };nn/**n * Returns the generated line and column information for the original source,n * line, and column positions provided. The only argument is an object withn * the following properties:n *n * - source: The filename of the original source.n * - line: The line number in the original source. The line numbern * is 1-based.n * - column: The column number in the original source. The columnn * number is 0-based.n *n * and an object is returned with the following properties:n *n * - line: The line number in the generated source, or null. Then * line number is 1-based. n * - column: The column number in the generated source, or null.n * The column number is 0-based.n */nIndexedSourceMapConsumer.prototype.generatedPositionFor =n function IndexedSourceMapConsumer_generatedPositionFor(aArgs) {n for (var i = 0; i < this._sections.length; i++) {n var section = this._sections;nn // Only consider this section if the requested source is in the list ofn // sources of the consumer.n if (section.consumer._findSourceIndex(util.getArg(aArgs, 'source')) === -1) {n continue;n }n var generatedPosition = section.consumer.generatedPositionFor(aArgs);n if (generatedPosition) {n var ret = {n line: generatedPosition.line +n (section.generatedOffset.generatedLine - 1),n column: generatedPosition.column +n (section.generatedOffset.generatedLine === generatedPosition.linen ? section.generatedOffset.generatedColumn - 1n : 0)n };n return ret;n }n }nn return {n line: null,n column: nulln };n };nn/**n * Parse the mappings in a string in to a data structure which we can easilyn * query (the ordered arrays in the `this.__generatedMappings` andn * `this.__originalMappings` properties).n */nIndexedSourceMapConsumer.prototype._parseMappings =n function IndexedSourceMapConsumer_parseMappings(aStr, aSourceRoot) {n this.__generatedMappings = [];n this.__originalMappings = [];n for (var i = 0; i < this._sections.length; i++) {n var section = this._sections;n var sectionMappings = section.consumer._generatedMappings;n for (var j = 0; j < sectionMappings.length; j++) {n var mapping = sectionMappings;nn var source = section.consumer._sources.at(mapping.source);n source = util.computeSourceURL(section.consumer.sourceRoot, source, this._sourceMapURL);n this._sources.add(source);n source = this._sources.indexOf(source);nn var name = null;n if (mapping.name) {n name = section.consumer._names.at(mapping.name);n this._names.add(name);n name = this._names.indexOf(name);n }nn // The mappings coming from the consumer for the section haven // generated positions relative to the start of the section, so wen // need to offset them to be relative to the start of the concatenatedn // generated file.n var adjustedMapping = {n source: source,n generatedLine: mapping.generatedLine +n (section.generatedOffset.generatedLine - 1),n generatedColumn: mapping.generatedColumn +n (section.generatedOffset.generatedLine === mapping.generatedLinen ? section.generatedOffset.generatedColumn - 1n : 0),n originalLine: mapping.originalLine,n originalColumn: mapping.originalColumn,n name: namen };nn this.__generatedMappings.push(adjustedMapping);n if (typeof adjustedMapping.originalLine === 'number') {n this.__originalMappings.push(adjustedMapping);n }n }n }nn quickSort(this.__generatedMappings, util.compareByGeneratedPositionsDeflated);n quickSort(this.__originalMappings, util.compareByOriginalPositions);n };nnexports.IndexedSourceMapConsumer = IndexedSourceMapConsumer;nnnn//////////////////n// WEBPACK FOOTERn// ./lib/source-map-consumer.jsn// module id = 7n// module chunks = 0”,“/* -*- Mode: js; js-indent-level: 2; -*- */n/*n * Copyright 2011 Mozilla Foundation and contributorsn * Licensed under the New BSD license. See LICENSE or:n * opensource.org/licenses/BSD-3-Clausen */nnexports.GREATEST_LOWER_BOUND = 1;nexports.LEAST_UPPER_BOUND = 2;nn/**n * Recursive implementation of binary search.n *n * @param aLow Indices here and lower do not contain the needle.n * @param aHigh Indices here and higher do not contain the needle.n * @param aNeedle The element being searched for.n * @param aHaystack The non-empty array being searched.n * @param aCompare Function which takes two elements and returns -1, 0, or 1.n * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' orn * 'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return then * closest element that is smaller than or greater than the one we aren * searching for, respectively, if the exact element cannot be found.n */nfunction recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare, aBias) {n // This function terminates when one of the following is true:n //n // 1. We find the exact element we are looking for.n //n // 2. We did not find the exact element, but we can return the index ofn // the next-closest element.n //n // 3. We did not find the exact element, and there is no next-closestn // element than the one we are searching for, so we return -1.n var mid = Math.floor((aHigh - aLow) / 2) + aLow;n var cmp = aCompare(aNeedle, aHaystack, true);n if (cmp === 0) {n // Found the element we are looking for.n return mid;n }n else if (cmp > 0) {n // Our needle is greater than aHaystack.n if (aHigh - mid > 1) {n // The element is in the upper half.n return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias);n }nn // The exact needle element was not found in this haystack. Determine ifn // we are in termination case (3) or (2) and return the appropriate thing.n if (aBias == exports.LEAST_UPPER_BOUND) {n return aHigh < aHaystack.length ? aHigh : -1;n } else {n return mid;n }n }n else {n // Our needle is less than aHaystack.n if (mid - aLow > 1) {n // The element is in the lower half.n return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias);n }nn // we are in termination case (3) or (2) and return the appropriate thing.n if (aBias == exports.LEAST_UPPER_BOUND) {n return mid;n } else {n return aLow < 0 ? -1 : aLow;n }n }n}nn/**n * This is an implementation of binary search which will always try and returnn * the index of the closest element if there is no exact hit. This is becausen * mappings between original and generated line/col pairs are single points,n * and there is an implicit region between each of them, so a miss just meansn * that you aren't on the very start of a region.n *n * @param aNeedle The element you are looking for.n * @param aHaystack The array that is being searched.n * @param aCompare A function which takes the needle and an element in then * array and returns -1, 0, or 1 depending on whether the needle is lessn * than, equal to, or greater than the element, respectively.n * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' orn * 'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return then * closest element that is smaller than or greater than the one we aren * searching for, respectively, if the exact element cannot be found.n * Defaults to 'binarySearch.GREATEST_LOWER_BOUND'.n */nexports.search = function search(aNeedle, aHaystack, aCompare, aBias) {n if (aHaystack.length === 0) {n return -1;n }nn var index = recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack,n aCompare, aBias || exports.GREATEST_LOWER_BOUND);n if (index < 0) {n return -1;n }nn // We have found either the exact element, or the next-closest element thann // the one we are searching for. However, there may be more than one suchn // element. Make sure we always return the smallest of these.n while (index - 1 >= 0) {n if (aCompare(aHaystack, aHaystack[index - 1], true) !== 0) {n break;n }n –index;n }nn return index;n};nnnn//////////////////n// WEBPACK FOOTERn// ./lib/binary-search.jsn// module id = 8n// module chunks = 0”,“/* -*- Mode: js; js-indent-level: 2; -*- */n/*n * Copyright 2011 Mozilla Foundation and contributorsn * Licensed under the New BSD license. See LICENSE or:n * opensource.org/licenses/BSD-3-Clausen */nn// It turns out that some (most?) JavaScript engines don't self-hostn// `Array.prototype.sort`. This makes sense because C++ will likely remainn// faster than JS when doing raw CPU-intensive sorting. However, when using an// custom comparator function, calling back and forth between the VM's C++ andn// JIT'd JS is rather slow and loses JIT type information, resulting inn// worse generated code for the comparator function than would be optimal. Inn// fact, when sorting with a comparator, these costs outweigh the benefits ofn// sorting in C++. By using our own JS-implemented Quick Sort (below), we getn// a ~3500ms mean speed-up in `bench/bench.html`.nn/**n * Swap the elements indexed by `x` and `y` in the array `ary`.n *n * @param {Array} aryn * The array.n * @param {Number} xn * The index of the first item.n * @param {Number} yn * The index of the second item.n */nfunction swap(ary, x, y) {n var temp = ary;n ary = ary;n ary = temp;n}nn/**n * Returns a random integer within the range `low .. high` inclusive.n *n * @param {Number} lown * The lower bound on the range.n * @param {Number} highn * The upper bound on the range.n */nfunction randomIntInRange(low, high) {n return Math.round(low + (Math.random() * (high - low)));n}nn/**n * The Quick Sort algorithm.n *n * @param {Array} aryn * An array to sort.n * @param {function} comparatorn * Function to use to compare two items.n * @param {Number} pn * Start index of the arrayn * @param {Number} rn * End index of the arrayn */nfunction doQuickSort(ary, comparator, p, r) {n // If our lower bound is less than our upper bound, we (1) partition then // array into two pieces and (2) recurse on each half. If it is not, this isn // the empty array and our base case.nn if (p < r) {n // (1) Partitioning.n //n // The partitioning chooses a pivot between `p` and `r` and moves alln // elements that are less than or equal to the pivot to the before it, andn // all the elements that are greater than it after it. The effect is thatn // once partition is done, the pivot is in the exact place it will be whenn // the array is put in sorted order, and it will not need to be movedn // again. This runs in O(n) time.nn // Always choose a random pivot so that an input array which is reversen // sorted does not cause O(n^2) running time.n var pivotIndex = randomIntInRange(p, r);n var i = p - 1;nn swap(ary, pivotIndex, r);n var pivot = ary;nn // Immediately after `j` is incremented in this loop, the following holdn // true:n //n // * Every element in `ary[p .. i]` is less than or equal to the pivot.n //n // * Every element in `ary[i+1 .. j-1]` is greater than the pivot.n for (var j = p; j < r; j++) {n if (comparator(ary, pivot) <= 0) {n i += 1;n swap(ary, i, j);n }n }nn swap(ary, i + 1, j);n var q = i + 1;nn // (2) Recurse on each half.nn doQuickSort(ary, comparator, p, q - 1);n doQuickSort(ary, comparator, q + 1, r);n }n}nn/**n * Sort the given array in-place with the given comparator function.n *n * @param {Array} aryn * An array to sort.n * @param {function} comparatorn * Function to use to compare two items.n */nexports.quickSort = function (ary, comparator) {n doQuickSort(ary, comparator, 0, ary.length - 1);n};nnnn//////////////////n// WEBPACK FOOTERn// ./lib/quick-sort.jsn// module id = 9n// module chunks = 0”,“/* -*- Mode: js; js-indent-level: 2; -*- */n/*n * Copyright 2011 Mozilla Foundation and contributorsn * Licensed under the New BSD license. See LICENSE or:n * opensource.org/licenses/BSD-3-Clausen */nnvar SourceMapGenerator = require('./source-map-generator').SourceMapGenerator;nvar util = require('./util');nn// Matches a Windows-style `\r\n` newline or a `\n` newline used by all othern// operating systems these days (capturing the result).nvar REGEX_NEWLINE = /(\r?\n)/;nn// Newline character code for charCodeAt() comparisonsnvar NEWLINE_CODE = 10;nn// Private symbol for identifying `SourceNode`s when multiple versions ofn// the source-map library are loaded. This MUST NOT CHANGE acrossn// versions!nvar isSourceNode = "$$$isSourceNode$$$";nn/**n * SourceNodes provide a way to abstract over interpolating/concatenatingn * snippets of generated JavaScript source code while maintaining the line andn * column information associated with the original source code.n *n * @param aLine The original line number.n * @param aColumn The original column number.n * @param aSource The original source's filename.n * @param aChunks Optional. An array of strings which are snippets ofn * generated JS, or other SourceNodes.n * @param aName The original identifier.n */nfunction SourceNode(aLine, aColumn, aSource, aChunks, aName) {n this.children = [];n this.sourceContents = {};n this.line = aLine == null ? null : aLine;n this.column = aColumn == null ? null : aColumn;n this.source = aSource == null ? null : aSource;n this.name = aName == null ? null : aName;n this = true;n if (aChunks != null) this.add(aChunks);n}nn/**n * Creates a SourceNode from generated code and a SourceMapConsumer.n *n * @param aGeneratedCode The generated coden * @param aSourceMapConsumer The SourceMap for the generated coden * @param aRelativePath Optional. The path that relative sources in then * SourceMapConsumer should be relative to.n */nSourceNode.fromStringWithSourceMap =n function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {n // The SourceNode we want to fill with the generated coden // and the SourceMapn var node = new SourceNode();nn // All even indices of this array are one line of the generated code,n // while all odd indices are the newlines between two adjacent linesn // (since `REGEX_NEWLINE` captures its match).n // Processed fragments are accessed by calling `shiftNextLine`.n var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);n var remainingLinesIndex = 0;n var shiftNextLine = function() {n var lineContents = getNextLine();n // The last line of a file might not have a newline.n var newLine = getNextLine() || "";n return lineContents + newLine;nn function getNextLine() {n return remainingLinesIndex < remainingLines.length ?n remainingLines : undefined;n }n };nn // We need to remember the position of "remainingLines"n var lastGeneratedLine = 1, lastGeneratedColumn = 0;nn // The generate SourceNodes we need a code range.n // To extract it current and last mapping is used.n // Here we store the last mapping.n var lastMapping = null;nn aSourceMapConsumer.eachMapping(function (mapping) {n if (lastMapping !== null) {n // We add the code from "lastMapping" to "mapping":n // First check if there is a new line in between.n if (lastGeneratedLine < mapping.generatedLine) {n // Associate first line with "lastMapping"n addMappingWithCode(lastMapping, shiftNextLine());n lastGeneratedLine++;n lastGeneratedColumn = 0;n // The remaining code is added without mappingn } else {n // There is no new line in between.n // Associate the code between "lastGeneratedColumn" andn // "mapping.generatedColumn" with "lastMapping"n var nextLine = remainingLines || '';n var code = nextLine.substr(0, mapping.generatedColumn -n lastGeneratedColumn);n remainingLines = nextLine.substr(mapping.generatedColumn -n lastGeneratedColumn);n lastGeneratedColumn = mapping.generatedColumn;n addMappingWithCode(lastMapping, code);n // No more remaining code, continuen lastMapping = mapping;n return;n }n }n // We add the generated code until the first mappingn // to the SourceNode without any mapping.n // Each line is added as separate string.n while (lastGeneratedLine < mapping.generatedLine) {n node.add(shiftNextLine());n lastGeneratedLine++;n }n if (lastGeneratedColumn < mapping.generatedColumn) {n var nextLine = remainingLines || '';n node.add(nextLine.substr(0, mapping.generatedColumn));n remainingLines = nextLine.substr(mapping.generatedColumn);n lastGeneratedColumn = mapping.generatedColumn;n }n lastMapping = mapping;n }, this);n // We have processed all mappings.n if (remainingLinesIndex < remainingLines.length) {n if (lastMapping) {n // Associate the remaining code in the current line with "lastMapping"n addMappingWithCode(lastMapping, shiftNextLine());n }n // and add the remaining lines without any mappingn node.add(remainingLines.splice(remainingLinesIndex).join(""));n }nn // Copy sourcesContent into SourceNoden aSourceMapConsumer.sources.forEach(function (sourceFile) {n var content = aSourceMapConsumer.sourceContentFor(sourceFile);n if (content != null) {n if (aRelativePath != null) {n sourceFile = util.join(aRelativePath, sourceFile);n }n node.setSourceContent(sourceFile, content);n }n });nn return node;nn function addMappingWithCode(mapping, code) {n if (mapping === null || mapping.source === undefined) {n node.add(code);n } else {n var source = aRelativePathn ? util.join(aRelativePath, mapping.source)n : mapping.source;n node.add(new SourceNode(mapping.originalLine,n mapping.originalColumn,n source,n code,n mapping.name));n }n }n };nn/**n * Add a chunk of generated JS to this source node.n *n * @param aChunk A string snippet of generated JS code, another instance ofn * SourceNode, or an array where each member is one of those things.n */nSourceNode.prototype.add = function SourceNode_add(aChunk) {n if (Array.isArray(aChunk)) {n aChunk.forEach(function (chunk) {n this.add(chunk);n }, this);n }n else if (aChunk || typeof aChunk === "string") {n if (aChunk) {n this.children.push(aChunk);n }n }n else {n throw new TypeError(n "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunkn );n }n return this;n};nn/**n * Add a chunk of generated JS to the beginning of this source node.n *n * @param aChunk A string snippet of generated JS code, another instance ofn * SourceNode, or an array where each member is one of those things.n */nSourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {n if (Array.isArray(aChunk)) {n for (var i = aChunk.length-1; i >= 0; i–) {n this.prepend(aChunk);n }n }n else if (aChunk || typeof aChunk === "string") {n this.children.unshift(aChunk);n }n else {n throw new TypeError(n "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunkn );n }n return this;n};nn/**n * Walk over the tree of JS snippets in this node and its children. Then * walking function is called once for each snippet of JS and is passed thatn * snippet and the its original associated source's line/column location.n *n * @param aFn The traversal function.n */nSourceNode.prototype.walk = function SourceNode_walk(aFn) {n var chunk;n for (var i = 0, len = this.children.length; i < len; i++) {n chunk = this.children;n if (chunk) {n chunk.walk(aFn);n }n else {n if (chunk !== '') {n aFn(chunk, { source: this.source,n line: this.line,n column: this.column,n name: this.name });n }n }n }n};nn/**n * Like `String.prototype.join` except for SourceNodes. Inserts `aStr` betweenn * each of `this.children`.n *n * @param aSep The separator.n */nSourceNode.prototype.join = function SourceNode_join(aSep) {n var newChildren;n var i;n var len = this.children.length;n if (len > 0) {n newChildren = [];n for (i = 0; i < len-1; i++) {n newChildren.push(this.children);n newChildren.push(aSep);n }n newChildren.push(this.children);n this.children = newChildren;n }n return this;n};nn/**n * Call String.prototype.replace on the very right-most source snippet. Usefuln * for trimming whitespace from the end of a source node, etc.n *n * @param aPattern The pattern to replace.n * @param aReplacement The thing to replace the pattern with.n */nSourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {n var lastChild = this.children[this.children.length - 1];n if (lastChild) {n lastChild.replaceRight(aPattern, aReplacement);n }n else if (typeof lastChild === 'string') {n this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);n }n else {n this.children.push(''.replace(aPattern, aReplacement));n }n return this;n};nn/**n * Set the source content for a source file. This will be added to the SourceMapGeneratorn * in the sourcesContent field.n *n * @param aSourceFile The filename of the source filen * @param aSourceContent The content of the source filen */nSourceNode.prototype.setSourceContent =n function SourceNode_setSourceContent(aSourceFile, aSourceContent) {n this.sourceContents = aSourceContent;n };nn/**n * Walk over the tree of SourceNodes. The walking function is called for eachn * source file content and is passed the filename and source content.n *n * @param aFn The traversal function.n */nSourceNode.prototype.walkSourceContents =n function SourceNode_walkSourceContents(aFn) {n for (var i = 0, len = this.children.length; i < len; i++) {n if (this.children[isSourceNode]) {n this.children.walkSourceContents(aFn);n }n }nn var sources = Object.keys(this.sourceContents);n for (var i = 0, len = sources.length; i < len; i++) {n aFn(util.fromSetString(sources), this.sourceContents[sources]);n }n };nn/**n * Return the string representation of this source node. Walks over the treen * and concatenates all the various snippets together to one string.n */nSourceNode.prototype.toString = function SourceNode_toString() {n var str = "";n this.walk(function (chunk) {n str += chunk;n });n return str;n};nn/**n * Returns the string representation of this source node along with a sourcen * map.n */nSourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {n var generated = {n code: "",n line: 1,n column: 0n };n var map = new SourceMapGenerator(aArgs);n var sourceMappingActive = false;n var lastOriginalSource = null;n var lastOriginalLine = null;n var lastOriginalColumn = null;n var lastOriginalName = null;n this.walk(function (chunk, original) {n generated.code += chunk;n if (original.source !== nulln && original.line !== nulln && original.column !== null) {n if(lastOriginalSource !== original.sourcen || lastOriginalLine !== original.linen || lastOriginalColumn !== original.columnn || lastOriginalName !== original.name) {n map.addMapping({n source: original.source,n original: {n line: original.line,n column: original.columnn },n generated: {n line: generated.line,n column: generated.columnn },n name: original.namen });n }n lastOriginalSource = original.source;n lastOriginalLine = original.line;n lastOriginalColumn = original.column;n lastOriginalName = original.name;n sourceMappingActive = true;n } else if (sourceMappingActive) {n map.addMapping({n generated: {n line: generated.line,n column: generated.columnn }n });n lastOriginalSource = null;n sourceMappingActive = false;n }n for (var idx = 0, length = chunk.length; idx < length; idx++) {n if (chunk.charCodeAt(idx) === NEWLINE_CODE) {n generated.line++;n generated.column = 0;n // Mappings end at eoln if (idx + 1 === length) {n lastOriginalSource = null;n sourceMappingActive = false;n } else if (sourceMappingActive) {n map.addMapping({n source: original.source,n original: {n line: original.line,n column: original.columnn },n generated: {n line: generated.line,n column: generated.columnn },n name: original.namen });n }n } else {n generated.column++;n }n }n });n this.walkSourceContents(function (sourceFile, sourceContent) {n map.setSourceContent(sourceFile, sourceContent);n });nn return { code: generated.code, map: map };n};nnexports.SourceNode = SourceNode;nnnn//////////////////n// WEBPACK FOOTERn// ./lib/source-node.jsn// module id = 10n// module chunks = 0”],“sourceRoot”:“”}