{"version":3,"sources":["webpack://grapesjs-parser-postcss/webpack/universalModuleDefinition","webpack://grapesjs-parser-postcss/webpack/bootstrap","webpack://grapesjs-parser-postcss/./node_modules/postcss/node_modules/source-map/lib/util.js","webpack://grapesjs-parser-postcss/./node_modules/postcss/lib/declaration.js","webpack://grapesjs-parser-postcss/./node_modules/postcss/lib/node.js","webpack://grapesjs-parser-postcss/./node_modules/postcss/lib/stringify.js","webpack://grapesjs-parser-postcss/./node_modules/path-browserify/index.js","webpack://grapesjs-parser-postcss/./node_modules/postcss/lib/parse.js","webpack://grapesjs-parser-postcss/./node_modules/postcss/lib/comment.js","webpack://grapesjs-parser-postcss/./node_modules/postcss/lib/at-rule.js","webpack://grapesjs-parser-postcss/./node_modules/postcss/lib/container.js","webpack://grapesjs-parser-postcss/./node_modules/postcss/lib/rule.js","webpack://grapesjs-parser-postcss/./node_modules/postcss/lib/css-syntax-error.js","webpack://grapesjs-parser-postcss/./node_modules/postcss/lib/stringifier.js","webpack://grapesjs-parser-postcss/./node_modules/postcss/lib/processor.js","webpack://grapesjs-parser-postcss/./node_modules/postcss/lib/lazy-result.js","webpack://grapesjs-parser-postcss/./node_modules/buffer/index.js","webpack://grapesjs-parser-postcss/./node_modules/postcss/node_modules/source-map/source-map.js","webpack://grapesjs-parser-postcss/./node_modules/postcss/node_modules/source-map/lib/source-map-generator.js","webpack://grapesjs-parser-postcss/./node_modules/postcss/node_modules/source-map/lib/base64-vlq.js","webpack://grapesjs-parser-postcss/./node_modules/postcss/node_modules/source-map/lib/array-set.js","webpack://grapesjs-parser-postcss/./node_modules/postcss/lib/list.js","webpack://grapesjs-parser-postcss/./node_modules/postcss/lib/root.js","webpack://grapesjs-parser-postcss/./src/index.js","webpack://grapesjs-parser-postcss/./src/parser.js","webpack://grapesjs-parser-postcss/./node_modules/postcss/lib/postcss.js","webpack://grapesjs-parser-postcss/./node_modules/postcss/lib/map-generator.js","webpack://grapesjs-parser-postcss/(webpack)/buildin/global.js","webpack://grapesjs-parser-postcss/./node_modules/base64-js/index.js","webpack://grapesjs-parser-postcss/./node_modules/ieee754/index.js","webpack://grapesjs-parser-postcss/./node_modules/isarray/index.js","webpack://grapesjs-parser-postcss/./node_modules/postcss/node_modules/source-map/lib/base64.js","webpack://grapesjs-parser-postcss/./node_modules/postcss/node_modules/source-map/lib/mapping-list.js","webpack://grapesjs-parser-postcss/./node_modules/postcss/node_modules/source-map/lib/source-map-consumer.js","webpack://grapesjs-parser-postcss/./node_modules/postcss/node_modules/source-map/lib/binary-search.js","webpack://grapesjs-parser-postcss/./node_modules/postcss/node_modules/source-map/lib/quick-sort.js","webpack://grapesjs-parser-postcss/./node_modules/postcss/node_modules/source-map/lib/source-node.js","webpack://grapesjs-parser-postcss/./node_modules/process/browser.js","webpack://grapesjs-parser-postcss/./node_modules/postcss/lib/warn-once.js","webpack://grapesjs-parser-postcss/./node_modules/postcss/lib/result.js","webpack://grapesjs-parser-postcss/./node_modules/postcss/lib/warning.js","webpack://grapesjs-parser-postcss/./node_modules/postcss/lib/parser.js","webpack://grapesjs-parser-postcss/./node_modules/postcss/lib/tokenize.js","webpack://grapesjs-parser-postcss/./node_modules/postcss/lib/input.js","webpack://grapesjs-parser-postcss/./node_modules/postcss/lib/previous-map.js","webpack://grapesjs-parser-postcss/./node_modules/postcss/lib/vendor.js"],"names":["root","factory","exports","module","define","amd","window","installedModules","__webpack_require__","moduleId","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","getArg","aArgs","aName","aDefaultValue","arguments","length","Error","urlRegexp","dataUrlRegexp","urlParse","aUrl","match","scheme","auth","host","port","path","urlGenerate","aParsedUrl","url","normalize","aPath","part","isAbsolute","parts","split","up","splice","join","aRoot","aPathUrl","aRootUrl","joined","charAt","replace","test","relative","level","indexOf","index","lastIndexOf","slice","Array","substr","supportsNullProto","identity","isProtoString","charCodeAt","strcmp","aStr1","aStr2","toSetString","aStr","fromSetString","compareByOriginalPositions","mappingA","mappingB","onlyCompareOriginal","cmp","source","originalLine","originalColumn","generatedColumn","generatedLine","compareByGeneratedPositionsDeflated","onlyCompareGenerated","compareByGeneratedPositionsInflated","parseSourceMapInput","str","JSON","parse","computeSourceURL","sourceRoot","sourceURL","sourceMapURL","parsed","substring","Declaration","_Node","defaults","instance","Constructor","TypeError","_classCallCheck","this","_this","self","ReferenceError","_possibleConstructorReturn","type","subClass","superClass","constructor","writable","configurable","setPrototypeOf","__proto__","_inherits","obj","default","_interopRequireDefault","_typeof","iterator","_cssSyntaxError2","_stringifier2","_stringify2","Node","undefined","raws","error","message","opts","pos","positionBy","input","line","column","warn","result","text","data","node","remove","parent","removeChild","toString","stringifier","stringify","clone","overrides","cloned","cloneNode","map","j","cloneBefore","insertBefore","cloneAfter","insertAfter","replaceWith","_len","nodes","_key","_iterator","_isArray","isArray","_i","_ref","next","done","prev","before","add","after","toJSON","fixed","raw","prop","defaultType","cleanRaws","keepBetween","between","positionInside","string","start","word","builder","process","normalizeArray","allowAboveRoot","last","unshift","splitPathRe","splitPath","filename","exec","filter","xs","f","res","push","resolve","resolvedPath","resolvedAbsolute","cwd","trailingSlash","paths","from","to","trim","arr","end","fromParts","toParts","Math","min","samePartsLength","outputParts","concat","sep","delimiter","dirname","dir","basename","ext","extname","len","_parser2","_input2","css","parser","e","Comment","AtRule","_Container","append","_Container$prototype$","children","apply","prepend","_Container$prototype$2","_len2","_key2","_createClass","defineProperties","target","props","descriptor","protoProps","staticProps","_declaration2","_comment2","Container","child","each","callback","lastEach","indexes","id","walk","postcssNode","stack","walkDecls","RegExp","walkRules","selector","walkAtRules","walkComments","_iterator2","_isArray2","_i2","_ref2","_iterator3","reverse","_isArray3","_i3","_ref3","first","_iterator4","_isArray4","_i4","_ref4","_iterator5","_isArray5","_i5","_ref5","exist","_iterator6","_isArray6","_i6","_ref6","_iterator7","_isArray7","_i7","_ref7","removeAll","_iterator8","_isArray8","_i8","_ref8","replaceValues","pattern","decl","fast","every","condition","some","sample","_this2","cleanSource","_iterator9","_isArray9","_i9","_ref9","_iterator10","_isArray10","_i11","_ref10","_i10","String","_container2","_list2","Rule","comma","set","values","_supportsColor2","_chalk2","_terminalHighlight2","CssSyntaxError","file","plugin","reason","setMessage","captureStackTrace","showSourceCode","color","stdout","lines","max","maxWidth","mark","red","bold","aside","gray","number","gutter","spacing","code","DEFAULT_RAW","colon","indent","beforeDecl","beforeRule","beforeOpen","beforeClose","beforeComment","emptyBody","commentLeft","commentRight","Stringifier","semicolon","body","comment","left","right","rawValue","important","rule","block","ownSemicolon","atrule","params","afterName","own","detect","rawCache","beforeAfter","method","toUpperCase","capitalize","rawSemicolon","rawEmptyBody","rawIndent","rawBeforeComment","rawBeforeDecl","rawBeforeRule","rawBeforeClose","rawBeforeOpen","rawColon","buf","depth","step","_lazyResult2","Processor","plugins","version","use","_process","_x","normalized","postcss","_mapGenerator2","_stringify3","_result2","_parse2","isPromise","then","LazyResult","processor","stringified","processed","inline","syntax","warnings","sync","onFulfilled","onRejected","async","catch","finally","onFinally","handleError","postcssVersion","postcssPlugin","err","console","asyncTick","reject","promise","run","Promise","processing","lastPlugin","generate","content","messages","global","base64","ieee754","kMaxLength","Buffer","TYPED_ARRAY_SUPPORT","createBuffer","that","RangeError","Uint8Array","arg","encodingOrOffset","allocUnsafe","ArrayBuffer","array","byteOffset","byteLength","fromArrayLike","fromArrayBuffer","encoding","isEncoding","actual","write","fromString","isBuffer","checked","copy","buffer","val","isnan","fromObject","assertSize","size","isView","loweredCase","utf8ToBytes","base64ToBytes","toLowerCase","swap","b","bidirectionalIndexOf","isNaN","arrayIndexOf","indexSize","arrLength","valLength","read","readUInt16BE","foundIndex","found","hexWrite","offset","Number","remaining","strLen","parseInt","utf8Write","blitBuffer","asciiWrite","byteArray","asciiToBytes","latin1Write","base64Write","ucs2Write","units","hi","lo","utf16leToBytes","base64Slice","fromByteArray","utf8Slice","secondByte","thirdByte","fourthByte","tempCodePoint","firstByte","codePoint","bytesPerSequence","codePoints","MAX_ARGUMENTS_LENGTH","fromCharCode","decodeCodePointsArray","SlowBuffer","alloc","INSPECT_MAX_BYTES","foo","subarray","typedArraySupport","poolSize","_augment","species","fill","allocUnsafeSlow","_isBuffer","compare","a","x","y","list","swap16","swap32","swap64","hexSlice","asciiSlice","latin1Slice","utf16leSlice","equals","inspect","thisStart","thisEnd","thisCopy","targetCopy","includes","isFinite","_arr","ret","out","toHex","bytes","checkOffset","checkInt","objectWriteUInt16","littleEndian","objectWriteUInt32","checkIEEE754","writeFloat","noAssert","writeDouble","newBuf","sliceLen","readUIntLE","mul","readUIntBE","readUInt8","readUInt16LE","readUInt32LE","readUInt32BE","readIntLE","pow","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","writeUIntLE","writeUIntBE","writeUInt8","floor","writeUInt16LE","writeUInt16BE","writeUInt32LE","writeUInt32BE","writeIntLE","limit","sub","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","targetStart","INVALID_BASE64_RE","Infinity","leadSurrogate","toByteArray","stringtrim","base64clean","src","dst","SourceMapGenerator","SourceMapConsumer","SourceNode","base64VLQ","util","ArraySet","MappingList","_file","_sourceRoot","_skipValidation","_sources","_names","_mappings","_sourcesContents","_version","fromSourceMap","aSourceMapConsumer","generator","eachMapping","mapping","newMapping","generated","original","addMapping","sources","forEach","sourceFile","sourceRelative","has","sourceContentFor","setSourceContent","_validateMapping","aSourceFile","aSourceContent","keys","applySourceMap","aSourceMapPath","newSources","newNames","unsortedForEach","originalPositionFor","aGenerated","aOriginal","aSource","_serializeMappings","nameIdx","sourceIdx","previousGeneratedColumn","previousGeneratedLine","previousOriginalColumn","previousOriginalLine","previousName","previousSource","mappings","toArray","encode","_generateSourcesContent","aSources","aSourceRoot","names","sourcesContent","aValue","digit","encoded","vlq","toVLQSigned","VLQ_BASE","decode","aIndex","aOutParam","continuation","shift","shifted","fromVLQSigned","rest","hasNativeMap","Map","_array","_set","fromArray","aArray","aAllowDuplicates","getOwnPropertyNames","sStr","isDuplicate","idx","at","aIdx","separators","current","func","quote","escape","letter","space","Root","ignore","toResult","editor","options","setCustomParserCss","log","msg","createRule","style","selectors","createAtRule","_extends","atRule","ast","_processor2","_atRule2","_vendor2","_rule2","_root2","initializer","creator","transformer","cache","processOpts","pluginOpts","vendor","_sourceMap2","_path2","MapGenerator","mapOpts","isMap","previous","previousMaps","isInline","annotation","isSourcesContent","withContent","clearAnnotation","setSourcesContent","already","applyPrevMaps","consumer","isAnnotation","toBase64","btoa","unescape","encodeURIComponent","addAnnotation","outputFile","eol","generateMap","generateString","sourcePath","_this3","g","Function","eval","b64","lens","getLens","validLen","placeHoldersLen","tmp","Arr","_byteLength","curByte","revLookup","uint8","extraBytes","len2","encodeChunk","lookup","tripletToBase64","num","output","isLE","mLen","nBytes","eLen","eMax","eBias","nBits","NaN","rt","abs","LN2","intToCharMap","charCode","_sorted","_last","aCallback","aThisArg","aMapping","lineA","lineB","columnA","columnB","generatedPositionAfter","sort","binarySearch","quickSort","aSourceMap","aSourceMapURL","sourceMap","sections","IndexedSourceMapConsumer","BasicSourceMapConsumer","_absoluteSources","_sourceMapURL","Mapping","lastOffset","_sections","offsetLine","offsetColumn","generatedOffset","__generatedMappings","_parseMappings","__originalMappings","_charIsMappingSeparator","GENERATED_ORDER","ORIGINAL_ORDER","GREATEST_LOWER_BOUND","LEAST_UPPER_BOUND","aContext","aOrder","context","_generatedMappings","_originalMappings","allGeneratedPositionsFor","needle","_findSourceIndex","_findMapping","lastColumn","relativeSource","smc","generatedMappings","destGeneratedMappings","destOriginalMappings","srcMapping","destMapping","segment","cachedSegments","temp","originalMappings","aNeedle","aMappings","aLineName","aColumnName","aComparator","aBias","search","computeColumnSpans","nextMapping","lastGeneratedColumn","hasContentsOfAllSources","sc","nullOnMissing","fileUriAbsPath","generatedPositionFor","sectionIndex","section","bias","generatedPosition","sectionMappings","adjustedMapping","aHaystack","aCompare","recursiveSearch","aLow","aHigh","mid","ary","doQuickSort","comparator","low","high","round","random","randomIntInRange","pivot","q","REGEX_NEWLINE","isSourceNode","aLine","aColumn","aChunks","sourceContents","fromStringWithSourceMap","aGeneratedCode","aRelativePath","remainingLines","remainingLinesIndex","shiftNextLine","getNextLine","lastGeneratedLine","lastMapping","nextLine","addMappingWithCode","aChunk","chunk","aFn","aSep","newChildren","replaceRight","aPattern","aReplacement","lastChild","walkSourceContents","toStringWithSourceMap","sourceMappingActive","lastOriginalSource","lastOriginalLine","lastOriginalColumn","lastOriginalName","sourceContent","cachedSetTimeout","cachedClearTimeout","defaultSetTimout","defaultClearTimeout","runTimeout","fun","setTimeout","clearTimeout","currentQueue","queue","draining","queueIndex","cleanUpNextTick","drainQueue","timeout","marker","runClearTimeout","Item","noop","nextTick","args","title","browser","env","argv","versions","on","addListener","once","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","chdir","umask","printed","_warning2","Result","warning","Warning","opt","_tokenize2","Parser","spaces","createTokenizer","tokenizer","token","endOfFile","nextToken","freeSemicolon","emptyRule","other","endFile","init","bracket","brackets","tokens","back","pop","unclosedBracket","unknownWord","spacesAndCommentsFromEnd","spacesAndCommentsFromStart","precheckMissedSemicolon","stringFrom","spacesFromEnd","_type","checkMissedSemicolon","unnamedAtrule","open","unexpectedClose","unclosedBlock","clean","reduce","all","lastTokenType","doubleColon","founded","valueOf","ignoreErrors","nextOffset","escaped","escapePos","currentToken","returned","unclosed","what","NEWLINE","FEED","CR","SPACE","TAB","OPEN_SQUARE","CLOSE_SQUARE","OPEN_CURLY","CLOSE_CURLY","COLON","SEMICOLON","OPEN_PARENTHESES","SINGLE_QUOTE","DOUBLE_QUOTE","BACKSLASH","RE_BAD_BRACKET","CLOSE_PARENTHESES","AT","RE_AT_END","lastIndex","SLASH","RE_HEX_ESCAPE","ASTERISK","RE_WORD_END","_previousMap2","sequence","Input","mapResolve","origin","_fs2","PreviousMap","loadAnnotation","startWith","loadMap","consumerCache","decodeInline","uri","decodeURIComponent","atob","fromBase64","lastMatch","prevPath","existsSync","readFileSync","prefix","unprefixed"],"mappings":";CAAA,SAAAA,EAAAC,GACA,iBAAAC,SAAA,iBAAAC,OACAA,OAAAD,QAAAD,IACA,mBAAAG,eAAAC,IACAD,UAAAH,GACA,iBAAAC,QACAA,QAAA,2BAAAD,IAEAD,EAAA,2BAAAC,IARA,CASCK,OAAA,WACD,mBCTA,IAAAC,KAGA,SAAAC,EAAAC,GAGA,GAAAF,EAAAE,GACA,OAAAF,EAAAE,GAAAP,QAGA,IAAAC,EAAAI,EAAAE,IACAC,EAAAD,EACAE,GAAA,EACAT,YAUA,OANAU,EAAAH,GAAAI,KAAAV,EAAAD,QAAAC,IAAAD,QAAAM,GAGAL,EAAAQ,GAAA,EAGAR,EAAAD,QA0DA,OArDAM,EAAAM,EAAAF,EAGAJ,EAAAO,EAAAR,EAGAC,EAAAQ,EAAA,SAAAd,EAAAe,EAAAC,GACAV,EAAAW,EAAAjB,EAAAe,IACAG,OAAAC,eAAAnB,EAAAe,GAA0CK,YAAA,EAAAC,IAAAL,KAK1CV,EAAAgB,EAAA,SAAAtB,GACA,oBAAAuB,eAAAC,aACAN,OAAAC,eAAAnB,EAAAuB,OAAAC,aAAwDC,MAAA,WAExDP,OAAAC,eAAAnB,EAAA,cAAiDyB,OAAA,KAQjDnB,EAAAoB,EAAA,SAAAD,EAAAE,GAEA,GADA,EAAAA,IAAAF,EAAAnB,EAAAmB,IACA,EAAAE,EAAA,OAAAF,EACA,KAAAE,GAAA,iBAAAF,QAAAG,WAAA,OAAAH,EACA,IAAAI,EAAAX,OAAAY,OAAA,MAGA,GAFAxB,EAAAgB,EAAAO,GACAX,OAAAC,eAAAU,EAAA,WAAyCT,YAAA,EAAAK,UACzC,EAAAE,GAAA,iBAAAF,EAAA,QAAAM,KAAAN,EAAAnB,EAAAQ,EAAAe,EAAAE,EAAA,SAAAA,GAAgH,OAAAN,EAAAM,IAAqBC,KAAA,KAAAD,IACrI,OAAAF,GAIAvB,EAAA2B,EAAA,SAAAhC,GACA,IAAAe,EAAAf,KAAA2B,WACA,WAA2B,OAAA3B,EAAA,SAC3B,WAAiC,OAAAA,GAEjC,OADAK,EAAAQ,EAAAE,EAAA,IAAAA,GACAA,GAIAV,EAAAW,EAAA,SAAAiB,EAAAC,GAAsD,OAAAjB,OAAAkB,UAAAC,eAAA1B,KAAAuB,EAAAC,IAGtD7B,EAAAgC,EAAA,GAIAhC,IAAAiC,EAAA,oBCxDAvC,EAAAwC,OATA,SAAAC,EAAAC,EAAAC,GACA,GAAAD,KAAAD,EACA,OAAAA,EAAAC,GACG,OAAAE,UAAAC,OACH,OAAAF,EAEA,UAAAG,MAAA,IAAAJ,EAAA,8BAKA,IAAAK,EAAA,iEACAC,EAAA,gBAEA,SAAAC,EAAAC,GACA,IAAAC,EAAAD,EAAAC,MAAAJ,GACA,OAAAI,GAIAC,OAAAD,EAAA,GACAE,KAAAF,EAAA,GACAG,KAAAH,EAAA,GACAI,KAAAJ,EAAA,GACAK,KAAAL,EAAA,IAPA,KAYA,SAAAM,EAAAC,GACA,IAAAC,EAAA,GAiBA,OAhBAD,EAAAN,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,SAAAC,EAAAC,GACA,IAAAL,EAAAK,EACAF,EAAAV,EAAAY,GACA,GAAAF,EAAA,CACA,IAAAA,EAAAH,KACA,OAAAK,EAEAL,EAAAG,EAAAH,KAKA,IAHA,IAGAM,EAHAC,EAAA/D,EAAA+D,WAAAP,GAEAQ,EAAAR,EAAAS,MAAA,OACAC,EAAA,EAAA1D,EAAAwD,EAAAnB,OAAA,EAA8CrC,GAAA,EAAQA,IAEtD,OADAsD,EAAAE,EAAAxD,IAEAwD,EAAAG,OAAA3D,EAAA,GACK,OAAAsD,EACLI,IACKA,EAAA,IACL,KAAAJ,GAIAE,EAAAG,OAAA3D,EAAA,EAAA0D,GACAA,EAAA,IAEAF,EAAAG,OAAA3D,EAAA,GACA0D,MAUA,MAJA,MAFAV,EAAAQ,EAAAI,KAAA,QAGAZ,EAAAO,EAAA,SAGAJ,GACAA,EAAAH,OACAC,EAAAE,IAEAH,EAoBA,SAAAY,EAAAC,EAAAR,GACA,KAAAQ,IACAA,EAAA,KAEA,KAAAR,IACAA,EAAA,KAEA,IAAAS,EAAArB,EAAAY,GACAU,EAAAtB,EAAAoB,GAMA,GALAE,IACAF,EAAAE,EAAAf,MAAA,KAIAc,MAAAlB,OAIA,OAHAmB,IACAD,EAAAlB,OAAAmB,EAAAnB,QAEAK,EAAAa,GAGA,GAAAA,GAAAT,EAAAV,MAAAH,GACA,OAAAa,EAIA,GAAAU,MAAAjB,OAAAiB,EAAAf,KAEA,OADAe,EAAAjB,KAAAO,EACAJ,EAAAc,GAGA,IAAAC,EAAA,MAAAX,EAAAY,OAAA,GACAZ,EACAD,EAAAS,EAAAK,QAAA,eAAAb,GAEA,OAAAU,GACAA,EAAAf,KAAAgB,EACAf,EAAAc,IAEAC,EAvIAxE,EAAAiD,WAsBAjD,EAAAyD,cAwDAzD,EAAA4D,YA2DA5D,EAAAoE,OAEApE,EAAA+D,WAAA,SAAAF,GACA,YAAAA,EAAAY,OAAA,IAAA1B,EAAA4B,KAAAd,IAyCA7D,EAAA4E,SAhCA,SAAAP,EAAAR,GACA,KAAAQ,IACAA,EAAA,KAGAA,IAAAK,QAAA,UAOA,IADA,IAAAG,EAAA,EACA,IAAAhB,EAAAiB,QAAAT,EAAA,OACA,IAAAU,EAAAV,EAAAW,YAAA,KACA,GAAAD,EAAA,EACA,OAAAlB,EAOA,IADAQ,IAAAY,MAAA,EAAAF,IACA5B,MAAA,qBACA,OAAAU,IAGAgB,EAIA,OAAAK,MAAAL,EAAA,GAAAT,KAAA,OAAAP,EAAAsB,OAAAd,EAAAxB,OAAA,IAIA,IAAAuC,IAEA,cADAlE,OAAAY,OAAA,OAIA,SAAAuD,EAAA9C,GACA,OAAAA,EA8BA,SAAA+C,EAAA/C,GACA,IAAAA,EACA,SAGA,IAAAM,EAAAN,EAAAM,OAEA,GAAAA,EAAA,EACA,SAGA,QAAAN,EAAAgD,WAAA1C,EAAA,IACA,KAAAN,EAAAgD,WAAA1C,EAAA,IACA,MAAAN,EAAAgD,WAAA1C,EAAA,IACA,MAAAN,EAAAgD,WAAA1C,EAAA,IACA,MAAAN,EAAAgD,WAAA1C,EAAA,IACA,MAAAN,EAAAgD,WAAA1C,EAAA,IACA,MAAAN,EAAAgD,WAAA1C,EAAA,IACA,KAAAN,EAAAgD,WAAA1C,EAAA,IACA,KAAAN,EAAAgD,WAAA1C,EAAA,GACA,SAGA,QAAArC,EAAAqC,EAAA,GAA2BrC,GAAA,EAAQA,IACnC,QAAA+B,EAAAgD,WAAA/E,GACA,SAIA,SAgFA,SAAAgF,EAAAC,EAAAC,GACA,OAAAD,IAAAC,EACA,EAGA,OAAAD,EACA,EAGA,OAAAC,GACA,EAGAD,EAAAC,EACA,GAGA,EAzIA1F,EAAA2F,YAAAP,EAAAC,EAPA,SAAAO,GACA,OAAAN,EAAAM,GACA,IAAAA,EAGAA,GAWA5F,EAAA6F,cAAAT,EAAAC,EAPA,SAAAO,GACA,OAAAN,EAAAM,GACAA,EAAAX,MAAA,GAGAW,GAwEA5F,EAAA8F,2BA5BA,SAAAC,EAAAC,EAAAC,GACA,IAAAC,EAAAV,EAAAO,EAAAI,OAAAH,EAAAG,QACA,WAAAD,EACAA,EAIA,IADAA,EAAAH,EAAAK,aAAAJ,EAAAI,cAEAF,EAIA,IADAA,EAAAH,EAAAM,eAAAL,EAAAK,iBACAJ,EACAC,EAIA,IADAA,EAAAH,EAAAO,gBAAAN,EAAAM,iBAEAJ,EAIA,IADAA,EAAAH,EAAAQ,cAAAP,EAAAO,eAEAL,EAGAV,EAAAO,EAAAhF,KAAAiF,EAAAjF,OAyCAf,EAAAwG,oCA5BA,SAAAT,EAAAC,EAAAS,GACA,IAAAP,EAAAH,EAAAQ,cAAAP,EAAAO,cACA,WAAAL,EACAA,EAIA,IADAA,EAAAH,EAAAO,gBAAAN,EAAAM,kBACAG,EACAP,EAIA,KADAA,EAAAV,EAAAO,EAAAI,OAAAH,EAAAG,SAEAD,EAIA,IADAA,EAAAH,EAAAK,aAAAJ,EAAAI,cAEAF,EAIA,IADAA,EAAAH,EAAAM,eAAAL,EAAAK,gBAEAH,EAGAV,EAAAO,EAAAhF,KAAAiF,EAAAjF,OAwDAf,EAAA0G,oCA5BA,SAAAX,EAAAC,GACA,IAAAE,EAAAH,EAAAQ,cAAAP,EAAAO,cACA,WAAAL,EACAA,EAIA,IADAA,EAAAH,EAAAO,gBAAAN,EAAAM,iBAEAJ,EAIA,KADAA,EAAAV,EAAAO,EAAAI,OAAAH,EAAAG,SAEAD,EAIA,IADAA,EAAAH,EAAAK,aAAAJ,EAAAI,cAEAF,EAIA,IADAA,EAAAH,EAAAM,eAAAL,EAAAK,gBAEAH,EAGAV,EAAAO,EAAAhF,KAAAiF,EAAAjF,OAYAf,EAAA2G,oBAHA,SAAAC,GACA,OAAAC,KAAAC,MAAAF,EAAAlC,QAAA,iBAAsC,MAuDtC1E,EAAA+G,iBA/CA,SAAAC,EAAAC,EAAAC,GA8BA,GA7BAD,KAAA,GAEAD,IAEA,MAAAA,IAAAnE,OAAA,UAAAoE,EAAA,KACAD,GAAA,KAOAC,EAAAD,EAAAC,GAiBAC,EAAA,CACA,IAAAC,EAAAlE,EAAAiE,GACA,IAAAC,EACA,UAAArE,MAAA,oCAEA,GAAAqE,EAAA3D,KAAA,CAEA,IAAAuB,EAAAoC,EAAA3D,KAAAwB,YAAA,KACAD,GAAA,IACAoC,EAAA3D,KAAA2D,EAAA3D,KAAA4D,UAAA,EAAArC,EAAA,IAGAkC,EAAA7C,EAAAX,EAAA0D,GAAAF,GAGA,OAAArD,EAAAqD,kCCneAjH,EAAA4B,YAAA,EAyBA,IAAAyF,EAAA,SAAAC,GAGA,SAAAD,EAAAE,IApBA,SAAAC,EAAAC,GAAiD,KAAAD,aAAAC,GAA0C,UAAAC,UAAA,qCAqB3FC,CAAAC,KAAAP,GAEA,IAAAQ,EArBA,SAAAC,EAAAnH,GAAiD,IAAAmH,EAAa,UAAAC,eAAA,6DAAyF,OAAApH,GAAA,iBAAAA,GAAA,mBAAAA,EAAAmH,EAAAnH,EAqBvJqH,CAAAJ,KAAAN,EAAA3G,KAAAiH,KAAAL,IAGA,OADAM,EAAAI,KAAA,OACAJ,EA4DA,OAlFA,SAAAK,EAAAC,GAA0C,sBAAAA,GAAA,OAAAA,EAA+D,UAAAT,UAAA,kEAAAS,GAAuGD,EAAA9F,UAAAlB,OAAAY,OAAAqG,KAAA/F,WAAyEgG,aAAe3G,MAAAyG,EAAA9G,YAAA,EAAAiH,UAAA,EAAAC,cAAA,KAA6EH,IAAAjH,OAAAqH,eAAArH,OAAAqH,eAAAL,EAAAC,GAAAD,EAAAM,UAAAL,GAcrXM,CAAApB,EAAAC,GAoEAD,EArEA,CAnBA,SAAAqB,GAAsC,OAAAA,KAAA9G,WAAA8G,GAAuCC,QAAAD,GAF7EE,CAFYtI,EAAQ,IA6FnBqI,SAED3I,EAAA2I,QAAAtB,EACApH,EAAAD,UAAA,sCClGAA,EAAA4B,YAAA,EAEA,IAAAiH,EAAA,mBAAAtH,QAAA,iBAAAA,OAAAuH,SAAA,SAAAJ,GAAoG,cAAAA,GAAqB,SAAAA,GAAmB,OAAAA,GAAA,mBAAAnH,QAAAmH,EAAAN,cAAA7G,QAAAmH,IAAAnH,OAAAa,UAAA,gBAAAsG,GAI5IK,EAAAH,EAFsBtI,EAAQ,KAM9B0I,EAAAJ,EAFmBtI,EAAQ,KAM3B2I,EAAAL,EAFiBtI,EAAQ,IAIzB,SAAAsI,EAAAF,GAAsC,OAAAA,KAAA9G,WAAA8G,GAAuCC,QAAAD,GAmC7E,IAAAQ,EAAA,WAIA,SAAAA,IACA,IAAA3B,EAAA3E,UAAAC,OAAA,QAAAsG,IAAAvG,UAAA,GAAAA,UAAA,MAUA,QAAA7B,KAhDA,SAAAyG,EAAAC,GAAiD,KAAAD,aAAAC,GAA0C,UAAAC,UAAA,qCAwC3FC,CAAAC,KAAAsB,GAEAtB,KAAAwB,QAMA7B,EACAK,KAAA7G,GAAAwG,EAAAxG,GA4gBA,OAteAmI,EAAA9G,UAAAiH,MAAA,SAAAC,GACA,IAAAC,EAAA3G,UAAAC,OAAA,QAAAsG,IAAAvG,UAAA,GAAAA,UAAA,MAEA,GAAAgF,KAAAzB,OAAA,CACA,IAAAqD,EAAA5B,KAAA6B,WAAAF,GACA,OAAA3B,KAAAzB,OAAAuD,MAAAL,MAAAC,EAAAE,EAAAG,KAAAH,EAAAI,OAAAL,GAEA,WAAAR,EAAAJ,QAAAW,IA+BAJ,EAAA9G,UAAAyH,KAAA,SAAAC,EAAAC,EAAAR,GACA,IAAAS,GAAgBC,KAAArC,MAChB,QAAApH,KAAA+I,EACAS,EAAAxJ,GAAA+I,EAAA/I,GACK,OAAAsJ,EAAAD,KAAAE,EAAAC,IAgBLd,EAAA9G,UAAA8H,OAAA,WAKA,OAJAtC,KAAAuC,QACAvC,KAAAuC,OAAAC,YAAAxC,MAEAA,KAAAuC,YAAAhB,EACAvB,MAgBAsB,EAAA9G,UAAAiI,SAAA,WACA,IAAAC,EAAA1H,UAAAC,OAAA,QAAAsG,IAAAvG,UAAA,GAAAA,UAAA,GAAAqG,EAAAN,QAEA2B,EAAAC,YAAAD,IAAAC,WACA,IAAAT,EAAA,GAIA,OAHAQ,EAAA1C,KAAA,SAAApH,GACAsJ,GAAAtJ,IAEAsJ,GAqBAZ,EAAA9G,UAAAoI,MAAA,WACA,IAAAC,EAAA7H,UAAAC,OAAA,QAAAsG,IAAAvG,UAAA,GAAAA,UAAA,MAEA8H,EApMA,SAAAC,EAAAjC,EAAAyB,GACA,IAAAO,EAAA,IAAAhC,EAAAN,YAEA,QAAA5H,KAAAkI,EACA,GAAAA,EAAArG,eAAA7B,GAAA,CACA,IAAAiB,EAAAiH,EAAAlI,GACAyH,OAAA,IAAAxG,EAAA,YAAAoH,EAAApH,GAEA,WAAAjB,GAAA,WAAAyH,EACAkC,IAAAO,EAAAlK,GAAA2J,GACK,WAAA3J,EACLkK,EAAAlK,GAAAiB,EACKA,aAAAyD,MACLwF,EAAAlK,GAAAiB,EAAAmJ,IAAA,SAAAC,GACA,OAAAF,EAAAE,EAAAH,MAGA,WAAAzC,GAAA,OAAAxG,MAAAkJ,EAAAlJ,IACAiJ,EAAAlK,GAAAiB,GAIA,OAAAiJ,EA8KAC,CAAA/C,MACA,QAAA7G,KAAA0J,EACAC,EAAA3J,GAAA0J,EAAA1J,GAEA,OAAA2J,GAgBAxB,EAAA9G,UAAA0I,YAAA,WACA,IAAAL,EAAA7H,UAAAC,OAAA,QAAAsG,IAAAvG,UAAA,GAAAA,UAAA,MAEA8H,EAAA9C,KAAA4C,MAAAC,GAEA,OADA7C,KAAAuC,OAAAY,aAAAnD,KAAA8C,GACAA,GAaAxB,EAAA9G,UAAA4I,WAAA,WACA,IAAAP,EAAA7H,UAAAC,OAAA,QAAAsG,IAAAvG,UAAA,GAAAA,UAAA,MAEA8H,EAAA9C,KAAA4C,MAAAC,GAEA,OADA7C,KAAAuC,OAAAc,YAAArD,KAAA8C,GACAA,GAiBAxB,EAAA9G,UAAA8I,YAAA,WACA,GAAAtD,KAAAuC,OAAA,CACA,QAAAgB,EAAAvI,UAAAC,OAAAuI,EAAAlG,MAAAiG,GAAAE,EAAA,EAAsEA,EAAAF,EAAaE,IACnFD,EAAAC,GAAAzI,UAAAyI,GAGA,IAAAC,EAAAF,EAAAG,EAAArG,MAAAsG,QAAAF,GAAAG,EAAA,MAAAH,EAAAC,EAAAD,IAAA/J,OAAAuH,cAAgJ,CAChJ,IAAA4C,EAEA,GAAAH,EAAA,CACA,GAAAE,GAAAH,EAAAzI,OAAA,MACA6I,EAAAJ,EAAAG,SACS,CAET,IADAA,EAAAH,EAAAK,QACAC,KAAA,MACAF,EAAAD,EAAAhK,MAGA,IAAAwI,EAAAyB,EAEA9D,KAAAuC,OAAAY,aAAAnD,KAAAqC,GAGArC,KAAAsC,SAGA,OAAAtC,MAmBAsB,EAAA9G,UAAAuJ,KAAA,WACA,GAAA/D,KAAAuC,OAAA,CACA,IAAApF,EAAA6C,KAAAuC,OAAApF,MAAA6C,MACA,OAAAA,KAAAuC,OAAAiB,MAAArG,EAAA,KAiBAmE,EAAA9G,UAAAyJ,KAAA,WACA,GAAAjE,KAAAuC,OAAA,CACA,IAAApF,EAAA6C,KAAAuC,OAAApF,MAAA6C,MACA,OAAAA,KAAAuC,OAAAiB,MAAArG,EAAA,KAiBAmE,EAAA9G,UAAA0J,OAAA,SAAAC,GAEA,OADAnE,KAAAuC,OAAAY,aAAAnD,KAAAmE,GACAnE,MAiBAsB,EAAA9G,UAAA4J,MAAA,SAAAD,GAEA,OADAnE,KAAAuC,OAAAc,YAAArD,KAAAmE,GACAnE,MAGAsB,EAAA9G,UAAA6J,OAAA,WACA,IAAAC,KAEA,QAAAnL,KAAA6G,KACA,GAAAA,KAAAvF,eAAAtB,IACA,WAAAA,EAAA,CACA,IAAAU,EAAAmG,KAAA7G,GAEAU,aAAAyD,MACAgH,EAAAnL,GAAAU,EAAAmJ,IAAA,SAAApK,GACA,2BAAAA,EAAA,YAAAqI,EAAArI,OAAAyL,OACAzL,EAAAyL,SAEAzL,IAGO,qBAAAiB,EAAA,YAAAoH,EAAApH,OAAAwK,OACPC,EAAAnL,GAAAU,EAAAwK,SAEAC,EAAAnL,GAAAU,EAIA,OAAAyK,GAuBAhD,EAAA9G,UAAA+J,IAAA,SAAAC,EAAAC,GAEA,OADA,IAAArD,EAAAL,SACAwD,IAAAvE,KAAAwE,EAAAC,IAaAnD,EAAA9G,UAAAtC,KAAA,WAEA,IADA,IAAAgK,EAAAlC,KACAkC,EAAAK,QACAL,IAAAK,OACK,OAAAL,GAiBLZ,EAAA9G,UAAAkK,UAAA,SAAAC,UACA3E,KAAAwB,KAAA0C,cACAlE,KAAAwB,KAAA4C,MACAO,UAAA3E,KAAAwB,KAAAoD,SAGAtD,EAAA9G,UAAAqK,eAAA,SAAA1H,GAKA,IAJA,IAAA2H,EAAA9E,KAAAyC,WACAT,EAAAhC,KAAAzB,OAAAwG,MAAA/C,OACAD,EAAA/B,KAAAzB,OAAAwG,MAAAhD,KAEAnJ,EAAA,EAAmBA,EAAAuE,EAAWvE,IAC9B,OAAAkM,EAAAlM,IACAoJ,EAAA,EACAD,GAAA,GAEAC,GAAA,EAIA,OAAYD,OAAAC,WAGZV,EAAA9G,UAAAqH,WAAA,SAAAF,GACA,IAAAC,EAAA5B,KAAAzB,OAAAwG,MACA,GAAApD,EAAAxE,MACAyE,EAAA5B,KAAA6E,eAAAlD,EAAAxE,YACK,GAAAwE,EAAAqD,KAAA,CACL,IAAA7H,EAAA6C,KAAAyC,WAAAvF,QAAAyE,EAAAqD,OACA,IAAA7H,IAAAyE,EAAA5B,KAAA6E,eAAA1H,IAEA,OAAAyE,GA6FAN,EA5hBA,GA+hBAlJ,EAAA2I,QAAAO,EAeAjJ,EAAAD,UAAA,sCCjmBAA,EAAA4B,YAAA,EAEA,IAEAoH,EAEA,SAAAN,GAAsC,OAAAA,KAAA9G,WAAA8G,GAAuCC,QAAAD,GAF7EE,CAFmBtI,EAAQ,KAW3BN,EAAA2I,QALA,SAAAsB,EAAA4C,GACA,IAAA7D,EAAAL,QAAAkE,GACAtC,UAAAN,IAIAhK,EAAAD,UAAA,0BChBA,SAAA8M,GAyBA,SAAAC,EAAA/I,EAAAgJ,GAGA,IADA,IAAA9I,EAAA,EACA1D,EAAAwD,EAAAnB,OAAA,EAAgCrC,GAAA,EAAQA,IAAA,CACxC,IAAAyM,EAAAjJ,EAAAxD,GACA,MAAAyM,EACAjJ,EAAAG,OAAA3D,EAAA,GACK,OAAAyM,GACLjJ,EAAAG,OAAA3D,EAAA,GACA0D,KACKA,IACLF,EAAAG,OAAA3D,EAAA,GACA0D,KAKA,GAAA8I,EACA,KAAU9I,IAAMA,EAChBF,EAAAkJ,QAAA,MAIA,OAAAlJ,EAKA,IAAAmJ,EACA,gEACAC,EAAA,SAAAC,GACA,OAAAF,EAAAG,KAAAD,GAAApI,MAAA,IAuJA,SAAAsI,EAAAC,EAAAC,GACA,GAAAD,EAAAD,OAAA,OAAAC,EAAAD,OAAAE,GAEA,IADA,IAAAC,KACAlN,EAAA,EAAmBA,EAAAgN,EAAA3K,OAAerC,IAClCiN,EAAAD,EAAAhN,KAAAgN,IAAAE,EAAAC,KAAAH,EAAAhN,IAEA,OAAAkN,EAxJA1N,EAAA4N,QAAA,WAIA,IAHA,IAAAC,EAAA,GACAC,GAAA,EAEAtN,EAAAoC,UAAAC,OAAA,EAAoCrC,IAAA,IAAAsN,EAA8BtN,IAAA,CAClE,IAAAgD,EAAAhD,GAAA,EAAAoC,UAAApC,GAAAsM,EAAAiB,MAGA,oBAAAvK,EACA,UAAAkE,UAAA,6CACKlE,IAILqK,EAAArK,EAAA,IAAAqK,EACAC,EAAA,MAAAtK,EAAAiB,OAAA,IAWA,OAJAoJ,EAAAd,EAAAQ,EAAAM,EAAA5J,MAAA,cAAA3B,GACA,QAAAA,KACGwL,GAAA1J,KAAA,MAEH0J,EAAA,QAAAD,GAAA,KAKA7N,EAAA4D,UAAA,SAAAJ,GACA,IAAAO,EAAA/D,EAAA+D,WAAAP,GACAwK,EAAA,MAAA7I,EAAA3B,GAAA,GAcA,OAXAA,EAAAuJ,EAAAQ,EAAA/J,EAAAS,MAAA,cAAA3B,GACA,QAAAA,KACGyB,GAAAK,KAAA,OAEHL,IACAP,EAAA,KAEAA,GAAAwK,IACAxK,GAAA,MAGAO,EAAA,QAAAP,GAIAxD,EAAA+D,WAAA,SAAAP,GACA,YAAAA,EAAAiB,OAAA,IAIAzE,EAAAoE,KAAA,WACA,IAAA6J,EAAA/I,MAAA9C,UAAA6C,MAAAtE,KAAAiC,UAAA,GACA,OAAA5C,EAAA4D,UAAA2J,EAAAU,EAAA,SAAA3L,EAAAyC,GACA,oBAAAzC,EACA,UAAAoF,UAAA,0CAEA,OAAApF,IACG8B,KAAA,OAMHpE,EAAA4E,SAAA,SAAAsJ,EAAAC,GAIA,SAAAC,EAAAC,GAEA,IADA,IAAA1B,EAAA,EACUA,EAAA0B,EAAAxL,QACV,KAAAwL,EAAA1B,GAD8BA,KAK9B,IADA,IAAA2B,EAAAD,EAAAxL,OAAA,EACUyL,GAAA,GACV,KAAAD,EAAAC,GADoBA,KAIpB,OAAA3B,EAAA2B,KACAD,EAAApJ,MAAA0H,EAAA2B,EAAA3B,EAAA,GAfAuB,EAAAlO,EAAA4N,QAAAM,GAAA/I,OAAA,GACAgJ,EAAAnO,EAAA4N,QAAAO,GAAAhJ,OAAA,GAsBA,IALA,IAAAoJ,EAAAH,EAAAF,EAAAjK,MAAA,MACAuK,EAAAJ,EAAAD,EAAAlK,MAAA,MAEApB,EAAA4L,KAAAC,IAAAH,EAAA1L,OAAA2L,EAAA3L,QACA8L,EAAA9L,EACArC,EAAA,EAAiBA,EAAAqC,EAAYrC,IAC7B,GAAA+N,EAAA/N,KAAAgO,EAAAhO,GAAA,CACAmO,EAAAnO,EACA,MAIA,IAAAoO,KACA,IAAApO,EAAAmO,EAA+BnO,EAAA+N,EAAA1L,OAAsBrC,IACrDoO,EAAAjB,KAAA,MAKA,OAFAiB,IAAAC,OAAAL,EAAAvJ,MAAA0J,KAEAvK,KAAA,MAGApE,EAAA8O,IAAA,IACA9O,EAAA+O,UAAA,IAEA/O,EAAAgP,QAAA,SAAAxL,GACA,IAAAsG,EAAAsD,EAAA5J,GACA1D,EAAAgK,EAAA,GACAmF,EAAAnF,EAAA,GAEA,OAAAhK,GAAAmP,GAKAA,IAEAA,IAAA9J,OAAA,EAAA8J,EAAApM,OAAA,IAGA/C,EAAAmP,GARA,KAYAjP,EAAAkP,SAAA,SAAA1L,EAAA2L,GACA,IAAA1B,EAAAL,EAAA5J,GAAA,GAKA,OAHA2L,GAAA1B,EAAAtI,QAAA,EAAAgK,EAAAtM,UAAAsM,IACA1B,IAAAtI,OAAA,EAAAsI,EAAA5K,OAAAsM,EAAAtM,SAEA4K,GAIAzN,EAAAoP,QAAA,SAAA5L,GACA,OAAA4J,EAAA5J,GAAA,IAaA,IAAA2B,EAAA,WAAAA,QAAA,GACA,SAAAyB,EAAA+F,EAAA0C,GAAkC,OAAAzI,EAAAzB,OAAAwH,EAAA0C,IAClC,SAAAzI,EAAA+F,EAAA0C,GAEA,OADA1C,EAAA,IAAAA,EAAA/F,EAAA/D,OAAA8J,GACA/F,EAAAzB,OAAAwH,EAAA0C,qDC3NArP,EAAA4B,YAAA,EAEA,IAEA0N,EAAA1G,EAFctI,EAAQ,KAMtBiP,EAAA3G,EAFatI,EAAQ,KAIrB,SAAAsI,EAAAF,GAAsC,OAAAA,KAAA9G,WAAA8G,GAAuCC,QAAAD,GAyB7E1I,EAAA2I,QAvBA,SAAA6G,EAAAjG,GACA,IAAAG,EAAA,IAAA6F,EAAA5G,QAAA6G,EAAAjG,GACAkG,EAAA,IAAAH,EAAA3G,QAAAe,GACA,IACA+F,EAAA3I,QACG,MAAA4I,GAYH,MAAAA,EAGA,OAAAD,EAAA3P,MAIAG,EAAAD,UAAA,sCCpCAA,EAAA4B,YAAA,EAsBA,IAAA+N,EAAA,SAAArI,GAGA,SAAAqI,EAAApI,IAjBA,SAAAC,EAAAC,GAAiD,KAAAD,aAAAC,GAA0C,UAAAC,UAAA,qCAkB3FC,CAAAC,KAAA+H,GAEA,IAAA9H,EAlBA,SAAAC,EAAAnH,GAAiD,IAAAmH,EAAa,UAAAC,eAAA,6DAAyF,OAAApH,GAAA,iBAAAA,GAAA,mBAAAA,EAAAmH,EAAAnH,EAkBvJqH,CAAAJ,KAAAN,EAAA3G,KAAAiH,KAAAL,IAGA,OADAM,EAAAI,KAAA,UACAJ,EAsBA,OAzCA,SAAAK,EAAAC,GAA0C,sBAAAA,GAAA,OAAAA,EAA+D,UAAAT,UAAA,kEAAAS,GAAuGD,EAAA9F,UAAAlB,OAAAY,OAAAqG,KAAA/F,WAAyEgG,aAAe3G,MAAAyG,EAAA9G,YAAA,EAAAiH,UAAA,EAAAC,cAAA,KAA6EH,IAAAjH,OAAAqH,eAAArH,OAAAqH,eAAAL,EAAAC,GAAAD,EAAAM,UAAAL,GAWrXM,CAAAkH,EAAArI,GA8BAqI,EA/BA,CAhBA,SAAAjH,GAAsC,OAAAA,KAAA9G,WAAA8G,GAAuCC,QAAAD,GAF7EE,CAFYtI,EAAQ,IAoDnBqI,SAED3I,EAAA2I,QAAAgH,EACA1P,EAAAD,UAAA,sCCzDAA,EAAA4B,YAAA,EAgCA,IAAAgO,EAAA,SAAAC,GAGA,SAAAD,EAAArI,IA3BA,SAAAC,EAAAC,GAAiD,KAAAD,aAAAC,GAA0C,UAAAC,UAAA,qCA4B3FC,CAAAC,KAAAgI,GAEA,IAAA/H,EA5BA,SAAAC,EAAAnH,GAAiD,IAAAmH,EAAa,UAAAC,eAAA,6DAAyF,OAAApH,GAAA,iBAAAA,GAAA,mBAAAA,EAAAmH,EAAAnH,EA4BvJqH,CAAAJ,KAAAiI,EAAAlP,KAAAiH,KAAAL,IAGA,OADAM,EAAAI,KAAA,SACAJ,EAkFA,OA/GA,SAAAK,EAAAC,GAA0C,sBAAAA,GAAA,OAAAA,EAA+D,UAAAT,UAAA,kEAAAS,GAAuGD,EAAA9F,UAAAlB,OAAAY,OAAAqG,KAAA/F,WAAyEgG,aAAe3G,MAAAyG,EAAA9G,YAAA,EAAAiH,UAAA,EAAAC,cAAA,KAA6EH,IAAAjH,OAAAqH,eAAArH,OAAAqH,eAAAL,EAAAC,GAAAD,EAAAM,UAAAL,GAqBrXM,CAAAmH,EAAAC,GAWAD,EAAAxN,UAAA0N,OAAA,WACA,IAAAC,EAEAnI,KAAAwD,QAAAxD,KAAAwD,UAEA,QAAAD,EAAAvI,UAAAC,OAAAmN,EAAA9K,MAAAiG,GAAAE,EAAA,EAAuEA,EAAAF,EAAaE,IACpF2E,EAAA3E,GAAAzI,UAAAyI,GAGA,OAAA0E,EAAAF,EAAAzN,UAAA0N,QAAAnP,KAAAsP,MAAAF,GAAAnI,MAAAiH,OAAAmB,KAGAJ,EAAAxN,UAAA8N,QAAA,WACA,IAAAC,EAEAvI,KAAAwD,QAAAxD,KAAAwD,UAEA,QAAAgF,EAAAxN,UAAAC,OAAAmN,EAAA9K,MAAAkL,GAAAC,EAAA,EAA0EA,EAAAD,EAAeC,IACzFL,EAAAK,GAAAzN,UAAAyN,GAGA,OAAAF,EAAAN,EAAAzN,UAAA8N,SAAAvP,KAAAsP,MAAAE,GAAAvI,MAAAiH,OAAAmB,KA0DAJ,EA3FA,CA1BA,SAAAlH,GAAsC,OAAAA,KAAA9G,WAAA8G,GAAuCC,QAAAD,GAF7EE,CAFiBtI,EAAQ,IA0HxBqI,SAED3I,EAAA2I,QAAAiH,EACA3P,EAAAD,UAAA,sCC/HAA,EAAA4B,YAAA,EAEA,IAAA0O,EAAA,WAAgC,SAAAC,EAAAC,EAAAC,GAA2C,QAAAjQ,EAAA,EAAgBA,EAAAiQ,EAAA5N,OAAkBrC,IAAA,CAAO,IAAAkQ,EAAAD,EAAAjQ,GAA2BkQ,EAAAtP,WAAAsP,EAAAtP,aAAA,EAAwDsP,EAAApI,cAAA,EAAgC,UAAAoI,MAAArI,UAAA,GAAuDnH,OAAAC,eAAAqP,EAAAE,EAAA3O,IAAA2O,IAA+D,gBAAAjJ,EAAAkJ,EAAAC,GAA2L,OAAlID,GAAAJ,EAAA9I,EAAArF,UAAAuO,GAAqEC,GAAAL,EAAA9I,EAAAmJ,GAA6DnJ,GAAxhB,GAIAoJ,EAAAjI,EAFmBtI,EAAQ,IAM3BwQ,EAAAlI,EAFetI,EAAQ,IAQvB,SAAAsI,EAAAF,GAAsC,OAAAA,KAAA9G,WAAA8G,GAAuCC,QAAAD,GA2B7E,IAAAqI,EAAA,SAAAzJ,GAGA,SAAAyJ,IAGA,OA/BA,SAAAvJ,EAAAC,GAAiD,KAAAD,aAAAC,GAA0C,UAAAC,UAAA,qCA6B3FC,CAAAC,KAAAmJ,GA3BA,SAAAjJ,EAAAnH,GAAiD,IAAAmH,EAAa,UAAAC,eAAA,6DAAyF,OAAApH,GAAA,iBAAAA,GAAA,mBAAAA,EAAAmH,EAAAnH,EA6BvJqH,CAAAJ,KAAAN,EAAA2I,MAAArI,KAAAhF,YAsyBA,OAj0BA,SAAAsF,EAAAC,GAA0C,sBAAAA,GAAA,OAAAA,EAA+D,UAAAT,UAAA,kEAAAS,GAAuGD,EAAA9F,UAAAlB,OAAAY,OAAAqG,KAAA/F,WAAyEgG,aAAe3G,MAAAyG,EAAA9G,YAAA,EAAAiH,UAAA,EAAAC,cAAA,KAA6EH,IAAAjH,OAAAqH,eAAArH,OAAAqH,eAAAL,EAAAC,GAAAD,EAAAM,UAAAL,GAsBrXM,CAAAsI,EAAAzJ,GAQAyJ,EAAA3O,UAAAuL,KAAA,SAAAqD,GAGA,OAFAA,EAAA7G,OAAAvC,KACAA,KAAAwD,MAAAuC,KAAAqD,GACApJ,MAsCAmJ,EAAA3O,UAAA6O,KAAA,SAAAC,GACAtJ,KAAAuJ,WAAAvJ,KAAAuJ,SAAA,GACAvJ,KAAAwJ,UAAAxJ,KAAAwJ,YAEAxJ,KAAAuJ,UAAA,EACA,IAAAE,EAAAzJ,KAAAuJ,SAGA,GAFAvJ,KAAAwJ,QAAAC,GAAA,EAEAzJ,KAAAwD,MAAA,CAIA,IAFA,IAAArG,OAAA,EACA+E,OAAA,EACAlC,KAAAwJ,QAAAC,GAAAzJ,KAAAwD,MAAAvI,SACAkC,EAAA6C,KAAAwJ,QAAAC,IAEA,KADAvH,EAAAoH,EAAAtJ,KAAAwD,MAAArG,SAGA6C,KAAAwJ,QAAAC,IAAA,EAKA,cAFAzJ,KAAAwJ,QAAAC,GAEAvH,IAwBAiH,EAAA3O,UAAAkP,KAAA,SAAAJ,GACA,OAAAtJ,KAAAqJ,KAAA,SAAAD,EAAAxQ,GACA,IAAAsJ,OAAA,EACA,IACAA,EAAAoH,EAAAF,EAAAxQ,GACO,MAAAkP,GAEP,GADAA,EAAA6B,YAAAP,EACAtB,EAAA8B,OAAAR,EAAA7K,QAAA,aAA+CxB,KAAA+K,EAAA8B,OAAA,CAC/C,IAAAjP,EAAAyO,EAAA7K,OACAuJ,EAAA8B,MAAA9B,EAAA8B,MAAA9M,QAAA,aAA4C,KAAAnC,EAAAmH,MAAAwE,KAAA,IAAA3L,EAAAoK,MAAAhD,KAAA,IAAApH,EAAAoK,MAAA/C,OAAA,MAE5C,MAAA8F,EAKA,OAHA,IAAA5F,GAAAkH,EAAAM,OACAxH,EAAAkH,EAAAM,KAAAJ,IAEApH,KAmCAiH,EAAA3O,UAAAqP,UAAA,SAAArF,EAAA8E,GACA,OAAAA,EAOK9E,aAAAsF,OACL9J,KAAA0J,KAAA,SAAAN,EAAAxQ,GACA,YAAAwQ,EAAA/I,MAAAmE,EAAAzH,KAAAqM,EAAA5E,MACA,OAAA8E,EAAAF,EAAAxQ,KAIAoH,KAAA0J,KAAA,SAAAN,EAAAxQ,GACA,YAAAwQ,EAAA/I,MAAA+I,EAAA5E,SACA,OAAA8E,EAAAF,EAAAxQ,MAfA0Q,EAAA9E,EACAxE,KAAA0J,KAAA,SAAAN,EAAAxQ,GACA,YAAAwQ,EAAA/I,KACA,OAAAiJ,EAAAF,EAAAxQ,OA2CAuQ,EAAA3O,UAAAuP,UAAA,SAAAC,EAAAV,GACA,OAAAA,EAQKU,aAAAF,OACL9J,KAAA0J,KAAA,SAAAN,EAAAxQ,GACA,YAAAwQ,EAAA/I,MAAA2J,EAAAjN,KAAAqM,EAAAY,UACA,OAAAV,EAAAF,EAAAxQ,KAIAoH,KAAA0J,KAAA,SAAAN,EAAAxQ,GACA,YAAAwQ,EAAA/I,MAAA+I,EAAAY,aACA,OAAAV,EAAAF,EAAAxQ,MAhBA0Q,EAAAU,EAEAhK,KAAA0J,KAAA,SAAAN,EAAAxQ,GACA,YAAAwQ,EAAA/I,KACA,OAAAiJ,EAAAF,EAAAxQ,OAkDAuQ,EAAA3O,UAAAyP,YAAA,SAAA9Q,EAAAmQ,GACA,OAAAA,EAOKnQ,aAAA2Q,OACL9J,KAAA0J,KAAA,SAAAN,EAAAxQ,GACA,cAAAwQ,EAAA/I,MAAAlH,EAAA4D,KAAAqM,EAAAjQ,MACA,OAAAmQ,EAAAF,EAAAxQ,KAIAoH,KAAA0J,KAAA,SAAAN,EAAAxQ,GACA,cAAAwQ,EAAA/I,MAAA+I,EAAAjQ,SACA,OAAAmQ,EAAAF,EAAAxQ,MAfA0Q,EAAAnQ,EACA6G,KAAA0J,KAAA,SAAAN,EAAAxQ,GACA,cAAAwQ,EAAA/I,KACA,OAAAiJ,EAAAF,EAAAxQ,OAoCAuQ,EAAA3O,UAAA0P,aAAA,SAAAZ,GACA,OAAAtJ,KAAA0J,KAAA,SAAAN,EAAAxQ,GACA,eAAAwQ,EAAA/I,KACA,OAAAiJ,EAAAF,EAAAxQ,MA2BAuQ,EAAA3O,UAAA0N,OAAA,WACA,QAAA3E,EAAAvI,UAAAC,OAAAmN,EAAA9K,MAAAiG,GAAAE,EAAA,EAAuEA,EAAAF,EAAaE,IACpF2E,EAAA3E,GAAAzI,UAAAyI,GAGA,IAAAC,EAAA0E,EAAAzE,EAAArG,MAAAsG,QAAAF,GAAAG,EAAA,MAAAH,EAAAC,EAAAD,IAAA/J,OAAAuH,cAAiJ,CACjJ,IAAA4C,EAEA,GAAAH,EAAA,CACA,GAAAE,GAAAH,EAAAzI,OAAA,MACA6I,EAAAJ,EAAAG,SACO,CAEP,IADAA,EAAAH,EAAAK,QACAC,KAAA,MACAF,EAAAD,EAAAhK,MAGA,IAAAuP,EAAAtF,EAGAqG,EADAnK,KAAAhE,UAAAoN,EAAApJ,KAAAqF,MACA+E,EAAA9M,MAAAsG,QAAAuG,GAAAE,EAAA,MAAAF,EAAAC,EAAAD,IAAAxQ,OAAAuH,cAAwJ,CACxJ,IAAAoJ,EAEA,GAAAF,EAAA,CACA,GAAAC,GAAAF,EAAAlP,OAAA,MACAqP,EAAAH,EAAAE,SACS,CAET,IADAA,EAAAF,EAAApG,QACAC,KAAA,MACAsG,EAAAD,EAAAxQ,MAGA,IAAAwI,EAAAiI,EACAtK,KAAAwD,MAAAuC,KAAA1D,IAGA,OAAArC,MAyBAmJ,EAAA3O,UAAA8N,QAAA,WACA,QAAAE,EAAAxN,UAAAC,OAAAmN,EAAA9K,MAAAkL,GAAAC,EAAA,EAA0EA,EAAAD,EAAeC,IACzFL,EAAAK,GAAAzN,UAAAyN,GAIA,IAAA8B,EADAnC,IAAAoC,UACAC,EAAAnN,MAAAsG,QAAA2G,GAAAG,EAAA,MAAAH,EAAAE,EAAAF,IAAA5Q,OAAAuH,cAAyJ,CACzJ,IAAAyJ,EAEA,GAAAF,EAAA,CACA,GAAAC,GAAAH,EAAAtP,OAAA,MACA0P,EAAAJ,EAAAG,SACO,CAEP,IADAA,EAAAH,EAAAxG,QACAC,KAAA,MACA2G,EAAAD,EAAA7Q,MAGA,IAAAuP,EAAAuB,EAEAnH,EAAAxD,KAAAhE,UAAAoN,EAAApJ,KAAA4K,MAAA,WAAAJ,UACAK,EAAArH,EAAAsH,EAAAxN,MAAAsG,QAAAiH,GAAAE,EAAA,MAAAF,EAAAC,EAAAD,IAAAlR,OAAAuH,cAAwJ,CACxJ,IAAA8J,EAEA,GAAAF,EAAA,CACA,GAAAC,GAAAF,EAAA5P,OAAA,MACA+P,EAAAH,EAAAE,SACS,CAET,IADAA,EAAAF,EAAA9G,QACAC,KAAA,MACAgH,EAAAD,EAAAlR,MAGA,IAAAwI,EAAA2I,EACAhL,KAAAwD,MAAA8B,QAAAjD,GACO,QAAAoH,KAAAzJ,KAAAwJ,QACPxJ,KAAAwJ,QAAAC,GAAAzJ,KAAAwJ,QAAAC,GAAAjG,EAAAvI,OAGA,OAAA+E,MAGAmJ,EAAA3O,UAAAkK,UAAA,SAAAC,GAEA,GADAjF,EAAAlF,UAAAkK,UAAA3L,KAAAiH,KAAA2E,GACA3E,KAAAwD,MACA,KAAAyH,EAAAjL,KAAAwD,MAAA0H,EAAA5N,MAAAsG,QAAAqH,GAAAE,EAAA,MAAAF,EAAAC,EAAAD,IAAAtR,OAAAuH,cAA6J,CAC7J,IAAAkK,EAEA,GAAAF,EAAA,CACA,GAAAC,GAAAF,EAAAhQ,OAAA,MACAmQ,EAAAH,EAAAE,SACS,CAET,IADAA,EAAAF,EAAAlH,QACAC,KAAA,MACAoH,EAAAD,EAAAtR,MAGAuR,EACA1G,UAAAC,MAkBAwE,EAAA3O,UAAA2I,aAAA,SAAAkI,EAAAlH,GAGA,IAAA9D,EAAA,KAFAgL,EAAArL,KAAA7C,MAAAkO,KAEA,UACA7H,EAAAxD,KAAAhE,UAAAmI,EAAAnE,KAAAwD,MAAA6H,GAAAhL,GAAAmK,UACAc,EAAA9H,EAAA+H,EAAAjO,MAAAsG,QAAA0H,GAAAE,EAAA,MAAAF,EAAAC,EAAAD,IAAA3R,OAAAuH,cAAsJ,CACtJ,IAAAuK,EAEA,GAAAF,EAAA,CACA,GAAAC,GAAAF,EAAArQ,OAAA,MACAwQ,EAAAH,EAAAE,SACO,CAEP,IADAA,EAAAF,EAAAvH,QACAC,KAAA,MACAyH,EAAAD,EAAA3R,MAGA,IAAAwI,EAAAoJ,EACAzL,KAAAwD,MAAAjH,OAAA8O,EAAA,EAAAhJ,GACK,IAAAlF,OAAA,EACL,QAAAsM,KAAAzJ,KAAAwJ,QAEA6B,IADAlO,EAAA6C,KAAAwJ,QAAAC,MAEAzJ,KAAAwJ,QAAAC,GAAAtM,EAAAqG,EAAAvI,QAIA,OAAA+E,MAaAmJ,EAAA3O,UAAA6I,YAAA,SAAAgI,EAAAlH,GACAkH,EAAArL,KAAA7C,MAAAkO,GAEA,IAAA7H,EAAAxD,KAAAhE,UAAAmI,EAAAnE,KAAAwD,MAAA6H,IAAAb,UACAkB,EAAAlI,EAAAmI,EAAArO,MAAAsG,QAAA8H,GAAAE,EAAA,MAAAF,EAAAC,EAAAD,IAAA/R,OAAAuH,cAAsJ,CACtJ,IAAA2K,EAEA,GAAAF,EAAA,CACA,GAAAC,GAAAF,EAAAzQ,OAAA,MACA4Q,EAAAH,EAAAE,SACO,CAEP,IADAA,EAAAF,EAAA3H,QACAC,KAAA,MACA6H,EAAAD,EAAA/R,MAGA,IAAAwI,EAAAwJ,EACA7L,KAAAwD,MAAAjH,OAAA8O,EAAA,IAAAhJ,GACK,IAAAlF,OAAA,EACL,QAAAsM,KAAAzJ,KAAAwJ,QAEA6B,GADAlO,EAAA6C,KAAAwJ,QAAAC,MAEAzJ,KAAAwJ,QAAAC,GAAAtM,EAAAqG,EAAAvI,QAIA,OAAA+E,MAmBAmJ,EAAA3O,UAAAgI,YAAA,SAAA4G,GACAA,EAAApJ,KAAA7C,MAAAiM,GACApJ,KAAAwD,MAAA4F,GAAA7G,YAAAhB,EACAvB,KAAAwD,MAAAjH,OAAA6M,EAAA,GAEA,IAAAjM,OAAA,EACA,QAAAsM,KAAAzJ,KAAAwJ,SACArM,EAAA6C,KAAAwJ,QAAAC,KACAL,IACApJ,KAAAwJ,QAAAC,GAAAtM,EAAA,GAIA,OAAA6C,MAeAmJ,EAAA3O,UAAAsR,UAAA,WACA,IAAAC,EAAA/L,KAAAwD,MAAAwI,EAAA1O,MAAAsG,QAAAmI,GAAAE,EAAA,MAAAF,EAAAC,EAAAD,IAAApS,OAAAuH,cAA2J,CAC3J,IAAAgL,EAEA,GAAAF,EAAA,CACA,GAAAC,GAAAF,EAAA9Q,OAAA,MACAiR,EAAAH,EAAAE,SACO,CAEP,IADAA,EAAAF,EAAAhI,QACAC,KAAA,MACAkI,EAAAD,EAAApS,MAGAqS,EACA3J,YAAAhB,EAEA,OADKvB,KAAAwD,SACLxD,MA+BAmJ,EAAA3O,UAAA2R,cAAA,SAAAC,EAAAzK,EAAA2H,GAaA,OAZAA,IACAA,EAAA3H,EACAA,MAGA3B,KAAA6J,UAAA,SAAAwC,GACA1K,EAAAkH,QAAA,IAAAlH,EAAAkH,MAAA3L,QAAAmP,EAAA7H,OACA7C,EAAA2K,OAAA,IAAAD,EAAAxS,MAAAqD,QAAAyE,EAAA2K,QAEAD,EAAAxS,MAAAwS,EAAAxS,MAAAiD,QAAAsP,EAAA9C,MAGAtJ,MAgBAmJ,EAAA3O,UAAA+R,MAAA,SAAAC,GACA,OAAAxM,KAAAwD,MAAA+I,MAAAC,IAgBArD,EAAA3O,UAAAiS,KAAA,SAAAD,GACA,OAAAxM,KAAAwD,MAAAiJ,KAAAD,IAeArD,EAAA3O,UAAA2C,MAAA,SAAAiM,GACA,uBAAAA,EACAA,EAEApJ,KAAAwD,MAAAtG,QAAAkM,IAcAD,EAAA3O,UAAAwB,UAAA,SAAAwH,EAAAkJ,GACA,IAAAC,EAAA3M,KAEA,oBAAAwD,EAEAA,EAntBA,SAAAoJ,EAAApJ,GACA,OAAAA,EAAAR,IAAA,SAAApK,GAGA,OAFAA,EAAA4K,QAAA5K,EAAA4K,MAAAoJ,EAAAhU,EAAA4K,eACA5K,EAAA2F,OACA3F,IA+sBAgU,CADkBlU,EAAQ,EAC1BwG,CAAAsE,eACK,GAAAlG,MAAAsG,QAAAJ,GAEL,KAAAqJ,EADArJ,IAAAnG,MAAA,GACAyP,EAAAxP,MAAAsG,QAAAiJ,GAAAE,EAAA,MAAAF,EAAAC,EAAAD,IAAAlT,OAAAuH,cAAwJ,CACxJ,IAAA8L,EAEA,GAAAF,EAAA,CACA,GAAAC,GAAAF,EAAA5R,OAAA,MACA+R,EAAAH,EAAAE,SACS,CAET,IADAA,EAAAF,EAAA9I,QACAC,KAAA,MACAgJ,EAAAD,EAAAlT,MAGA,IAAAjB,EAAAoU,EAEApU,EAAA2J,QAAA3J,EAAA2J,OAAAC,YAAA5J,EAAA,gBAEK,YAAA4K,EAAAnD,KAEL,KAAA4M,EADAzJ,UAAAnG,MAAA,GACA6P,EAAA5P,MAAAsG,QAAAqJ,GAAAE,EAAA,MAAAF,EAAAC,EAAAD,IAAAtT,OAAAuH,cAAgK,CAChK,IAAAkM,EAEA,GAAAF,EAAA,CACA,GAAAC,GAAAF,EAAAhS,OAAA,MACAmS,EAAAH,EAAAE,SACS,CAET,IADAA,EAAAF,EAAAlJ,QACAC,KAAA,MACAoJ,EAAAD,EAAAtT,MAGA,IAAAwT,EAAAD,EAEAC,EAAA9K,QAAA8K,EAAA9K,OAAAC,YAAA6K,EAAA,gBAEK,GAAA7J,EAAAnD,KACLmD,WACK,GAAAA,EAAAgB,KAAA,CACL,YAAAhB,EAAA3J,MACA,UAAAqB,MAAA,0CACO,iBAAAsI,EAAA3J,QACP2J,EAAA3J,MAAAyT,OAAA9J,EAAA3J,QAEA2J,GAAA,IAAAyF,EAAAlI,QAAAyC,SACK,GAAAA,EAAAwG,SAAA,CAELxG,GAAA,IADiB9K,EAAQ,GACzB,CAAA8K,SACK,GAAAA,EAAArK,KAAA,CAELqK,GAAA,IADmB9K,EAAQ,GAC3B,CAAA8K,QACK,KAAAA,EAAArB,KAGL,UAAAjH,MAAA,sCAFAsI,GAAA,IAAA0F,EAAAnI,QAAAyC,IAgBA,OAXAA,EAAAR,IAAA,SAAApK,GAQA,OAPAA,EAAA2J,QAAA3J,EAAA2J,OAAAC,YAAA5J,QACA,IAAAA,EAAA4I,KAAA0C,QACAwI,QAAA,IAAAA,EAAAlL,KAAA0C,SACAtL,EAAA4I,KAAA0C,OAAAwI,EAAAlL,KAAA0C,OAAApH,QAAA,cAGAlE,EAAA2J,OAAAoK,EACA/T,KAkBA8P,EAAAS,IACAhP,IAAA,QACAV,IAAA,WACA,GAAAuG,KAAAwD,MACA,OAAAxD,KAAAwD,MAAA,MAaArJ,IAAA,OACAV,IAAA,WACA,GAAAuG,KAAAwD,MACA,OAAAxD,KAAAwD,MAAAxD,KAAAwD,MAAAvI,OAAA,OAIAkO,EA5yBA,CA7BAnI,EAFYtI,EAAQ,IA40BnBqI,SAED3I,EAAA2I,QAAAoI,EAiBA9Q,EAAAD,UAAA,sCC32BAA,EAAA4B,YAAA,EAEA,IAAA0O,EAAA,WAAgC,SAAAC,EAAAC,EAAAC,GAA2C,QAAAjQ,EAAA,EAAgBA,EAAAiQ,EAAA5N,OAAkBrC,IAAA,CAAO,IAAAkQ,EAAAD,EAAAjQ,GAA2BkQ,EAAAtP,WAAAsP,EAAAtP,aAAA,EAAwDsP,EAAApI,cAAA,EAAgC,UAAAoI,MAAArI,UAAA,GAAuDnH,OAAAC,eAAAqP,EAAAE,EAAA3O,IAAA2O,IAA+D,gBAAAjJ,EAAAkJ,EAAAC,GAA2L,OAAlID,GAAAJ,EAAA9I,EAAArF,UAAAuO,GAAqEC,GAAAL,EAAA9I,EAAAmJ,GAA6DnJ,GAAxhB,GAIA0N,EAAAvM,EAFiBtI,EAAQ,IAMzB8U,EAAAxM,EAFYtI,EAAQ,KAIpB,SAAAsI,EAAAF,GAAsC,OAAAA,KAAA9G,WAAA8G,GAAuCC,QAAAD,GAmB7E,IAAA2M,EAAA,SAAAxF,GAGA,SAAAwF,EAAA9N,IApBA,SAAAC,EAAAC,GAAiD,KAAAD,aAAAC,GAA0C,UAAAC,UAAA,qCAqB3FC,CAAAC,KAAAyN,GAEA,IAAAxN,EArBA,SAAAC,EAAAnH,GAAiD,IAAAmH,EAAa,UAAAC,eAAA,6DAAyF,OAAApH,GAAA,iBAAAA,GAAA,mBAAAA,EAAAmH,EAAAnH,EAqBvJqH,CAAAJ,KAAAiI,EAAAlP,KAAAiH,KAAAL,IAIA,OAFAM,EAAAI,KAAA,OACAJ,EAAAuD,QAAAvD,EAAAuD,UACAvD,EA0EA,OAjGA,SAAAK,EAAAC,GAA0C,sBAAAA,GAAA,OAAAA,EAA+D,UAAAT,UAAA,kEAAAS,GAAuGD,EAAA9F,UAAAlB,OAAAY,OAAAqG,KAAA/F,WAAyEgG,aAAe3G,MAAAyG,EAAA9G,YAAA,EAAAiH,UAAA,EAAAC,cAAA,KAA6EH,IAAAjH,OAAAqH,eAAArH,OAAAqH,eAAAL,EAAAC,GAAAD,EAAAM,UAAAL,GAcrXM,CAAA4M,EAAAxF,GA8BAS,EAAA+E,IACAtT,IAAA,YACAV,IAAA,WACA,OAAA+T,EAAAzM,QAAA2M,MAAA1N,KAAAgK,WAEA2D,IAAA,SAAAC,GACA,IAAArS,EAAAyE,KAAAgK,SAAAhK,KAAAgK,SAAAzO,MAAA,aACA2L,EAAA3L,IAAA,OAAAyE,KAAAuE,IAAA,wBACAvE,KAAAgK,SAAA4D,EAAApR,KAAA0K,OA6CAuG,EApFA,CAqFCF,EAAAxM,SAED3I,EAAA2I,QAAA0M,EACApV,EAAAD,UAAA,sCCvHAA,EAAA4B,YAAA,EAEA,IAEA6T,EAAA7M,EAFqBtI,EAAQ,KAM7BoV,EAAA9M,EAFatI,EAAQ,KAMrBqV,EAAA/M,EAFyBtI,EAAQ,KAIjC,SAAAsI,EAAAF,GAAsC,OAAAA,KAAA9G,WAAA8G,GAAuCC,QAAAD,GA+B7E,IAAAkN,EAAA,WASA,SAAAA,EAAAtM,EAAAK,EAAAC,EAAAzD,EAAA0P,EAAAC,IAtCA,SAAAtO,EAAAC,GAAiD,KAAAD,aAAAC,GAA0C,UAAAC,UAAA,qCAuC3FC,CAAAC,KAAAgO,GAeAhO,KAAA7G,KAAA,iBASA6G,KAAAmO,OAAAzM,EAEAuM,IAUAjO,KAAAiO,QAEA1P,IAUAyB,KAAAzB,UAEA2P,IASAlO,KAAAkO,eAEA,IAAAnM,QAAA,IAAAC,IAUAhC,KAAA+B,OAUA/B,KAAAgC,UAGAhC,KAAAoO,aAEAlT,MAAAmT,mBACAnT,MAAAmT,kBAAArO,KAAAgO,GA2HA,OAvHAA,EAAAxT,UAAA4T,WAAA,WAUApO,KAAA0B,QAAA1B,KAAAkO,OAAAlO,KAAAkO,OAAA,QACAlO,KAAA0B,SAAA1B,KAAAiO,KAAAjO,KAAAiO,KAAA,mBACA,IAAAjO,KAAA+B,OACA/B,KAAA0B,SAAA,IAAA1B,KAAA+B,KAAA,IAAA/B,KAAAgC,QAEAhC,KAAA0B,SAAA,KAAA1B,KAAAmO,QA0BAH,EAAAxT,UAAA8T,eAAA,SAAAC,GACA,IAAAtO,EAAAD,KAEA,IAAAA,KAAAzB,OAAA,SAEA,IAAAqJ,EAAA5H,KAAAzB,OACAwP,EAAAhN,eACA,IAAAwN,MAAAV,EAAA9M,QAAAyN,QACAD,IAAA3G,GAAA,EAAAmG,EAAAhN,SAAA6G,KAGA,IAAA6G,EAAA7G,EAAAvL,MAAA,SACA0I,EAAA8B,KAAA6H,IAAA1O,KAAA+B,KAAA,KACA2E,EAAAG,KAAAC,IAAA9G,KAAA+B,KAAA,EAAA0M,EAAAxT,QAEA0T,EAAArB,OAAA5G,GAAAzL,OAEA,SAAA2T,EAAAzM,GACA,OAAAoM,GAAAT,EAAA/M,QAAA8N,IACAf,EAAA/M,QAAA8N,IAAAC,KAAA3M,GAEAA,EAGA,SAAA4M,EAAA5M,GACA,OAAAoM,GAAAT,EAAA/M,QAAAiO,KACAlB,EAAA/M,QAAAiO,KAAA7M,GAEAA,EAIA,OAAAsM,EAAApR,MAAA0H,EAAA2B,GAAA1D,IAAA,SAAAjB,EAAA5E,GACA,IAAA8R,EAAAlK,EAAA,EAAA5H,EACA+R,EAAA,SAAAD,GAAA5R,OAAAsR,GAAA,MACA,GAAAM,IAAAhP,EAAA8B,KAAA,CACA,IAAAoN,EAAAJ,EAAAG,EAAApS,QAAA,YAAAiF,EAAA1E,MAAA,EAAA4C,EAAA+B,OAAA,GAAAlF,QAAA,cACA,OAAA8R,EAAA,KAAAG,EAAAG,GAAAnN,EAAA,MAAAoN,EAAAP,EAAA,KAEA,UAAAG,EAAAG,GAAAnN,IAEKvF,KAAA,OAeLwR,EAAAxT,UAAAiI,SAAA,WACA,IAAA2M,EAAApP,KAAAsO,iBAIA,OAHAc,IACAA,EAAA,OAAAA,EAAA,MAEApP,KAAA7G,KAAA,KAAA6G,KAAA0B,QAAA0N,GAiBApB,EA5NA,GA+NA5V,EAAA2I,QAAAiN,EACA3V,EAAAD,UAAA,sCC7QAA,EAAA4B,YAAA,EAIA,IAAAqV,GACAC,MAAA,KACAC,OAAA,OACAC,WAAA,KACAC,WAAA,KACAC,WAAA,IACAC,YAAA,KACAC,cAAA,KACAxL,MAAA,KACAyL,UAAA,GACAC,YAAA,IACAC,aAAA,KAOA,IAAAC,EAAA,WACA,SAAAA,EAAA/K,IArBA,SAAArF,EAAAC,GAAiD,KAAAD,aAAAC,GAA0C,UAAAC,UAAA,qCAsB3FC,CAAAC,KAAAgQ,GAEAhQ,KAAAiF,UAsTA,OAnTA+K,EAAAxV,UAAAmI,UAAA,SAAAN,EAAA4N,GACAjQ,KAAAqC,EAAAhC,MAAAgC,EAAA4N,IAGAD,EAAAxV,UAAAtC,KAAA,SAAAmK,GACArC,KAAAkQ,KAAA7N,GACAA,EAAAb,KAAA4C,OAAApE,KAAAiF,QAAA5C,EAAAb,KAAA4C,QAGA4L,EAAAxV,UAAA2V,QAAA,SAAA9N,GACA,IAAA+N,EAAApQ,KAAAuE,IAAAlC,EAAA,sBACAgO,EAAArQ,KAAAuE,IAAAlC,EAAA,wBACArC,KAAAiF,QAAA,KAAAmL,EAAA/N,EAAAF,KAAAkO,EAAA,KAAAhO,IAGA2N,EAAAxV,UAAA6R,KAAA,SAAAhK,EAAA4N,GACA,IAAArL,EAAA5E,KAAAuE,IAAAlC,EAAA,mBACAyC,EAAAzC,EAAAmC,KAAAI,EAAA5E,KAAAsQ,SAAAjO,EAAA,SAEAA,EAAAkO,YACAzL,GAAAzC,EAAAb,KAAA+O,WAAA,eAGAN,IAAAnL,GAAA,KACA9E,KAAAiF,QAAAH,EAAAzC,IAGA2N,EAAAxV,UAAAgW,KAAA,SAAAnO,GACArC,KAAAyQ,MAAApO,EAAArC,KAAAsQ,SAAAjO,EAAA,aACAA,EAAAb,KAAAkP,cACA1Q,KAAAiF,QAAA5C,EAAAb,KAAAkP,aAAArO,EAAA,QAIA2N,EAAAxV,UAAAmW,OAAA,SAAAtO,EAAA4N,GACA,IAAA9W,EAAA,IAAAkJ,EAAAlJ,KACAyX,EAAAvO,EAAAuO,OAAA5Q,KAAAsQ,SAAAjO,EAAA,aAQA,QANA,IAAAA,EAAAb,KAAAqP,UACA1X,GAAAkJ,EAAAb,KAAAqP,UACKD,IACLzX,GAAA,KAGAkJ,EAAAmB,MACAxD,KAAAyQ,MAAApO,EAAAlJ,EAAAyX,OACK,CACL,IAAAlK,GAAArE,EAAAb,KAAAoD,SAAA,KAAAqL,EAAA,IAA2D,IAC3DjQ,KAAAiF,QAAA9L,EAAAyX,EAAAlK,EAAArE,KAIA2N,EAAAxV,UAAA0V,KAAA,SAAA7N,GAEA,IADA,IAAAgD,EAAAhD,EAAAmB,MAAAvI,OAAA,EACAoK,EAAA,GACA,YAAAhD,EAAAmB,MAAA6B,GAAAhF,MACAgF,GAAA,EAIA,IADA,IAAA4K,EAAAjQ,KAAAuE,IAAAlC,EAAA,aACAzJ,EAAA,EAAmBA,EAAAyJ,EAAAmB,MAAAvI,OAAuBrC,IAAA,CAC1C,IAAAwQ,EAAA/G,EAAAmB,MAAA5K,GACAsL,EAAAlE,KAAAuE,IAAA6E,EAAA,UACAlF,GAAAlE,KAAAiF,QAAAf,GACAlE,KAAA2C,UAAAyG,EAAA/D,IAAAzM,GAAAqX,KAIAD,EAAAxV,UAAAiW,MAAA,SAAApO,EAAA0C,GACA,IAAAH,EAAA5E,KAAAuE,IAAAlC,EAAA,wBACArC,KAAAiF,QAAAF,EAAAH,EAAA,IAAqCvC,EAAA,SAErC,IAAA+B,OAAA,EACA/B,EAAAmB,OAAAnB,EAAAmB,MAAAvI,QACA+E,KAAAkQ,KAAA7N,GACA+B,EAAApE,KAAAuE,IAAAlC,EAAA,UAEA+B,EAAApE,KAAAuE,IAAAlC,EAAA,qBAGA+B,GAAApE,KAAAiF,QAAAb,GACApE,KAAAiF,QAAA,IAAmB5C,EAAA,QAGnB2N,EAAAxV,UAAA+J,IAAA,SAAAlC,EAAAyO,EAAAC,GACA,IAAAlX,OAAA,EAIA,GAHAkX,MAAAD,GAGAA,QAEA,KADAjX,EAAAwI,EAAAb,KAAAsP,IACA,OAAAjX,EAGA,IAAA0I,EAAAF,EAAAE,OAGA,cAAAwO,KACAxO,GAAA,SAAAA,EAAAlC,MAAAkC,EAAAqI,QAAAvI,GACA,SAKA,IAAAE,EAAA,OAAA8M,EAAA0B,GAGA,IAAA7Y,EAAAmK,EAAAnK,OAEA,GADAA,EAAA8Y,WAAA9Y,EAAA8Y,kBACA,IAAA9Y,EAAA8Y,SAAAD,GACA,OAAA7Y,EAAA8Y,SAAAD,GAGA,cAAAA,GAAA,UAAAA,EACA,OAAA/Q,KAAAiR,YAAA5O,EAAA0O,GAEA,IAAAG,EAAA,MA/HA,SAAAlS,GACA,OAAAA,EAAA,GAAAmS,cAAAnS,EAAA3B,MAAA,GA8HA+T,CAAAL,GAcA,OAbA/Q,KAAAkR,GACArX,EAAAmG,KAAAkR,GAAAhZ,EAAAmK,GAEAnK,EAAAwR,KAAA,SAAA9Q,GAEA,aADAiB,EAAAjB,EAAA4I,KAAAsP,IACA,gBAKA,IAAAjX,MAAAwV,EAAA0B,IAEA7Y,EAAA8Y,SAAAD,GAAAlX,EACAA,GAGAmW,EAAAxV,UAAA6W,aAAA,SAAAnZ,GACA,IAAA2B,OAAA,EAOA,OANA3B,EAAAwR,KAAA,SAAA9Q,GACA,GAAAA,EAAA4K,OAAA5K,EAAA4K,MAAAvI,QAAA,SAAArC,EAAAyM,KAAAhF,WAEA,KADAxG,EAAAjB,EAAA4I,KAAAyO,WACA,WAGApW,GAGAmW,EAAAxV,UAAA8W,aAAA,SAAApZ,GACA,IAAA2B,OAAA,EAOA,OANA3B,EAAAwR,KAAA,SAAA9Q,GACA,GAAAA,EAAA4K,OAAA,IAAA5K,EAAA4K,MAAAvI,aAEA,KADApB,EAAAjB,EAAA4I,KAAA4C,OACA,WAGAvK,GAGAmW,EAAAxV,UAAA+W,UAAA,SAAArZ,GACA,GAAAA,EAAAsJ,KAAA+N,OAAA,OAAArX,EAAAsJ,KAAA+N,OACA,IAAA1V,OAAA,EAYA,OAXA3B,EAAAwR,KAAA,SAAA9Q,GACA,IAAA8B,EAAA9B,EAAA2J,OACA,GAAA7H,OAAAxC,GAAAwC,EAAA6H,QAAA7H,EAAA6H,SAAArK,QACA,IAAAU,EAAA4I,KAAA0C,OAAA,CACA,IAAA9H,EAAAxD,EAAA4I,KAAA0C,OAAA7H,MAAA,MAGA,OADAxC,GADAA,EAAAuC,IAAAnB,OAAA,IACA6B,QAAA,cACA,KAIAjD,GAGAmW,EAAAxV,UAAAgX,iBAAA,SAAAtZ,EAAAmK,GACA,IAAAxI,OAAA,EAeA,OAdA3B,EAAAgS,aAAA,SAAAtR,GACA,YAAAA,EAAA4I,KAAA0C,OAKA,OAHA,KADArK,EAAAjB,EAAA4I,KAAA0C,QACAhH,QAAA,QACArD,IAAAiD,QAAA,gBAEA,SAGA,IAAAjD,EACAA,EAAAmG,KAAAuE,IAAAlC,EAAA,mBACKxI,IACLA,IAAAiD,QAAA,cAEAjD,GAGAmW,EAAAxV,UAAAiX,cAAA,SAAAvZ,EAAAmK,GACA,IAAAxI,OAAA,EAeA,OAdA3B,EAAA2R,UAAA,SAAAjR,GACA,YAAAA,EAAA4I,KAAA0C,OAKA,OAHA,KADArK,EAAAjB,EAAA4I,KAAA0C,QACAhH,QAAA,QACArD,IAAAiD,QAAA,gBAEA,SAGA,IAAAjD,EACAA,EAAAmG,KAAAuE,IAAAlC,EAAA,mBACKxI,IACLA,IAAAiD,QAAA,cAEAjD,GAGAmW,EAAAxV,UAAAkX,cAAA,SAAAxZ,GACA,IAAA2B,OAAA,EAaA,OAZA3B,EAAAwR,KAAA,SAAA9Q,GACA,GAAAA,EAAA4K,QAAA5K,EAAA2J,SAAArK,KAAA0S,QAAAhS,SACA,IAAAA,EAAA4I,KAAA0C,OAKA,OAHA,KADArK,EAAAjB,EAAA4I,KAAA0C,QACAhH,QAAA,QACArD,IAAAiD,QAAA,gBAEA,IAIAjD,QAAAiD,QAAA,cACAjD,GAGAmW,EAAAxV,UAAAmX,eAAA,SAAAzZ,GACA,IAAA2B,OAAA,EAaA,OAZA3B,EAAAwR,KAAA,SAAA9Q,GACA,GAAAA,EAAA4K,OAAA5K,EAAA4K,MAAAvI,OAAA,QACA,IAAArC,EAAA4I,KAAA4C,MAKA,OAHA,KADAvK,EAAAjB,EAAA4I,KAAA4C,OACAlH,QAAA,QACArD,IAAAiD,QAAA,gBAEA,IAIAjD,QAAAiD,QAAA,cACAjD,GAGAmW,EAAAxV,UAAAoX,cAAA,SAAA1Z,GACA,IAAA2B,OAAA,EAOA,OANA3B,EAAAwR,KAAA,SAAA9Q,GACA,YAAAA,EAAAyH,WAEA,KADAxG,EAAAjB,EAAA4I,KAAAoD,SACA,WAGA/K,GAGAmW,EAAAxV,UAAAqX,SAAA,SAAA3Z,GACA,IAAA2B,OAAA,EAOA,OANA3B,EAAA2R,UAAA,SAAAjR,GACA,YAAAA,EAAA4I,KAAAoD,QAEA,OADA/K,EAAAjB,EAAA4I,KAAAoD,QAAA9H,QAAA,eACA,IAGAjD,GAGAmW,EAAAxV,UAAAyW,YAAA,SAAA5O,EAAA0O,GACA,IAAAlX,OAAA,EAEAA,EADA,SAAAwI,EAAAhC,KACAL,KAAAuE,IAAAlC,EAAA,mBACK,YAAAA,EAAAhC,KACLL,KAAAuE,IAAAlC,EAAA,sBACK,WAAA0O,EACL/Q,KAAAuE,IAAAlC,EAAA,mBAEArC,KAAAuE,IAAAlC,EAAA,oBAKA,IAFA,IAAAyP,EAAAzP,EAAAE,OACAwP,EAAA,EACAD,GAAA,SAAAA,EAAAzR,MACA0R,GAAA,EACAD,IAAAvP,OAGA,QAAA1I,EAAAqD,QAAA,OACA,IAAAqS,EAAAvP,KAAAuE,IAAAlC,EAAA,eACA,GAAAkN,EAAAtU,OACA,QAAA+W,EAAA,EAA0BA,EAAAD,EAAcC,IACxCnY,GAAA0V,EAKA,OAAA1V,GAGAmW,EAAAxV,UAAA8V,SAAA,SAAAjO,EAAAmC,GACA,IAAA3K,EAAAwI,EAAAmC,GACAD,EAAAlC,EAAAb,KAAAgD,GACA,OAAAD,KAAA1K,UACA0K,MAEA1K,GAIAmW,EA1TA,GA6TA5X,EAAA2I,QAAAiP,EACA3X,EAAAD,UAAA,sCCpVAA,EAAA4B,YAAA,EAEA,IAAAiH,EAAA,mBAAAtH,QAAA,iBAAAA,OAAAuH,SAAA,SAAAJ,GAAoG,cAAAA,GAAqB,SAAAA,GAAmB,OAAAA,GAAA,mBAAAnH,QAAAmH,EAAAN,cAAA7G,QAAAmH,IAAAnH,OAAAa,UAAA,gBAAAsG,GAI5ImR,EAEA,SAAAnR,GAAsC,OAAAA,KAAA9G,WAAA8G,GAAuCC,QAAAD,GAF7EE,CAFkBtI,EAAQ,KAiB1B,IAAAwZ,EAAA,WAKA,SAAAA,IACA,IAAAC,EAAAnX,UAAAC,OAAA,QAAAsG,IAAAvG,UAAA,GAAAA,UAAA,OAjBA,SAAA4E,EAAAC,GAAiD,KAAAD,aAAAC,GAA0C,UAAAC,UAAA,qCAmB3FC,CAAAC,KAAAkS,GAYAlS,KAAAoS,QAAA,QAUApS,KAAAmS,QAAAnS,KAAAhE,UAAAmW,GAuHA,OArFAD,EAAA1X,UAAA6X,IAAA,SAAAnE,GAEA,OADAlO,KAAAmS,QAAAnS,KAAAmS,QAAAlL,OAAAjH,KAAAhE,WAAAkS,KACAlO,MA2BAkS,EAAA1X,UAAA0K,QAAA,SAAAoN,GACA,SAAApN,EAAAqN,GACA,OAAAD,EAAAjK,MAAArI,KAAAhF,WAOA,OAJAkK,EAAAzC,SAAA,WACA,OAAA6P,EAAA7P,YAGAyC,EATA,CAUG,SAAA0C,GACH,IAAAjG,EAAA3G,UAAAC,OAAA,QAAAsG,IAAAvG,UAAA,GAAAA,UAAA,MASA,OAPA,IAAAgF,KAAAmS,QAAAlX,SAAA0G,EAAAkG,OAAAlG,EAAAe,aAOA,IAAAuP,EAAAlR,QAAAf,KAAA4H,EAAAjG,KAGAuQ,EAAA1X,UAAAwB,UAAA,SAAAmW,GACA,IAAAK,KACA9O,EAAAyO,EAAAxO,EAAArG,MAAAsG,QAAAF,GAAAG,EAAA,MAAAH,EAAAC,EAAAD,IAAA/J,OAAAuH,cAAgJ,CAChJ,IAAA4C,EAEA,GAAAH,EAAA,CACA,GAAAE,GAAAH,EAAAzI,OAAA,MACA6I,EAAAJ,EAAAG,SACO,CAEP,IADAA,EAAAH,EAAAK,QACAC,KAAA,MACAF,EAAAD,EAAAhK,MAGA,IAAAjB,EAAAkL,EAIA,GAFAlL,EAAA6Z,UAAA7Z,IAAA6Z,SAEA,qBAAA7Z,EAAA,YAAAqI,EAAArI,KAAA0E,MAAAsG,QAAAhL,EAAAuZ,SACAK,IAAAvL,OAAArO,EAAAuZ,cACO,sBAAAvZ,EACP4Z,EAAAzM,KAAAnN,OACO,yBAAAA,EAAA,YAAAqI,EAAArI,QAAAsG,QAAAtG,EAAA+J,UAKP,UAAAzH,MAAAtC,EAAA,6BAGA,OAAA4Z,GAGAN,EArJA,GAwJA9Z,EAAA2I,QAAAmR,EAoFA7Z,EAAAD,UAAA,sCCjQAA,EAAA4B,YAAA,EAEA,IAAA0O,EAAA,WAAgC,SAAAC,EAAAC,EAAAC,GAA2C,QAAAjQ,EAAA,EAAgBA,EAAAiQ,EAAA5N,OAAkBrC,IAAA,CAAO,IAAAkQ,EAAAD,EAAAjQ,GAA2BkQ,EAAAtP,WAAAsP,EAAAtP,aAAA,EAAwDsP,EAAApI,cAAA,EAAgC,UAAAoI,MAAArI,UAAA,GAAuDnH,OAAAC,eAAAqP,EAAAE,EAAA3O,IAAA2O,IAA+D,gBAAAjJ,EAAAkJ,EAAAC,GAA2L,OAAlID,GAAAJ,EAAA9I,EAAArF,UAAAuO,GAAqEC,GAAAL,EAAA9I,EAAAmJ,GAA6DnJ,GAAxhB,GAEAoB,EAAA,mBAAAtH,QAAA,iBAAAA,OAAAuH,SAAA,SAAAJ,GAAoG,cAAAA,GAAqB,SAAAA,GAAmB,OAAAA,GAAA,mBAAAnH,QAAAmH,EAAAN,cAAA7G,QAAAmH,IAAAnH,OAAAa,UAAA,gBAAAsG,GAI5I4R,EAAA1R,EAFoBtI,EAAQ,KAM5Bia,EAAA3R,EAFkBtI,EAAQ,IAU1Bka,GAJA5R,EAFgBtI,EAAQ,KAMxBsI,EAFctI,EAAQ,MAMtBma,EAAA7R,EAFatI,EAAQ,IAIrB,SAAAsI,EAAAF,GAAsC,OAAAA,KAAA9G,WAAA8G,GAAuCC,QAAAD,GAI7E,SAAAgS,EAAAhS,GACA,2BAAAA,EAAA,YAAAG,EAAAH,KAAA,mBAAAA,EAAAiS,KAYA,IAAAC,EAAA,WACA,SAAAA,EAAAC,EAAArL,EAAAjG,IAhBA,SAAA/B,EAAAC,GAAiD,KAAAD,aAAAC,GAA0C,UAAAC,UAAA,qCAiB3FC,CAAAC,KAAAgT,GAEAhT,KAAAkT,aAAA,EACAlT,KAAAmT,WAAA,EAEA,IAAAjb,OAAA,EACA,wBAAA0P,EAAA,YAAA3G,EAAA2G,KAAA,OAAAA,GAAA,SAAAA,EAAAvH,KACAnI,EAAA0P,OACK,GAAAA,aAAAoL,GAAApL,aAAAgL,EAAA7R,QACL7I,EAAA0P,EAAA1P,KACA0P,EAAA5E,WACA,IAAArB,EAAAqB,MAAArB,EAAAqB,QACArB,EAAAqB,IAAAoQ,SAAAzR,EAAAqB,IAAAoQ,QAAA,GACAzR,EAAAqB,IAAAiB,KAAA2D,EAAA5E,SAEK,CACL,IAAA6E,EAAAgL,EAAA9R,QACAY,EAAA0R,SAAAxL,EAAAlG,EAAA0R,OAAAnU,OACAyC,EAAAkG,WAAAlG,EAAAkG,QACAA,EAAA3I,QAAA2I,IAAA3I,OAEA,IACAhH,EAAA2P,EAAAD,EAAAjG,GACO,MAAAF,GACPzB,KAAAyB,SAIAzB,KAAAkC,OAAA,IAAA0Q,EAAA7R,QAAAkS,EAAA/a,EAAAyJ,GAkXA,OAjWAqR,EAAAxY,UAAA8Y,SAAA,WACA,OAAAtT,KAAAuT,OAAAD,YAaAN,EAAAxY,UAAAiI,SAAA,WACA,OAAAzC,KAAA4H,KAuBAoL,EAAAxY,UAAAuY,KAAA,SAAAS,EAAAC,GAMA,OAAAzT,KAAA0T,QAAAX,KAAAS,EAAAC,IAsBAT,EAAAxY,UAAAmZ,MAAA,SAAAF,GACA,OAAAzT,KAAA0T,QAAAC,MAAAF,IAoBAT,EAAAxY,UAAAoZ,QAAA,SAAAC,GACA,OAAA7T,KAAA0T,QAAAX,KAAAc,MAGAb,EAAAxY,UAAAsZ,YAAA,SAAArS,EAAAyM,GACA,IAEA,GADAlO,KAAAyB,QACA,mBAAAA,EAAAtI,MAAAsI,EAAAyM,QAGO,GAAAA,EAAA6F,sBAFPtS,EAAAyM,SAAA8F,cACAvS,EAAA2M,aAcK,MAAA6F,GACLC,iBAAAzS,OAAAyS,QAAAzS,MAAAwS,KAIAjB,EAAAxY,UAAA2Z,UAAA,SAAAnO,EAAAoO,GACA,IAAAnU,EAAAD,KAEA,GAAAA,KAAAkO,QAAAlO,KAAAiT,UAAAd,QAAAlX,OAEA,OADA+E,KAAAmT,WAAA,EACAnN,IAGA,IACA,IAAAkI,EAAAlO,KAAAiT,UAAAd,QAAAnS,KAAAkO,QACAmG,EAAArU,KAAAsU,IAAApG,GACAlO,KAAAkO,QAAA,EAEA4E,EAAAuB,GACAA,EAAAtB,KAAA,WACA9S,EAAAkU,UAAAnO,EAAAoO,KACST,MAAA,SAAAlS,GACTxB,EAAA6T,YAAArS,EAAAyM,GACAjO,EAAAkT,WAAA,EACAiB,EAAA3S,KAGAzB,KAAAmU,UAAAnO,EAAAoO,GAEK,MAAA3S,GACLzB,KAAAmT,WAAA,EACAiB,EAAA3S,KAIAuR,EAAAxY,UAAAkZ,MAAA,WACA,IAAA/G,EAAA3M,KAEA,OAAAA,KAAAmT,UACA,IAAAoB,QAAA,SAAAvO,EAAAoO,GACAzH,EAAAlL,MACA2S,EAAAzH,EAAAlL,OAEAuE,EAAA2G,EAAAhK,eAIA3C,KAAAwU,WACAxU,KAAAwU,YAGAxU,KAAAwU,WAAA,IAAAD,QAAA,SAAAvO,EAAAoO,GACA,GAAAzH,EAAAlL,MAAA,OAAA2S,EAAAzH,EAAAlL,OACAkL,EAAAuB,OAAA,EACAvB,EAAAwH,UAAAnO,EAAAoO,KACKrB,KAAA,WAEL,OADApG,EAAAwG,WAAA,EACAxG,EAAAhK,cAGA3C,KAAAwU,aAGAxB,EAAAxY,UAAA+Y,KAAA,WACA,GAAAvT,KAAAmT,UAAA,OAAAnT,KAAAkC,OAGA,GAFAlC,KAAAmT,WAAA,EAEAnT,KAAAwU,WACA,UAAAtZ,MAAA,wDAGA,GAAA8E,KAAAyB,MAAA,MAAAzB,KAAAyB,MAEA,IAAAiC,EAAA1D,KAAAkC,OAAA+Q,UAAAd,QAAAxO,EAAArG,MAAAsG,QAAAF,GAAAG,EAAA,MAAAH,EAAAC,EAAAD,IAAA/J,OAAAuH,cAAsK,CACtK,IAAA4C,EAEA,GAAAH,EAAA,CACA,GAAAE,GAAAH,EAAAzI,OAAA,MACA6I,EAAAJ,EAAAG,SACO,CAEP,IADAA,EAAAH,EAAAK,QACAC,KAAA,MACAF,EAAAD,EAAAhK,MAGA,IAAAqU,EAAApK,EAGA,GAAAgP,EADA9S,KAAAsU,IAAApG,IAEA,UAAAhT,MAAA,wDAIA,OAAA8E,KAAAkC,QAGA8Q,EAAAxY,UAAA8Z,IAAA,SAAApG,GACAlO,KAAAkC,OAAAuS,WAAAvG,EAEA,IACA,OAAAA,EAAAlO,KAAAkC,OAAAhK,KAAA8H,KAAAkC,QACK,MAAAT,GAEL,MADAzB,KAAA8T,YAAArS,EAAAyM,GACAzM,IAIAuR,EAAAxY,UAAAmI,UAAA,WACA,GAAA3C,KAAAkT,YAAA,OAAAlT,KAAAkC,OACAlC,KAAAkT,aAAA,EAEAlT,KAAAuT,OAEA,IAAA5R,EAAA3B,KAAAkC,OAAAP,KACA3C,EAAA2T,EAAA5R,QACAY,EAAA0R,SAAArU,EAAA2C,EAAA0R,OAAA1Q,WACAhB,EAAAe,cAAA1D,EAAA2C,EAAAe,aACA1D,EAAA2D,YAAA3D,IAAA2D,WAEA,IACAP,EADA,IAAAsQ,EAAA3R,QAAA/B,EAAAgB,KAAAkC,OAAAhK,KAAA8H,KAAAkC,OAAAP,MACA+S,WAIA,OAHA1U,KAAAkC,OAAA0F,IAAAxF,EAAA,GACApC,KAAAkC,OAAAc,IAAAZ,EAAA,GAEApC,KAAAkC,QAGAwG,EAAAsK,IACA7Y,IAAA,YACAV,IAAA,WACA,OAAAuG,KAAAkC,OAAA+Q,aAUA9Y,IAAA,OACAV,IAAA,WACA,OAAAuG,KAAAkC,OAAAP,QAiBAxH,IAAA,MACAV,IAAA,WACA,OAAAuG,KAAA2C,YAAAiF,OAiBAzN,IAAA,UACAV,IAAA,WACA,OAAAuG,KAAA2C,YAAAgS,WAiBAxa,IAAA,MACAV,IAAA,WACA,OAAAuG,KAAA2C,YAAAK,OAkBA7I,IAAA,OACAV,IAAA,WACA,OAAAuG,KAAAuT,OAAArb,QAkBAiC,IAAA,WACAV,IAAA,WACA,OAAAuG,KAAAuT,OAAAqB,aAIA5B,EAhZA,GAmZA5a,EAAA2I,QAAAiS,EAYA3a,EAAAD,UAAA,uCC5cA,SAAAyc;;;;;;;AAUA,IAAAC,EAAapc,EAAQ,IACrBqc,EAAcrc,EAAQ,IACtBkL,EAAclL,EAAQ,IAmDtB,SAAAsc,IACA,OAAAC,EAAAC,oBACA,WACA,WAGA,SAAAC,EAAAC,EAAAna,GACA,GAAA+Z,IAAA/Z,EACA,UAAAoa,WAAA,8BAcA,OAZAJ,EAAAC,qBAEAE,EAAA,IAAAE,WAAAra,IACA2F,UAAAqU,EAAAza,WAGA,OAAA4a,IACAA,EAAA,IAAAH,EAAAha,IAEAma,EAAAna,UAGAma,EAaA,SAAAH,EAAAM,EAAAC,EAAAva,GACA,KAAAga,EAAAC,qBAAAlV,gBAAAiV,GACA,WAAAA,EAAAM,EAAAC,EAAAva,GAIA,oBAAAsa,EAAA,CACA,oBAAAC,EACA,UAAAta,MACA,qEAGA,OAAAua,EAAAzV,KAAAuV,GAEA,OAAAjP,EAAAtG,KAAAuV,EAAAC,EAAAva,GAWA,SAAAqL,EAAA8O,EAAAvb,EAAA2b,EAAAva,GACA,oBAAApB,EACA,UAAAiG,UAAA,yCAGA,0BAAA4V,aAAA7b,aAAA6b,YA6HA,SAAAN,EAAAO,EAAAC,EAAA3a,GAGA,GAFA0a,EAAAE,WAEAD,EAAA,GAAAD,EAAAE,WAAAD,EACA,UAAAP,WAAA,6BAGA,GAAAM,EAAAE,WAAAD,GAAA3a,GAAA,GACA,UAAAoa,WAAA,6BAIAM,OADApU,IAAAqU,QAAArU,IAAAtG,EACA,IAAAqa,WAAAK,QACGpU,IAAAtG,EACH,IAAAqa,WAAAK,EAAAC,GAEA,IAAAN,WAAAK,EAAAC,EAAA3a,GAGAga,EAAAC,qBAEAE,EAAAO,GACA/U,UAAAqU,EAAAza,UAGA4a,EAAAU,EAAAV,EAAAO,GAEA,OAAAP,EAvJAW,CAAAX,EAAAvb,EAAA2b,EAAAva,GAGA,iBAAApB,EAwFA,SAAAub,EAAAtQ,EAAAkR,GACA,iBAAAA,GAAA,KAAAA,IACAA,EAAA,QAGA,IAAAf,EAAAgB,WAAAD,GACA,UAAAlW,UAAA,8CAGA,IAAA7E,EAAA,EAAA4a,EAAA/Q,EAAAkR,GAGAE,GAFAd,EAAAD,EAAAC,EAAAna,IAEAkb,MAAArR,EAAAkR,GAEAE,IAAAjb,IAIAma,IAAA/X,MAAA,EAAA6Y,IAGA,OAAAd,EA5GAgB,CAAAhB,EAAAvb,EAAA2b,GAsJA,SAAAJ,EAAAtU,GACA,GAAAmU,EAAAoB,SAAAvV,GAAA,CACA,IAAA2G,EAAA,EAAA6O,EAAAxV,EAAA7F,QAGA,YAFAma,EAAAD,EAAAC,EAAA3N,IAEAxM,OACAma,GAGAtU,EAAAyV,KAAAnB,EAAA,IAAA3N,GACA2N,GAGA,GAAAtU,EAAA,CACA,uBAAA4U,aACA5U,EAAA0V,kBAAAd,aAAA,WAAA5U,EACA,uBAAAA,EAAA7F,QA+8CA,SAAAwb,GACA,OAAAA,KAh9CAC,CAAA5V,EAAA7F,QACAka,EAAAC,EAAA,GAEAU,EAAAV,EAAAtU,GAGA,cAAAA,EAAAT,MAAAuD,EAAA9C,EAAAsB,MACA,OAAA0T,EAAAV,EAAAtU,EAAAsB,MAIA,UAAAtC,UAAA,sFA9KA6W,CAAAvB,EAAAvb,GA4BA,SAAA+c,EAAAC,GACA,oBAAAA,EACA,UAAA/W,UAAA,oCACG,GAAA+W,EAAA,EACH,UAAAxB,WAAA,wCA4BA,SAAAI,EAAAL,EAAAyB,GAGA,GAFAD,EAAAC,GACAzB,EAAAD,EAAAC,EAAAyB,EAAA,MAAAP,EAAAO,KACA5B,EAAAC,oBACA,QAAAtc,EAAA,EAAmBA,EAAAie,IAAUje,EAC7Bwc,EAAAxc,GAAA,EAGA,OAAAwc,EAwCA,SAAAU,EAAAV,EAAAO,GACA,IAAA1a,EAAA0a,EAAA1a,OAAA,MAAAqb,EAAAX,EAAA1a,QACAma,EAAAD,EAAAC,EAAAna,GACA,QAAArC,EAAA,EAAiBA,EAAAqC,EAAYrC,GAAA,EAC7Bwc,EAAAxc,GAAA,IAAA+c,EAAA/c,GAEA,OAAAwc,EA+DA,SAAAkB,EAAArb,GAGA,GAAAA,GAAA+Z,IACA,UAAAK,WAAA,0DACAL,IAAAvS,SAAA,cAEA,SAAAxH,EAsFA,SAAA4a,EAAA/Q,EAAAkR,GACA,GAAAf,EAAAoB,SAAAvR,GACA,OAAAA,EAAA7J,OAEA,uBAAAya,aAAA,mBAAAA,YAAAoB,SACApB,YAAAoB,OAAAhS,iBAAA4Q,aACA,OAAA5Q,EAAA+Q,WAEA,iBAAA/Q,IACAA,EAAA,GAAAA,GAGA,IAAA2C,EAAA3C,EAAA7J,OACA,OAAAwM,EAAA,SAIA,IADA,IAAAsP,GAAA,IAEA,OAAAf,GACA,YACA,aACA,aACA,OAAAvO,EACA,WACA,YACA,UAAAlG,EACA,OAAAyV,EAAAlS,GAAA7J,OACA,WACA,YACA,cACA,eACA,SAAAwM,EACA,UACA,OAAAA,IAAA,EACA,aACA,OAAAwP,EAAAnS,GAAA7J,OACA,QACA,GAAA8b,EAAA,OAAAC,EAAAlS,GAAA7J,OACA+a,GAAA,GAAAA,GAAAkB,cACAH,GAAA,GAgFA,SAAAI,EAAAC,EAAA/c,EAAArB,GACA,IAAAJ,EAAAwe,EAAA/c,GACA+c,EAAA/c,GAAA+c,EAAApe,GACAoe,EAAApe,GAAAJ,EAmIA,SAAAye,EAAAb,EAAAC,EAAAb,EAAAI,EAAA3O,GAEA,OAAAmP,EAAAvb,OAAA,SAmBA,GAhBA,iBAAA2a,GACAI,EAAAJ,EACAA,EAAA,GACGA,EAAA,WACHA,EAAA,WACGA,GAAA,aACHA,GAAA,YAEAA,KACA0B,MAAA1B,KAEAA,EAAAvO,EAAA,EAAAmP,EAAAvb,OAAA,GAIA2a,EAAA,IAAAA,EAAAY,EAAAvb,OAAA2a,GACAA,GAAAY,EAAAvb,OAAA,CACA,GAAAoM,EAAA,SACAuO,EAAAY,EAAAvb,OAAA,OACG,GAAA2a,EAAA,GACH,IAAAvO,EACA,SADAuO,EAAA,EAUA,GALA,iBAAAa,IACAA,EAAAxB,EAAA3O,KAAAmQ,EAAAT,IAIAf,EAAAoB,SAAAI,GAEA,WAAAA,EAAAxb,QACA,EAEAsc,EAAAf,EAAAC,EAAAb,EAAAI,EAAA3O,GACG,oBAAAoP,EAEH,OADAA,GAAA,IACAxB,EAAAC,qBACA,mBAAAI,WAAA9a,UAAA0C,QACAmK,EACAiO,WAAA9a,UAAA0C,QAAAnE,KAAAyd,EAAAC,EAAAb,GAEAN,WAAA9a,UAAA4C,YAAArE,KAAAyd,EAAAC,EAAAb,GAGA2B,EAAAf,GAAAC,GAAAb,EAAAI,EAAA3O,GAGA,UAAAvH,UAAA,wCAGA,SAAAyX,EAAA9Q,EAAAgQ,EAAAb,EAAAI,EAAA3O,GACA,IA0BAzO,EA1BA4e,EAAA,EACAC,EAAAhR,EAAAxL,OACAyc,EAAAjB,EAAAxb,OAEA,QAAAsG,IAAAyU,IAEA,UADAA,EAAA1I,OAAA0I,GAAAkB,gBACA,UAAAlB,GACA,YAAAA,GAAA,aAAAA,GAAA,CACA,GAAAvP,EAAAxL,OAAA,GAAAwb,EAAAxb,OAAA,EACA,SAEAuc,EAAA,EACAC,GAAA,EACAC,GAAA,EACA9B,GAAA,EAIA,SAAA+B,EAAA7F,EAAAlZ,GACA,WAAA4e,EACA1F,EAAAlZ,GAEAkZ,EAAA8F,aAAAhf,EAAA4e,GAKA,GAAAnQ,EAAA,CACA,IAAAwQ,GAAA,EACA,IAAAjf,EAAAgd,EAAwBhd,EAAA6e,EAAe7e,IACvC,GAAA+e,EAAAlR,EAAA7N,KAAA+e,EAAAlB,GAAA,IAAAoB,EAAA,EAAAjf,EAAAif,IAEA,IADA,IAAAA,MAAAjf,GACAA,EAAAif,EAAA,IAAAH,EAAA,OAAAG,EAAAL,OAEA,IAAAK,IAAAjf,KAAAif,GACAA,GAAA,OAKA,IADAjC,EAAA8B,EAAAD,IAAA7B,EAAA6B,EAAAC,GACA9e,EAAAgd,EAAwBhd,GAAA,EAAQA,IAAA,CAEhC,IADA,IAAAkf,GAAA,EACA7U,EAAA,EAAqBA,EAAAyU,EAAezU,IACpC,GAAA0U,EAAAlR,EAAA7N,EAAAqK,KAAA0U,EAAAlB,EAAAxT,GAAA,CACA6U,GAAA,EACA,MAGA,GAAAA,EAAA,OAAAlf,EAIA,SAeA,SAAAmf,EAAAjG,EAAAhN,EAAAkT,EAAA/c,GACA+c,EAAAC,OAAAD,IAAA,EACA,IAAAE,EAAApG,EAAA7W,OAAA+c,EACA/c,GAGAA,EAAAgd,OAAAhd,IACAid,IACAjd,EAAAid,GAJAjd,EAAAid,EASA,IAAAC,EAAArT,EAAA7J,OACA,GAAAkd,EAAA,eAAArY,UAAA,sBAEA7E,EAAAkd,EAAA,IACAld,EAAAkd,EAAA,GAEA,QAAAvf,EAAA,EAAiBA,EAAAqC,IAAYrC,EAAA,CAC7B,IAAA2G,EAAA6Y,SAAAtT,EAAAvH,OAAA,EAAA3E,EAAA,OACA,GAAA0e,MAAA/X,GAAA,OAAA3G,EACAkZ,EAAAkG,EAAApf,GAAA2G,EAEA,OAAA3G,EAGA,SAAAyf,EAAAvG,EAAAhN,EAAAkT,EAAA/c,GACA,OAAAqd,EAAAtB,EAAAlS,EAAAgN,EAAA7W,OAAA+c,GAAAlG,EAAAkG,EAAA/c,GAGA,SAAAsd,EAAAzG,EAAAhN,EAAAkT,EAAA/c,GACA,OAAAqd,EAq6BA,SAAAtZ,GAEA,IADA,IAAAwZ,KACA5f,EAAA,EAAiBA,EAAAoG,EAAA/D,SAAgBrC,EAEjC4f,EAAAzS,KAAA,IAAA/G,EAAArB,WAAA/E,IAEA,OAAA4f,EA36BAC,CAAA3T,GAAAgN,EAAAkG,EAAA/c,GAGA,SAAAyd,EAAA5G,EAAAhN,EAAAkT,EAAA/c,GACA,OAAAsd,EAAAzG,EAAAhN,EAAAkT,EAAA/c,GAGA,SAAA0d,EAAA7G,EAAAhN,EAAAkT,EAAA/c,GACA,OAAAqd,EAAArB,EAAAnS,GAAAgN,EAAAkG,EAAA/c,GAGA,SAAA2d,EAAA9G,EAAAhN,EAAAkT,EAAA/c,GACA,OAAAqd,EAk6BA,SAAAtZ,EAAA6Z,GAGA,IAFA,IAAA5f,EAAA6f,EAAAC,EACAP,KACA5f,EAAA,EAAiBA,EAAAoG,EAAA/D,WACjB4d,GAAA,QADiCjgB,EAGjCK,EAAA+F,EAAArB,WAAA/E,GACAkgB,EAAA7f,GAAA,EACA8f,EAAA9f,EAAA,IACAuf,EAAAzS,KAAAgT,GACAP,EAAAzS,KAAA+S,GAGA,OAAAN,EA/6BAQ,CAAAlU,EAAAgN,EAAA7W,OAAA+c,GAAAlG,EAAAkG,EAAA/c,GAkFA,SAAAge,EAAAnH,EAAA/M,EAAA2B,GACA,WAAA3B,GAAA2B,IAAAoL,EAAA7W,OACA6Z,EAAAoE,cAAApH,GAEAgD,EAAAoE,cAAApH,EAAAzU,MAAA0H,EAAA2B,IAIA,SAAAyS,EAAArH,EAAA/M,EAAA2B,GACAA,EAAAG,KAAAC,IAAAgL,EAAA7W,OAAAyL,GAIA,IAHA,IAAAZ,KAEAlN,EAAAmM,EACAnM,EAAA8N,GAAA,CACA,IAQA0S,EAAAC,EAAAC,EAAAC,EARAC,EAAA1H,EAAAlZ,GACA6gB,EAAA,KACAC,EAAAF,EAAA,MACAA,EAAA,MACAA,EAAA,MACA,EAEA,GAAA5gB,EAAA8gB,GAAAhT,EAGA,OAAAgT,GACA,OACAF,EAAA,MACAC,EAAAD,GAEA,MACA,OAEA,WADAJ,EAAAtH,EAAAlZ,EAAA,OAEA2gB,GAAA,GAAAC,IAAA,KAAAJ,GACA,MACAK,EAAAF,GAGA,MACA,OACAH,EAAAtH,EAAAlZ,EAAA,GACAygB,EAAAvH,EAAAlZ,EAAA,GACA,UAAAwgB,IAAA,UAAAC,KACAE,GAAA,GAAAC,IAAA,OAAAJ,IAAA,KAAAC,GACA,OAAAE,EAAA,OAAAA,EAAA,SACAE,EAAAF,GAGA,MACA,OACAH,EAAAtH,EAAAlZ,EAAA,GACAygB,EAAAvH,EAAAlZ,EAAA,GACA0gB,EAAAxH,EAAAlZ,EAAA,GACA,UAAAwgB,IAAA,UAAAC,IAAA,UAAAC,KACAC,GAAA,GAAAC,IAAA,OAAAJ,IAAA,OAAAC,IAAA,KAAAC,GACA,OAAAC,EAAA,UACAE,EAAAF,GAMA,OAAAE,GAGAA,EAAA,MACAC,EAAA,GACKD,EAAA,QAELA,GAAA,MACA3T,EAAAC,KAAA0T,IAAA,eACAA,EAAA,WAAAA,GAGA3T,EAAAC,KAAA0T,GACA7gB,GAAA8gB,EAGA,OAQA,SAAAC,GACA,IAAAlS,EAAAkS,EAAA1e,OACA,GAAAwM,GAAAmS,EACA,OAAAtM,OAAAuM,aAAAxR,MAAAiF,OAAAqM,GAIA,IAAA7T,EAAA,GACAlN,EAAA,EACA,KAAAA,EAAA6O,GACA3B,GAAAwH,OAAAuM,aAAAxR,MACAiF,OACAqM,EAAAtc,MAAAzE,KAAAghB,IAGA,OAAA9T,EAvBAgU,CAAAhU,GA98BA1N,EAAA6c,SACA7c,EAAA2hB,WAoTA,SAAA9e,IACAA,OACAA,EAAA,GAEA,OAAAga,EAAA+E,OAAA/e,IAvTA7C,EAAA6hB,kBAAA,GA0BAhF,EAAAC,yBAAA3T,IAAAsT,EAAAK,oBACAL,EAAAK,oBAQA,WACA,IACA,IAAAzO,EAAA,IAAA6O,WAAA,GAEA,OADA7O,EAAA7F,WAAqBA,UAAA0U,WAAA9a,UAAA0f,IAAA,WAAmD,YACxE,KAAAzT,EAAAyT,OACA,mBAAAzT,EAAA0T,UACA,IAAA1T,EAAA0T,SAAA,KAAAtE,WACG,MAAA/N,GACH,UAfAsS,GAKAhiB,EAAA4c,eAkEAC,EAAAoF,SAAA,KAGApF,EAAAqF,SAAA,SAAA7T,GAEA,OADAA,EAAA7F,UAAAqU,EAAAza,UACAiM,GA2BAwO,EAAA3O,KAAA,SAAAzM,EAAA2b,EAAAva,GACA,OAAAqL,EAAA,KAAAzM,EAAA2b,EAAAva,IAGAga,EAAAC,sBACAD,EAAAza,UAAAoG,UAAA0U,WAAA9a,UACAya,EAAArU,UAAA0U,WACA,oBAAA3b,eAAA4gB,SACAtF,EAAAtb,OAAA4gB,WAAAtF,GAEA3b,OAAAC,eAAA0b,EAAAtb,OAAA4gB,SACA1gB,MAAA,KACA6G,cAAA,KAiCAuU,EAAA+E,MAAA,SAAAnD,EAAA2D,EAAAxE,GACA,OArBA,SAAAZ,EAAAyB,EAAA2D,EAAAxE,GAEA,OADAY,EAAAC,GACAA,GAAA,EACA1B,EAAAC,EAAAyB,QAEAtV,IAAAiZ,EAIA,iBAAAxE,EACAb,EAAAC,EAAAyB,GAAA2D,OAAAxE,GACAb,EAAAC,EAAAyB,GAAA2D,QAEArF,EAAAC,EAAAyB,GAQAmD,CAAA,KAAAnD,EAAA2D,EAAAxE,IAiBAf,EAAAQ,YAAA,SAAAoB,GACA,OAAApB,EAAA,KAAAoB,IAKA5B,EAAAwF,gBAAA,SAAA5D,GACA,OAAApB,EAAA,KAAAoB,IAiHA5B,EAAAoB,SAAA,SAAAe,GACA,cAAAA,MAAAsD,YAGAzF,EAAA0F,QAAA,SAAAC,EAAAxD,GACA,IAAAnC,EAAAoB,SAAAuE,KAAA3F,EAAAoB,SAAAe,GACA,UAAAtX,UAAA,6BAGA,GAAA8a,IAAAxD,EAAA,SAKA,IAHA,IAAAyD,EAAAD,EAAA3f,OACA6f,EAAA1D,EAAAnc,OAEArC,EAAA,EAAA6O,EAAAZ,KAAAC,IAAA+T,EAAAC,GAAuCliB,EAAA6O,IAAS7O,EAChD,GAAAgiB,EAAAhiB,KAAAwe,EAAAxe,GAAA,CACAiiB,EAAAD,EAAAhiB,GACAkiB,EAAA1D,EAAAxe,GACA,MAIA,OAAAiiB,EAAAC,GAAA,EACAA,EAAAD,EAAA,EACA,GAGA5F,EAAAgB,WAAA,SAAAD,GACA,OAAA1I,OAAA0I,GAAAkB,eACA,UACA,WACA,YACA,YACA,aACA,aACA,aACA,WACA,YACA,cACA,eACA,SACA,QACA,WAIAjC,EAAAhO,OAAA,SAAA8T,EAAA9f,GACA,IAAA2I,EAAAmX,GACA,UAAAjb,UAAA,+CAGA,OAAAib,EAAA9f,OACA,OAAAga,EAAA+E,MAAA,GAGA,IAAAphB,EACA,QAAA2I,IAAAtG,EAEA,IADAA,EAAA,EACArC,EAAA,EAAeA,EAAAmiB,EAAA9f,SAAiBrC,EAChCqC,GAAA8f,EAAAniB,GAAAqC,OAIA,IAAAub,EAAAvB,EAAAQ,YAAAxa,GACA2G,EAAA,EACA,IAAAhJ,EAAA,EAAaA,EAAAmiB,EAAA9f,SAAiBrC,EAAA,CAC9B,IAAAkZ,EAAAiJ,EAAAniB,GACA,IAAAqc,EAAAoB,SAAAvE,GACA,UAAAhS,UAAA,+CAEAgS,EAAAyE,KAAAC,EAAA5U,GACAA,GAAAkQ,EAAA7W,OAEA,OAAAub,GA8CAvB,EAAAY,aA0EAZ,EAAAza,UAAAkgB,WAAA,EAQAzF,EAAAza,UAAAwgB,OAAA,WACA,IAAAvT,EAAAzH,KAAA/E,OACA,GAAAwM,EAAA,KACA,UAAA4N,WAAA,6CAEA,QAAAzc,EAAA,EAAiBA,EAAA6O,EAAS7O,GAAA,EAC1Bue,EAAAnX,KAAApH,IAAA,GAEA,OAAAoH,MAGAiV,EAAAza,UAAAygB,OAAA,WACA,IAAAxT,EAAAzH,KAAA/E,OACA,GAAAwM,EAAA,KACA,UAAA4N,WAAA,6CAEA,QAAAzc,EAAA,EAAiBA,EAAA6O,EAAS7O,GAAA,EAC1Bue,EAAAnX,KAAApH,IAAA,GACAue,EAAAnX,KAAApH,EAAA,EAAAA,EAAA,GAEA,OAAAoH,MAGAiV,EAAAza,UAAA0gB,OAAA,WACA,IAAAzT,EAAAzH,KAAA/E,OACA,GAAAwM,EAAA,KACA,UAAA4N,WAAA,6CAEA,QAAAzc,EAAA,EAAiBA,EAAA6O,EAAS7O,GAAA,EAC1Bue,EAAAnX,KAAApH,IAAA,GACAue,EAAAnX,KAAApH,EAAA,EAAAA,EAAA,GACAue,EAAAnX,KAAApH,EAAA,EAAAA,EAAA,GACAue,EAAAnX,KAAApH,EAAA,EAAAA,EAAA,GAEA,OAAAoH,MAGAiV,EAAAza,UAAAiI,SAAA,WACA,IAAAxH,EAAA,EAAA+E,KAAA/E,OACA,WAAAA,EAAA,GACA,IAAAD,UAAAC,OAAAke,EAAAnZ,KAAA,EAAA/E,GAxHA,SAAA+a,EAAAjR,EAAA2B,GACA,IAAAqQ,GAAA,EAcA,SALAxV,IAAAwD,KAAA,KACAA,EAAA,GAIAA,EAAA/E,KAAA/E,OACA,SAOA,SAJAsG,IAAAmF,KAAA1G,KAAA/E,UACAyL,EAAA1G,KAAA/E,QAGAyL,GAAA,EACA,SAOA,IAHAA,KAAA,KACA3B,KAAA,GAGA,SAKA,IAFAiR,MAAA,UAGA,OAAAA,GACA,UACA,OAAAmF,EAAAnb,KAAA+E,EAAA2B,GAEA,WACA,YACA,OAAAyS,EAAAnZ,KAAA+E,EAAA2B,GAEA,YACA,OAAA0U,EAAApb,KAAA+E,EAAA2B,GAEA,aACA,aACA,OAAA2U,EAAArb,KAAA+E,EAAA2B,GAEA,aACA,OAAAuS,EAAAjZ,KAAA+E,EAAA2B,GAEA,WACA,YACA,cACA,eACA,OAAA4U,EAAAtb,KAAA+E,EAAA2B,GAEA,QACA,GAAAqQ,EAAA,UAAAjX,UAAA,qBAAAkW,GACAA,KAAA,IAAAkB,cACAH,GAAA,IAwDA1O,MAAArI,KAAAhF,YAGAia,EAAAza,UAAA+gB,OAAA,SAAAnE,GACA,IAAAnC,EAAAoB,SAAAe,GAAA,UAAAtX,UAAA,6BACA,OAAAE,OAAAoX,GACA,IAAAnC,EAAA0F,QAAA3a,KAAAoX,IAGAnC,EAAAza,UAAAghB,QAAA,WACA,IAAAxc,EAAA,GACA0P,EAAAtW,EAAA6hB,kBAKA,OAJAja,KAAA/E,OAAA,IACA+D,EAAAgB,KAAAyC,SAAA,QAAAiM,GAAAnT,MAAA,SAAkDiB,KAAA,KAClDwD,KAAA/E,OAAAyT,IAAA1P,GAAA,UAEA,WAAAA,EAAA,KAGAiW,EAAAza,UAAAmgB,QAAA,SAAA/R,EAAA7D,EAAA2B,EAAA+U,EAAAC,GACA,IAAAzG,EAAAoB,SAAAzN,GACA,UAAA9I,UAAA,6BAgBA,QAbAyB,IAAAwD,IACAA,EAAA,QAEAxD,IAAAmF,IACAA,EAAAkC,IAAA3N,OAAA,QAEAsG,IAAAka,IACAA,EAAA,QAEAla,IAAAma,IACAA,EAAA1b,KAAA/E,QAGA8J,EAAA,GAAA2B,EAAAkC,EAAA3N,QAAAwgB,EAAA,GAAAC,EAAA1b,KAAA/E,OACA,UAAAoa,WAAA,sBAGA,GAAAoG,GAAAC,GAAA3W,GAAA2B,EACA,SAEA,GAAA+U,GAAAC,EACA,SAEA,GAAA3W,GAAA2B,EACA,SAQA,GALA3B,KAAA,EACA2B,KAAA,EACA+U,KAAA,EACAC,KAAA,EAEA1b,OAAA4I,EAAA,SASA,IAPA,IAAAiS,EAAAa,EAAAD,EACAX,EAAApU,EAAA3B,EACA0C,EAAAZ,KAAAC,IAAA+T,EAAAC,GAEAa,EAAA3b,KAAA3C,MAAAoe,EAAAC,GACAE,EAAAhT,EAAAvL,MAAA0H,EAAA2B,GAEA9N,EAAA,EAAiBA,EAAA6O,IAAS7O,EAC1B,GAAA+iB,EAAA/iB,KAAAgjB,EAAAhjB,GAAA,CACAiiB,EAAAc,EAAA/iB,GACAkiB,EAAAc,EAAAhjB,GACA,MAIA,OAAAiiB,EAAAC,GAAA,EACAA,EAAAD,EAAA,EACA,GA6HA5F,EAAAza,UAAAqhB,SAAA,SAAApF,EAAAb,EAAAI,GACA,WAAAhW,KAAA9C,QAAAuZ,EAAAb,EAAAI,IAGAf,EAAAza,UAAA0C,QAAA,SAAAuZ,EAAAb,EAAAI,GACA,OAAAqB,EAAArX,KAAAyW,EAAAb,EAAAI,GAAA,IAGAf,EAAAza,UAAA4C,YAAA,SAAAqZ,EAAAb,EAAAI,GACA,OAAAqB,EAAArX,KAAAyW,EAAAb,EAAAI,GAAA,IAkDAf,EAAAza,UAAA2b,MAAA,SAAArR,EAAAkT,EAAA/c,EAAA+a,GAEA,QAAAzU,IAAAyW,EACAhC,EAAA,OACA/a,EAAA+E,KAAA/E,OACA+c,EAAA,OAEG,QAAAzW,IAAAtG,GAAA,iBAAA+c,EACHhC,EAAAgC,EACA/c,EAAA+E,KAAA/E,OACA+c,EAAA,MAEG,KAAA8D,SAAA9D,GAWH,UAAA9c,MACA,2EAXA8c,GAAA,EACA8D,SAAA7gB,IACAA,GAAA,OACAsG,IAAAyU,MAAA,UAEAA,EAAA/a,EACAA,OAAAsG,GASA,IAAA2W,EAAAlY,KAAA/E,OAAA+c,EAGA,SAFAzW,IAAAtG,KAAAid,KAAAjd,EAAAid,GAEApT,EAAA7J,OAAA,IAAAA,EAAA,GAAA+c,EAAA,IAAAA,EAAAhY,KAAA/E,OACA,UAAAoa,WAAA,0CAGAW,MAAA,QAGA,IADA,IAAAe,GAAA,IAEA,OAAAf,GACA,UACA,OAAA+B,EAAA/X,KAAA8E,EAAAkT,EAAA/c,GAEA,WACA,YACA,OAAAod,EAAArY,KAAA8E,EAAAkT,EAAA/c,GAEA,YACA,OAAAsd,EAAAvY,KAAA8E,EAAAkT,EAAA/c,GAEA,aACA,aACA,OAAAyd,EAAA1Y,KAAA8E,EAAAkT,EAAA/c,GAEA,aAEA,OAAA0d,EAAA3Y,KAAA8E,EAAAkT,EAAA/c,GAEA,WACA,YACA,cACA,eACA,OAAA2d,EAAA5Y,KAAA8E,EAAAkT,EAAA/c,GAEA,QACA,GAAA8b,EAAA,UAAAjX,UAAA,qBAAAkW,GACAA,GAAA,GAAAA,GAAAkB,cACAH,GAAA,IAKA9B,EAAAza,UAAA6J,OAAA,WACA,OACAhE,KAAA,SACA+B,KAAA9E,MAAA9C,UAAA6C,MAAAtE,KAAAiH,KAAA+b,MAAA/b,KAAA,KAwFA,IAAA4Z,EAAA,KAoBA,SAAAwB,EAAAtJ,EAAA/M,EAAA2B,GACA,IAAAsV,EAAA,GACAtV,EAAAG,KAAAC,IAAAgL,EAAA7W,OAAAyL,GAEA,QAAA9N,EAAAmM,EAAqBnM,EAAA8N,IAAS9N,EAC9BojB,GAAA1O,OAAAuM,aAAA,IAAA/H,EAAAlZ,IAEA,OAAAojB,EAGA,SAAAX,EAAAvJ,EAAA/M,EAAA2B,GACA,IAAAsV,EAAA,GACAtV,EAAAG,KAAAC,IAAAgL,EAAA7W,OAAAyL,GAEA,QAAA9N,EAAAmM,EAAqBnM,EAAA8N,IAAS9N,EAC9BojB,GAAA1O,OAAAuM,aAAA/H,EAAAlZ,IAEA,OAAAojB,EAGA,SAAAb,EAAArJ,EAAA/M,EAAA2B,GACA,IAAAe,EAAAqK,EAAA7W,SAEA8J,KAAA,KAAAA,EAAA,KACA2B,KAAA,GAAAA,EAAAe,KAAAf,EAAAe,GAGA,IADA,IAAAwU,EAAA,GACArjB,EAAAmM,EAAqBnM,EAAA8N,IAAS9N,EAC9BqjB,GAAAC,EAAApK,EAAAlZ,IAEA,OAAAqjB,EAGA,SAAAX,EAAAxJ,EAAA/M,EAAA2B,GAGA,IAFA,IAAAyV,EAAArK,EAAAzU,MAAA0H,EAAA2B,GACAZ,EAAA,GACAlN,EAAA,EAAiBA,EAAAujB,EAAAlhB,OAAkBrC,GAAA,EACnCkN,GAAAwH,OAAAuM,aAAAsC,EAAAvjB,GAAA,IAAAujB,EAAAvjB,EAAA,IAEA,OAAAkN,EA0CA,SAAAsW,EAAApE,EAAAzQ,EAAAtM,GACA,GAAA+c,EAAA,MAAAA,EAAA,YAAA3C,WAAA,sBACA,GAAA2C,EAAAzQ,EAAAtM,EAAA,UAAAoa,WAAA,yCA+JA,SAAAgH,EAAAvK,EAAAjY,EAAAme,EAAAzQ,EAAAmH,EAAA5H,GACA,IAAAmO,EAAAoB,SAAAvE,GAAA,UAAAhS,UAAA,+CACA,GAAAjG,EAAA6U,GAAA7U,EAAAiN,EAAA,UAAAuO,WAAA,qCACA,GAAA2C,EAAAzQ,EAAAuK,EAAA7W,OAAA,UAAAoa,WAAA,sBAkDA,SAAAiH,EAAAxK,EAAAjY,EAAAme,EAAAuE,GACA1iB,EAAA,IAAAA,EAAA,MAAAA,EAAA,GACA,QAAAjB,EAAA,EAAAqK,EAAA4D,KAAAC,IAAAgL,EAAA7W,OAAA+c,EAAA,GAAuDpf,EAAAqK,IAAOrK,EAC9DkZ,EAAAkG,EAAApf,IAAAiB,EAAA,QAAA0iB,EAAA3jB,EAAA,EAAAA,MACA,GAAA2jB,EAAA3jB,EAAA,EAAAA,GA8BA,SAAA4jB,EAAA1K,EAAAjY,EAAAme,EAAAuE,GACA1iB,EAAA,IAAAA,EAAA,WAAAA,EAAA,GACA,QAAAjB,EAAA,EAAAqK,EAAA4D,KAAAC,IAAAgL,EAAA7W,OAAA+c,EAAA,GAAuDpf,EAAAqK,IAAOrK,EAC9DkZ,EAAAkG,EAAApf,GAAAiB,IAAA,GAAA0iB,EAAA3jB,EAAA,EAAAA,GAAA,IAmJA,SAAA6jB,EAAA3K,EAAAjY,EAAAme,EAAAzQ,EAAAmH,EAAA5H,GACA,GAAAkR,EAAAzQ,EAAAuK,EAAA7W,OAAA,UAAAoa,WAAA,sBACA,GAAA2C,EAAA,YAAA3C,WAAA,sBAGA,SAAAqH,EAAA5K,EAAAjY,EAAAme,EAAAuE,EAAAI,GAKA,OAJAA,GACAF,EAAA3K,EAAAjY,EAAAme,EAAA,GAEAjD,EAAAoB,MAAArE,EAAAjY,EAAAme,EAAAuE,EAAA,MACAvE,EAAA,EAWA,SAAA4E,EAAA9K,EAAAjY,EAAAme,EAAAuE,EAAAI,GAKA,OAJAA,GACAF,EAAA3K,EAAAjY,EAAAme,EAAA,GAEAjD,EAAAoB,MAAArE,EAAAjY,EAAAme,EAAAuE,EAAA,MACAvE,EAAA,EA/cA/C,EAAAza,UAAA6C,MAAA,SAAA0H,EAAA2B,GACA,IAoBAmW,EApBApV,EAAAzH,KAAA/E,OAqBA,GApBA8J,MACA2B,OAAAnF,IAAAmF,EAAAe,IAAAf,EAEA3B,EAAA,GACAA,GAAA0C,GACA,IAAA1C,EAAA,GACGA,EAAA0C,IACH1C,EAAA0C,GAGAf,EAAA,GACAA,GAAAe,GACA,IAAAf,EAAA,GACGA,EAAAe,IACHf,EAAAe,GAGAf,EAAA3B,IAAA2B,EAAA3B,GAGAkQ,EAAAC,qBACA2H,EAAA7c,KAAAma,SAAApV,EAAA2B,IACA9F,UAAAqU,EAAAza,cACG,CACH,IAAAsiB,EAAApW,EAAA3B,EACA8X,EAAA,IAAA5H,EAAA6H,OAAAvb,GACA,QAAA3I,EAAA,EAAmBA,EAAAkkB,IAAclkB,EACjCikB,EAAAjkB,GAAAoH,KAAApH,EAAAmM,GAIA,OAAA8X,GAWA5H,EAAAza,UAAAuiB,WAAA,SAAA/E,EAAAnC,EAAA8G,GACA3E,GAAA,EACAnC,GAAA,EACA8G,GAAAP,EAAApE,EAAAnC,EAAA7V,KAAA/E,QAKA,IAHA,IAAAwb,EAAAzW,KAAAgY,GACAgF,EAAA,EACApkB,EAAA,IACAA,EAAAid,IAAAmH,GAAA,MACAvG,GAAAzW,KAAAgY,EAAApf,GAAAokB,EAGA,OAAAvG,GAGAxB,EAAAza,UAAAyiB,WAAA,SAAAjF,EAAAnC,EAAA8G,GACA3E,GAAA,EACAnC,GAAA,EACA8G,GACAP,EAAApE,EAAAnC,EAAA7V,KAAA/E,QAKA,IAFA,IAAAwb,EAAAzW,KAAAgY,IAAAnC,GACAmH,EAAA,EACAnH,EAAA,IAAAmH,GAAA,MACAvG,GAAAzW,KAAAgY,IAAAnC,GAAAmH,EAGA,OAAAvG,GAGAxB,EAAAza,UAAA0iB,UAAA,SAAAlF,EAAA2E,GAEA,OADAA,GAAAP,EAAApE,EAAA,EAAAhY,KAAA/E,QACA+E,KAAAgY,IAGA/C,EAAAza,UAAA2iB,aAAA,SAAAnF,EAAA2E,GAEA,OADAA,GAAAP,EAAApE,EAAA,EAAAhY,KAAA/E,QACA+E,KAAAgY,GAAAhY,KAAAgY,EAAA,OAGA/C,EAAAza,UAAAod,aAAA,SAAAI,EAAA2E,GAEA,OADAA,GAAAP,EAAApE,EAAA,EAAAhY,KAAA/E,QACA+E,KAAAgY,IAAA,EAAAhY,KAAAgY,EAAA,IAGA/C,EAAAza,UAAA4iB,aAAA,SAAApF,EAAA2E,GAGA,OAFAA,GAAAP,EAAApE,EAAA,EAAAhY,KAAA/E,SAEA+E,KAAAgY,GACAhY,KAAAgY,EAAA,MACAhY,KAAAgY,EAAA,QACA,SAAAhY,KAAAgY,EAAA,IAGA/C,EAAAza,UAAA6iB,aAAA,SAAArF,EAAA2E,GAGA,OAFAA,GAAAP,EAAApE,EAAA,EAAAhY,KAAA/E,QAEA,SAAA+E,KAAAgY,IACAhY,KAAAgY,EAAA,OACAhY,KAAAgY,EAAA,MACAhY,KAAAgY,EAAA,KAGA/C,EAAAza,UAAA8iB,UAAA,SAAAtF,EAAAnC,EAAA8G,GACA3E,GAAA,EACAnC,GAAA,EACA8G,GAAAP,EAAApE,EAAAnC,EAAA7V,KAAA/E,QAKA,IAHA,IAAAwb,EAAAzW,KAAAgY,GACAgF,EAAA,EACApkB,EAAA,IACAA,EAAAid,IAAAmH,GAAA,MACAvG,GAAAzW,KAAAgY,EAAApf,GAAAokB,EAMA,OAFAvG,IAFAuG,GAAA,OAEAvG,GAAA5P,KAAA0W,IAAA,IAAA1H,IAEAY,GAGAxB,EAAAza,UAAAgjB,UAAA,SAAAxF,EAAAnC,EAAA8G,GACA3E,GAAA,EACAnC,GAAA,EACA8G,GAAAP,EAAApE,EAAAnC,EAAA7V,KAAA/E,QAKA,IAHA,IAAArC,EAAAid,EACAmH,EAAA,EACAvG,EAAAzW,KAAAgY,IAAApf,GACAA,EAAA,IAAAokB,GAAA,MACAvG,GAAAzW,KAAAgY,IAAApf,GAAAokB,EAMA,OAFAvG,IAFAuG,GAAA,OAEAvG,GAAA5P,KAAA0W,IAAA,IAAA1H,IAEAY,GAGAxB,EAAAza,UAAAijB,SAAA,SAAAzF,EAAA2E,GAEA,OADAA,GAAAP,EAAApE,EAAA,EAAAhY,KAAA/E,QACA,IAAA+E,KAAAgY,IACA,OAAAhY,KAAAgY,GAAA,GADAhY,KAAAgY,IAIA/C,EAAAza,UAAAkjB,YAAA,SAAA1F,EAAA2E,GACAA,GAAAP,EAAApE,EAAA,EAAAhY,KAAA/E,QACA,IAAAwb,EAAAzW,KAAAgY,GAAAhY,KAAAgY,EAAA,MACA,aAAAvB,EAAA,WAAAA,KAGAxB,EAAAza,UAAAmjB,YAAA,SAAA3F,EAAA2E,GACAA,GAAAP,EAAApE,EAAA,EAAAhY,KAAA/E,QACA,IAAAwb,EAAAzW,KAAAgY,EAAA,GAAAhY,KAAAgY,IAAA,EACA,aAAAvB,EAAA,WAAAA,KAGAxB,EAAAza,UAAAojB,YAAA,SAAA5F,EAAA2E,GAGA,OAFAA,GAAAP,EAAApE,EAAA,EAAAhY,KAAA/E,QAEA+E,KAAAgY,GACAhY,KAAAgY,EAAA,MACAhY,KAAAgY,EAAA,OACAhY,KAAAgY,EAAA,QAGA/C,EAAAza,UAAAqjB,YAAA,SAAA7F,EAAA2E,GAGA,OAFAA,GAAAP,EAAApE,EAAA,EAAAhY,KAAA/E,QAEA+E,KAAAgY,IAAA,GACAhY,KAAAgY,EAAA,OACAhY,KAAAgY,EAAA,MACAhY,KAAAgY,EAAA,IAGA/C,EAAAza,UAAAsjB,YAAA,SAAA9F,EAAA2E,GAEA,OADAA,GAAAP,EAAApE,EAAA,EAAAhY,KAAA/E,QACA8Z,EAAA4C,KAAA3X,KAAAgY,GAAA,SAGA/C,EAAAza,UAAAujB,YAAA,SAAA/F,EAAA2E,GAEA,OADAA,GAAAP,EAAApE,EAAA,EAAAhY,KAAA/E,QACA8Z,EAAA4C,KAAA3X,KAAAgY,GAAA,SAGA/C,EAAAza,UAAAwjB,aAAA,SAAAhG,EAAA2E,GAEA,OADAA,GAAAP,EAAApE,EAAA,EAAAhY,KAAA/E,QACA8Z,EAAA4C,KAAA3X,KAAAgY,GAAA,SAGA/C,EAAAza,UAAAyjB,aAAA,SAAAjG,EAAA2E,GAEA,OADAA,GAAAP,EAAApE,EAAA,EAAAhY,KAAA/E,QACA8Z,EAAA4C,KAAA3X,KAAAgY,GAAA,SASA/C,EAAAza,UAAA0jB,YAAA,SAAArkB,EAAAme,EAAAnC,EAAA8G,IACA9iB,KACAme,GAAA,EACAnC,GAAA,EACA8G,IAEAN,EAAArc,KAAAnG,EAAAme,EAAAnC,EADAhP,KAAA0W,IAAA,IAAA1H,GAAA,EACA,GAGA,IAAAmH,EAAA,EACApkB,EAAA,EAEA,IADAoH,KAAAgY,GAAA,IAAAne,IACAjB,EAAAid,IAAAmH,GAAA,MACAhd,KAAAgY,EAAApf,GAAAiB,EAAAmjB,EAAA,IAGA,OAAAhF,EAAAnC,GAGAZ,EAAAza,UAAA2jB,YAAA,SAAAtkB,EAAAme,EAAAnC,EAAA8G,IACA9iB,KACAme,GAAA,EACAnC,GAAA,EACA8G,IAEAN,EAAArc,KAAAnG,EAAAme,EAAAnC,EADAhP,KAAA0W,IAAA,IAAA1H,GAAA,EACA,GAGA,IAAAjd,EAAAid,EAAA,EACAmH,EAAA,EAEA,IADAhd,KAAAgY,EAAApf,GAAA,IAAAiB,IACAjB,GAAA,IAAAokB,GAAA,MACAhd,KAAAgY,EAAApf,GAAAiB,EAAAmjB,EAAA,IAGA,OAAAhF,EAAAnC,GAGAZ,EAAAza,UAAA4jB,WAAA,SAAAvkB,EAAAme,EAAA2E,GAMA,OALA9iB,KACAme,GAAA,EACA2E,GAAAN,EAAArc,KAAAnG,EAAAme,EAAA,SACA/C,EAAAC,sBAAArb,EAAAgN,KAAAwX,MAAAxkB,IACAmG,KAAAgY,GAAA,IAAAne,EACAme,EAAA,GAWA/C,EAAAza,UAAA8jB,cAAA,SAAAzkB,EAAAme,EAAA2E,GAUA,OATA9iB,KACAme,GAAA,EACA2E,GAAAN,EAAArc,KAAAnG,EAAAme,EAAA,WACA/C,EAAAC,qBACAlV,KAAAgY,GAAA,IAAAne,EACAmG,KAAAgY,EAAA,GAAAne,IAAA,GAEAyiB,EAAAtc,KAAAnG,EAAAme,GAAA,GAEAA,EAAA,GAGA/C,EAAAza,UAAA+jB,cAAA,SAAA1kB,EAAAme,EAAA2E,GAUA,OATA9iB,KACAme,GAAA,EACA2E,GAAAN,EAAArc,KAAAnG,EAAAme,EAAA,WACA/C,EAAAC,qBACAlV,KAAAgY,GAAAne,IAAA,EACAmG,KAAAgY,EAAA,OAAAne,GAEAyiB,EAAAtc,KAAAnG,EAAAme,GAAA,GAEAA,EAAA,GAUA/C,EAAAza,UAAAgkB,cAAA,SAAA3kB,EAAAme,EAAA2E,GAYA,OAXA9iB,KACAme,GAAA,EACA2E,GAAAN,EAAArc,KAAAnG,EAAAme,EAAA,gBACA/C,EAAAC,qBACAlV,KAAAgY,EAAA,GAAAne,IAAA,GACAmG,KAAAgY,EAAA,GAAAne,IAAA,GACAmG,KAAAgY,EAAA,GAAAne,IAAA,EACAmG,KAAAgY,GAAA,IAAAne,GAEA2iB,EAAAxc,KAAAnG,EAAAme,GAAA,GAEAA,EAAA,GAGA/C,EAAAza,UAAAikB,cAAA,SAAA5kB,EAAAme,EAAA2E,GAYA,OAXA9iB,KACAme,GAAA,EACA2E,GAAAN,EAAArc,KAAAnG,EAAAme,EAAA,gBACA/C,EAAAC,qBACAlV,KAAAgY,GAAAne,IAAA,GACAmG,KAAAgY,EAAA,GAAAne,IAAA,GACAmG,KAAAgY,EAAA,GAAAne,IAAA,EACAmG,KAAAgY,EAAA,OAAAne,GAEA2iB,EAAAxc,KAAAnG,EAAAme,GAAA,GAEAA,EAAA,GAGA/C,EAAAza,UAAAkkB,WAAA,SAAA7kB,EAAAme,EAAAnC,EAAA8G,GAGA,GAFA9iB,KACAme,GAAA,GACA2E,EAAA,CACA,IAAAgC,EAAA9X,KAAA0W,IAAA,IAAA1H,EAAA,GAEAwG,EAAArc,KAAAnG,EAAAme,EAAAnC,EAAA8I,EAAA,GAAAA,GAGA,IAAA/lB,EAAA,EACAokB,EAAA,EACA4B,EAAA,EAEA,IADA5e,KAAAgY,GAAA,IAAAne,IACAjB,EAAAid,IAAAmH,GAAA,MACAnjB,EAAA,OAAA+kB,GAAA,IAAA5e,KAAAgY,EAAApf,EAAA,KACAgmB,EAAA,GAEA5e,KAAAgY,EAAApf,IAAAiB,EAAAmjB,GAAA,GAAA4B,EAAA,IAGA,OAAA5G,EAAAnC,GAGAZ,EAAAza,UAAAqkB,WAAA,SAAAhlB,EAAAme,EAAAnC,EAAA8G,GAGA,GAFA9iB,KACAme,GAAA,GACA2E,EAAA,CACA,IAAAgC,EAAA9X,KAAA0W,IAAA,IAAA1H,EAAA,GAEAwG,EAAArc,KAAAnG,EAAAme,EAAAnC,EAAA8I,EAAA,GAAAA,GAGA,IAAA/lB,EAAAid,EAAA,EACAmH,EAAA,EACA4B,EAAA,EAEA,IADA5e,KAAAgY,EAAApf,GAAA,IAAAiB,IACAjB,GAAA,IAAAokB,GAAA,MACAnjB,EAAA,OAAA+kB,GAAA,IAAA5e,KAAAgY,EAAApf,EAAA,KACAgmB,EAAA,GAEA5e,KAAAgY,EAAApf,IAAAiB,EAAAmjB,GAAA,GAAA4B,EAAA,IAGA,OAAA5G,EAAAnC,GAGAZ,EAAAza,UAAAskB,UAAA,SAAAjlB,EAAAme,EAAA2E,GAOA,OANA9iB,KACAme,GAAA,EACA2E,GAAAN,EAAArc,KAAAnG,EAAAme,EAAA,YACA/C,EAAAC,sBAAArb,EAAAgN,KAAAwX,MAAAxkB,IACAA,EAAA,IAAAA,EAAA,IAAAA,EAAA,GACAmG,KAAAgY,GAAA,IAAAne,EACAme,EAAA,GAGA/C,EAAAza,UAAAukB,aAAA,SAAAllB,EAAAme,EAAA2E,GAUA,OATA9iB,KACAme,GAAA,EACA2E,GAAAN,EAAArc,KAAAnG,EAAAme,EAAA,gBACA/C,EAAAC,qBACAlV,KAAAgY,GAAA,IAAAne,EACAmG,KAAAgY,EAAA,GAAAne,IAAA,GAEAyiB,EAAAtc,KAAAnG,EAAAme,GAAA,GAEAA,EAAA,GAGA/C,EAAAza,UAAAwkB,aAAA,SAAAnlB,EAAAme,EAAA2E,GAUA,OATA9iB,KACAme,GAAA,EACA2E,GAAAN,EAAArc,KAAAnG,EAAAme,EAAA,gBACA/C,EAAAC,qBACAlV,KAAAgY,GAAAne,IAAA,EACAmG,KAAAgY,EAAA,OAAAne,GAEAyiB,EAAAtc,KAAAnG,EAAAme,GAAA,GAEAA,EAAA,GAGA/C,EAAAza,UAAAykB,aAAA,SAAAplB,EAAAme,EAAA2E,GAYA,OAXA9iB,KACAme,GAAA,EACA2E,GAAAN,EAAArc,KAAAnG,EAAAme,EAAA,0BACA/C,EAAAC,qBACAlV,KAAAgY,GAAA,IAAAne,EACAmG,KAAAgY,EAAA,GAAAne,IAAA,EACAmG,KAAAgY,EAAA,GAAAne,IAAA,GACAmG,KAAAgY,EAAA,GAAAne,IAAA,IAEA2iB,EAAAxc,KAAAnG,EAAAme,GAAA,GAEAA,EAAA,GAGA/C,EAAAza,UAAA0kB,aAAA,SAAArlB,EAAAme,EAAA2E,GAaA,OAZA9iB,KACAme,GAAA,EACA2E,GAAAN,EAAArc,KAAAnG,EAAAme,EAAA,0BACAne,EAAA,IAAAA,EAAA,WAAAA,EAAA,GACAob,EAAAC,qBACAlV,KAAAgY,GAAAne,IAAA,GACAmG,KAAAgY,EAAA,GAAAne,IAAA,GACAmG,KAAAgY,EAAA,GAAAne,IAAA,EACAmG,KAAAgY,EAAA,OAAAne,GAEA2iB,EAAAxc,KAAAnG,EAAAme,GAAA,GAEAA,EAAA,GAgBA/C,EAAAza,UAAA2kB,aAAA,SAAAtlB,EAAAme,EAAA2E,GACA,OAAAD,EAAA1c,KAAAnG,EAAAme,GAAA,EAAA2E,IAGA1H,EAAAza,UAAA4kB,aAAA,SAAAvlB,EAAAme,EAAA2E,GACA,OAAAD,EAAA1c,KAAAnG,EAAAme,GAAA,EAAA2E,IAWA1H,EAAAza,UAAA6kB,cAAA,SAAAxlB,EAAAme,EAAA2E,GACA,OAAAC,EAAA5c,KAAAnG,EAAAme,GAAA,EAAA2E,IAGA1H,EAAAza,UAAA8kB,cAAA,SAAAzlB,EAAAme,EAAA2E,GACA,OAAAC,EAAA5c,KAAAnG,EAAAme,GAAA,EAAA2E,IAIA1H,EAAAza,UAAA+b,KAAA,SAAA3N,EAAA2W,EAAAxa,EAAA2B,GAQA,GAPA3B,MAAA,GACA2B,GAAA,IAAAA,MAAA1G,KAAA/E,QACAskB,GAAA3W,EAAA3N,SAAAskB,EAAA3W,EAAA3N,QACAskB,MAAA,GACA7Y,EAAA,GAAAA,EAAA3B,IAAA2B,EAAA3B,GAGA2B,IAAA3B,EAAA,SACA,OAAA6D,EAAA3N,QAAA,IAAA+E,KAAA/E,OAAA,SAGA,GAAAskB,EAAA,EACA,UAAAlK,WAAA,6BAEA,GAAAtQ,EAAA,GAAAA,GAAA/E,KAAA/E,OAAA,UAAAoa,WAAA,6BACA,GAAA3O,EAAA,YAAA2O,WAAA,2BAGA3O,EAAA1G,KAAA/E,SAAAyL,EAAA1G,KAAA/E,QACA2N,EAAA3N,OAAAskB,EAAA7Y,EAAA3B,IACA2B,EAAAkC,EAAA3N,OAAAskB,EAAAxa,GAGA,IACAnM,EADA6O,EAAAf,EAAA3B,EAGA,GAAA/E,OAAA4I,GAAA7D,EAAAwa,KAAA7Y,EAEA,IAAA9N,EAAA6O,EAAA,EAAqB7O,GAAA,IAAQA,EAC7BgQ,EAAAhQ,EAAA2mB,GAAAvf,KAAApH,EAAAmM,QAEG,GAAA0C,EAAA,MAAAwN,EAAAC,oBAEH,IAAAtc,EAAA,EAAeA,EAAA6O,IAAS7O,EACxBgQ,EAAAhQ,EAAA2mB,GAAAvf,KAAApH,EAAAmM,QAGAuQ,WAAA9a,UAAAmT,IAAA5U,KACA6P,EACA5I,KAAAma,SAAApV,IAAA0C,GACA8X,GAIA,OAAA9X,GAOAwN,EAAAza,UAAAggB,KAAA,SAAA/D,EAAA1R,EAAA2B,EAAAsP,GAEA,oBAAAS,EAAA,CASA,GARA,iBAAA1R,GACAiR,EAAAjR,EACAA,EAAA,EACA2B,EAAA1G,KAAA/E,QACK,iBAAAyL,IACLsP,EAAAtP,EACAA,EAAA1G,KAAA/E,QAEA,IAAAwb,EAAAxb,OAAA,CACA,IAAAmU,EAAAqH,EAAA9Y,WAAA,GACAyR,EAAA,MACAqH,EAAArH,GAGA,QAAA7N,IAAAyU,GAAA,iBAAAA,EACA,UAAAlW,UAAA,6BAEA,oBAAAkW,IAAAf,EAAAgB,WAAAD,GACA,UAAAlW,UAAA,qBAAAkW,OAEG,iBAAAS,IACHA,GAAA,KAIA,GAAA1R,EAAA,GAAA/E,KAAA/E,OAAA8J,GAAA/E,KAAA/E,OAAAyL,EACA,UAAA2O,WAAA,sBAGA,GAAA3O,GAAA3B,EACA,OAAA/E,KAQA,IAAApH,EACA,GANAmM,KAAA,EACA2B,OAAAnF,IAAAmF,EAAA1G,KAAA/E,OAAAyL,IAAA,EAEA+P,MAAA,GAGA,iBAAAA,EACA,IAAA7d,EAAAmM,EAAmBnM,EAAA8N,IAAS9N,EAC5BoH,KAAApH,GAAA6d,MAEG,CACH,IAAA0F,EAAAlH,EAAAoB,SAAAI,GACAA,EACAO,EAAA,IAAA/B,EAAAwB,EAAAT,GAAAvT,YACAgF,EAAA0U,EAAAlhB,OACA,IAAArC,EAAA,EAAeA,EAAA8N,EAAA3B,IAAiBnM,EAChCoH,KAAApH,EAAAmM,GAAAoX,EAAAvjB,EAAA6O,GAIA,OAAAzH,MAMA,IAAAwf,EAAA,qBAmBA,SAAAtD,EAAA7hB,GACA,OAAAA,EAAA,OAAAA,EAAAoI,SAAA,IACApI,EAAAoI,SAAA,IAGA,SAAAuU,EAAAlS,EAAA+T,GAEA,IAAAY,EADAZ,KAAA4G,IAMA,IAJA,IAAAxkB,EAAA6J,EAAA7J,OACAykB,EAAA,KACAvD,KAEAvjB,EAAA,EAAiBA,EAAAqC,IAAYrC,EAAA,CAI7B,IAHA6gB,EAAA3U,EAAAnH,WAAA/E,IAGA,OAAA6gB,EAAA,OAEA,IAAAiG,EAAA,CAEA,GAAAjG,EAAA,QAEAZ,GAAA,OAAAsD,EAAApW,KAAA,aACA,SACS,GAAAnN,EAAA,IAAAqC,EAAA,EAET4d,GAAA,OAAAsD,EAAApW,KAAA,aACA,SAIA2Z,EAAAjG,EAEA,SAIA,GAAAA,EAAA,QACAZ,GAAA,OAAAsD,EAAApW,KAAA,aACA2Z,EAAAjG,EACA,SAIAA,EAAA,OAAAiG,EAAA,UAAAjG,EAAA,YACKiG,IAEL7G,GAAA,OAAAsD,EAAApW,KAAA,aAMA,GAHA2Z,EAAA,KAGAjG,EAAA,KACA,IAAAZ,GAAA,WACAsD,EAAApW,KAAA0T,QACK,GAAAA,EAAA,MACL,IAAAZ,GAAA,WACAsD,EAAApW,KACA0T,GAAA,MACA,GAAAA,EAAA,UAEK,GAAAA,EAAA,OACL,IAAAZ,GAAA,WACAsD,EAAApW,KACA0T,GAAA,OACAA,GAAA,SACA,GAAAA,EAAA,SAEK,MAAAA,EAAA,SASL,UAAAve,MAAA,sBARA,IAAA2d,GAAA,WACAsD,EAAApW,KACA0T,GAAA,OACAA,GAAA,UACAA,GAAA,SACA,GAAAA,EAAA,MAOA,OAAA0C,EA4BA,SAAAlF,EAAAjY,GACA,OAAA8V,EAAA6K,YAhIA,SAAA3gB,GAIA,IAFAA,EAUA,SAAAA,GACA,OAAAA,EAAAwH,KAAAxH,EAAAwH,OACAxH,EAAAlC,QAAA,iBAZA8iB,CAAA5gB,GAAAlC,QAAA0iB,EAAA,KAEAvkB,OAAA,WAEA,KAAA+D,EAAA/D,OAAA,MACA+D,GAAA,IAEA,OAAAA,EAuHA6gB,CAAA7gB,IAGA,SAAAsZ,EAAAwH,EAAAC,EAAA/H,EAAA/c,GACA,QAAArC,EAAA,EAAiBA,EAAAqC,KACjBrC,EAAAof,GAAA+H,EAAA9kB,QAAArC,GAAAknB,EAAA7kB,UAD6BrC,EAE7BmnB,EAAAnnB,EAAAof,GAAA8H,EAAAlnB,GAEA,OAAAA,uCClvDAR,EAAA4nB,mBAA6BtnB,EAAQ,IAA4BsnB,mBACjE5nB,EAAA6nB,kBAA4BvnB,EAAQ,IAA2BunB,kBAC/D7nB,EAAA8nB,WAAqBxnB,EAAQ,IAAmBwnB,4BCAhD,IAAAC,EAAgBznB,EAAQ,IACxB0nB,EAAW1nB,EAAQ,GACnB2nB,EAAe3nB,EAAQ,IAAa2nB,SACpCC,EAAkB5nB,EAAQ,IAAgB4nB,YAU1C,SAAAN,EAAAnlB,GACAA,IACAA,MAEAmF,KAAAugB,MAAAH,EAAAxlB,OAAAC,EAAA,aACAmF,KAAAwgB,YAAAJ,EAAAxlB,OAAAC,EAAA,mBACAmF,KAAAygB,gBAAAL,EAAAxlB,OAAAC,EAAA,qBACAmF,KAAA0gB,SAAA,IAAAL,EACArgB,KAAA2gB,OAAA,IAAAN,EACArgB,KAAA4gB,UAAA,IAAAN,EACAtgB,KAAA6gB,iBAAA,KAGAb,EAAAxlB,UAAAsmB,SAAA,EAOAd,EAAAe,cACA,SAAAC,GACA,IAAA5hB,EAAA4hB,EAAA5hB,WACA6hB,EAAA,IAAAjB,GACA/R,KAAA+S,EAAA/S,KACA7O,eA2CA,OAzCA4hB,EAAAE,YAAA,SAAAC,GACA,IAAAC,GACAC,WACAtf,KAAAof,EAAAxiB,cACAqD,OAAAmf,EAAAziB,kBAIA,MAAAyiB,EAAA5iB,SACA6iB,EAAA7iB,OAAA4iB,EAAA5iB,OACA,MAAAa,IACAgiB,EAAA7iB,OAAA6hB,EAAApjB,SAAAoC,EAAAgiB,EAAA7iB,SAGA6iB,EAAAE,UACAvf,KAAAof,EAAA3iB,aACAwD,OAAAmf,EAAA1iB,gBAGA,MAAA0iB,EAAAhoB,OACAioB,EAAAjoB,KAAAgoB,EAAAhoB,OAIA8nB,EAAAM,WAAAH,KAEAJ,EAAAQ,QAAAC,QAAA,SAAAC,GACA,IAAAC,EAAAD,EACA,OAAAtiB,IACAuiB,EAAAvB,EAAApjB,SAAAoC,EAAAsiB,IAGAT,EAAAP,SAAAkB,IAAAD,IACAV,EAAAP,SAAAvc,IAAAwd,GAGA,IAAAhN,EAAAqM,EAAAa,iBAAAH,GACA,MAAA/M,GACAsM,EAAAa,iBAAAJ,EAAA/M,KAGAsM,GAaAjB,EAAAxlB,UAAA+mB,WACA,SAAA1mB,GACA,IAAAwmB,EAAAjB,EAAAxlB,OAAAC,EAAA,aACAymB,EAAAlB,EAAAxlB,OAAAC,EAAA,iBACA0D,EAAA6hB,EAAAxlB,OAAAC,EAAA,eACA1B,EAAAinB,EAAAxlB,OAAAC,EAAA,aAEAmF,KAAAygB,iBACAzgB,KAAA+hB,iBAAAV,EAAAC,EAAA/iB,EAAApF,GAGA,MAAAoF,IACAA,EAAA+O,OAAA/O,GACAyB,KAAA0gB,SAAAkB,IAAArjB,IACAyB,KAAA0gB,SAAAvc,IAAA5F,IAIA,MAAApF,IACAA,EAAAmU,OAAAnU,GACA6G,KAAA2gB,OAAAiB,IAAAzoB,IACA6G,KAAA2gB,OAAAxc,IAAAhL,IAIA6G,KAAA4gB,UAAAzc,KACAxF,cAAA0iB,EAAAtf,KACArD,gBAAA2iB,EAAArf,OACAxD,aAAA,MAAA8iB,KAAAvf,KACAtD,eAAA,MAAA6iB,KAAAtf,OACAzD,SACApF,UAOA6mB,EAAAxlB,UAAAsnB,iBACA,SAAAE,EAAAC,GACA,IAAA1jB,EAAAyjB,EACA,MAAAhiB,KAAAwgB,cACAjiB,EAAA6hB,EAAApjB,SAAAgD,KAAAwgB,YAAAjiB,IAGA,MAAA0jB,GAGAjiB,KAAA6gB,mBACA7gB,KAAA6gB,iBAAAvnB,OAAAY,OAAA,OAEA8F,KAAA6gB,iBAAAT,EAAAriB,YAAAQ,IAAA0jB,GACKjiB,KAAA6gB,0BAGL7gB,KAAA6gB,iBAAAT,EAAAriB,YAAAQ,IACA,IAAAjF,OAAA4oB,KAAAliB,KAAA6gB,kBAAA5lB,SACA+E,KAAA6gB,iBAAA,QAqBAb,EAAAxlB,UAAA2nB,eACA,SAAAnB,EAAAgB,EAAAI,GACA,IAAAV,EAAAM,EAEA,SAAAA,EAAA,CACA,SAAAhB,EAAA/S,KACA,UAAA/S,MACA,iJAIAwmB,EAAAV,EAAA/S,KAEA,IAAA7O,EAAAY,KAAAwgB,YAEA,MAAAphB,IACAsiB,EAAAtB,EAAApjB,SAAAoC,EAAAsiB,IAIA,IAAAW,EAAA,IAAAhC,EACAiC,EAAA,IAAAjC,EAGArgB,KAAA4gB,UAAA2B,gBAAA,SAAApB,GACA,GAAAA,EAAA5iB,SAAAmjB,GAAA,MAAAP,EAAA3iB,aAAA,CAEA,IAAA8iB,EAAAN,EAAAwB,qBACAzgB,KAAAof,EAAA3iB,aACAwD,OAAAmf,EAAA1iB,iBAEA,MAAA6iB,EAAA/iB,SAEA4iB,EAAA5iB,OAAA+iB,EAAA/iB,OACA,MAAA6jB,IACAjB,EAAA5iB,OAAA6hB,EAAA5jB,KAAA4lB,EAAAjB,EAAA5iB,SAEA,MAAAa,IACA+hB,EAAA5iB,OAAA6hB,EAAApjB,SAAAoC,EAAA+hB,EAAA5iB,SAEA4iB,EAAA3iB,aAAA8iB,EAAAvf,KACAof,EAAA1iB,eAAA6iB,EAAAtf,OACA,MAAAsf,EAAAnoB,OACAgoB,EAAAhoB,KAAAmoB,EAAAnoB,OAKA,IAAAoF,EAAA4iB,EAAA5iB,OACA,MAAAA,GAAA8jB,EAAAT,IAAArjB,IACA8jB,EAAAle,IAAA5F,GAGA,IAAApF,EAAAgoB,EAAAhoB,KACA,MAAAA,GAAAmpB,EAAAV,IAAAzoB,IACAmpB,EAAAne,IAAAhL,IAGK6G,MACLA,KAAA0gB,SAAA2B,EACAriB,KAAA2gB,OAAA2B,EAGAtB,EAAAQ,QAAAC,QAAA,SAAAC,GACA,IAAA/M,EAAAqM,EAAAa,iBAAAH,GACA,MAAA/M,IACA,MAAAyN,IACAV,EAAAtB,EAAA5jB,KAAA4lB,EAAAV,IAEA,MAAAtiB,IACAsiB,EAAAtB,EAAApjB,SAAAoC,EAAAsiB,IAEA1hB,KAAA8hB,iBAAAJ,EAAA/M,KAEK3U,OAcLggB,EAAAxlB,UAAAunB,iBACA,SAAAU,EAAAC,EAAAC,EACA7nB,GAKA,GAAA4nB,GAAA,iBAAAA,EAAA3gB,MAAA,iBAAA2gB,EAAA1gB,OACA,UAAA9G,MACA,gPAMA,MAAAunB,GAAA,SAAAA,GAAA,WAAAA,GACAA,EAAA1gB,KAAA,GAAA0gB,EAAAzgB,QAAA,IACA0gB,GAAAC,GAAA7nB,MAIA2nB,GAAA,SAAAA,GAAA,WAAAA,GACAC,GAAA,SAAAA,GAAA,WAAAA,GACAD,EAAA1gB,KAAA,GAAA0gB,EAAAzgB,QAAA,GACA0gB,EAAA3gB,KAAA,GAAA2gB,EAAA1gB,QAAA,GACA2gB,GAKA,UAAAznB,MAAA,oBAAA+D,KAAA0D,WACA0e,UAAAoB,EACAlkB,OAAAokB,EACArB,SAAAoB,EACAvpB,KAAA2B,MASAklB,EAAAxlB,UAAAooB,mBACA,WAcA,IAbA,IAOA7e,EACAod,EACA0B,EACAC,EAVAC,EAAA,EACAC,EAAA,EACAC,EAAA,EACAC,EAAA,EACAC,EAAA,EACAC,EAAA,EACAlhB,EAAA,GAMAmhB,EAAArjB,KAAA4gB,UAAA0C,UACA1qB,EAAA,EAAA6O,EAAA4b,EAAApoB,OAA0CrC,EAAA6O,EAAS7O,IAAA,CAInD,GAFAmL,EAAA,IADAod,EAAAkC,EAAAzqB,IAGA+F,gBAAAqkB,EAEA,IADAD,EAAA,EACA5B,EAAAxiB,gBAAAqkB,GACAjf,GAAA,IACAif,SAIA,GAAApqB,EAAA,GACA,IAAAwnB,EAAAthB,oCAAAqiB,EAAAkC,EAAAzqB,EAAA,IACA,SAEAmL,GAAA,IAIAA,GAAAoc,EAAAoD,OAAApC,EAAAziB,gBACAqkB,GACAA,EAAA5B,EAAAziB,gBAEA,MAAAyiB,EAAA5iB,SACAukB,EAAA9iB,KAAA0gB,SAAAxjB,QAAAikB,EAAA5iB,QACAwF,GAAAoc,EAAAoD,OAAAT,EAAAM,GACAA,EAAAN,EAGA/e,GAAAoc,EAAAoD,OAAApC,EAAA3iB,aAAA,EACA0kB,GACAA,EAAA/B,EAAA3iB,aAAA,EAEAuF,GAAAoc,EAAAoD,OAAApC,EAAA1iB,eACAwkB,GACAA,EAAA9B,EAAA1iB,eAEA,MAAA0iB,EAAAhoB,OACA0pB,EAAA7iB,KAAA2gB,OAAAzjB,QAAAikB,EAAAhoB,MACA4K,GAAAoc,EAAAoD,OAAAV,EAAAM,GACAA,EAAAN,IAIA3gB,GAAA6B,EAGA,OAAA7B,GAGA8d,EAAAxlB,UAAAgpB,wBACA,SAAAC,EAAAC,GACA,OAAAD,EAAAzgB,IAAA,SAAAzE,GACA,IAAAyB,KAAA6gB,iBACA,YAEA,MAAA6C,IACAnlB,EAAA6hB,EAAApjB,SAAA0mB,EAAAnlB,IAEA,IAAApE,EAAAimB,EAAAriB,YAAAQ,GACA,OAAAjF,OAAAkB,UAAAC,eAAA1B,KAAAiH,KAAA6gB,iBAAA1mB,GACA6F,KAAA6gB,iBAAA1mB,GACA,MACK6F,OAMLggB,EAAAxlB,UAAA6J,OACA,WACA,IAAArB,GACAoP,QAAApS,KAAA8gB,SACAU,QAAAxhB,KAAA0gB,SAAA4C,UACAK,MAAA3jB,KAAA2gB,OAAA2C,UACAD,SAAArjB,KAAA4iB,sBAYA,OAVA,MAAA5iB,KAAAugB,QACAvd,EAAAiL,KAAAjO,KAAAugB,OAEA,MAAAvgB,KAAAwgB,cACAxd,EAAA5D,WAAAY,KAAAwgB,aAEAxgB,KAAA6gB,mBACA7d,EAAA4gB,eAAA5jB,KAAAwjB,wBAAAxgB,EAAAwe,QAAAxe,EAAA5D,aAGA4D,GAMAgd,EAAAxlB,UAAAiI,SACA,WACA,OAAAxD,KAAA0D,UAAA3C,KAAAqE,WAGAjM,EAAA4nB,sCCnYA,IAAAlL,EAAapc,EAAQ,IAsDrBN,EAAAmrB,OAAA,SAAAM,GACA,IACAC,EADAC,EAAA,GAGAC,EA3BA,SAAAH,GACA,OAAAA,EAAA,EACA,IAAAA,GAAA,GACA,GAAAA,GAAA,GAwBAI,CAAAJ,GAEA,GACAC,EAzCAI,GAyCAF,GACAA,KAhDA,GAiDA,IAGAF,GAjDA,IAmDAC,GAAAjP,EAAAyO,OAAAO,SACGE,EAAA,GAEH,OAAAD,GAOA3rB,EAAA+rB,OAAA,SAAAnmB,EAAAomB,EAAAC,GACA,IAGAC,EAAAR,EAHA3L,EAAAna,EAAA/C,OACAiH,EAAA,EACAqiB,EAAA,EAGA,GACA,GAAAH,GAAAjM,EACA,UAAAjd,MAAA,8CAIA,SADA4oB,EAAAhP,EAAAqP,OAAAnmB,EAAAL,WAAAymB,OAEA,UAAAlpB,MAAA,yBAAA8C,EAAAnB,OAAAunB,EAAA,IAGAE,KA7EA,GA6EAR,GAEA5hB,IADA4hB,GA3EAI,KA4EAK,EACAA,GAnFA,QAoFGD,GAEHD,EAAAxqB,MAzDA,SAAAgqB,GACA,IACAW,EAAAX,GAAA,EACA,OAFA,MAAAA,IAGAW,EACAA,EAoDAC,CAAAviB,GACAmiB,EAAAK,KAAAN,oBCnIA,IAAAhE,EAAW1nB,EAAQ,GACnBkpB,EAAAtoB,OAAAkB,UAAAC,eACAkqB,EAAA,oBAAAC,IAQA,SAAAvE,IACArgB,KAAA6kB,UACA7kB,KAAA8kB,KAAAH,EAAA,IAAAC,IAAAtrB,OAAAY,OAAA,MAMAmmB,EAAA0E,UAAA,SAAAC,EAAAC,GAEA,IADA,IAAAtX,EAAA,IAAA0S,EACAznB,EAAA,EAAA6O,EAAAud,EAAA/pB,OAAsCrC,EAAA6O,EAAS7O,IAC/C+U,EAAAxJ,IAAA6gB,EAAApsB,GAAAqsB,GAEA,OAAAtX,GASA0S,EAAA7lB,UAAAqc,KAAA,WACA,OAAA8N,EAAA3kB,KAAA8kB,KAAAjO,KAAAvd,OAAA4rB,oBAAAllB,KAAA8kB,MAAA7pB,QAQAolB,EAAA7lB,UAAA2J,IAAA,SAAAnG,EAAAinB,GACA,IAAAE,EAAAR,EAAA3mB,EAAAoiB,EAAAriB,YAAAC,GACAonB,EAAAT,EAAA3kB,KAAA4hB,IAAA5jB,GAAA4jB,EAAA7oB,KAAAiH,KAAA8kB,KAAAK,GACAE,EAAArlB,KAAA6kB,OAAA5pB,OACAmqB,IAAAH,GACAjlB,KAAA6kB,OAAA9e,KAAA/H,GAEAonB,IACAT,EACA3kB,KAAA8kB,KAAAnX,IAAA3P,EAAAqnB,GAEArlB,KAAA8kB,KAAAK,GAAAE,IAUAhF,EAAA7lB,UAAAonB,IAAA,SAAA5jB,GACA,GAAA2mB,EACA,OAAA3kB,KAAA8kB,KAAAlD,IAAA5jB,GAEA,IAAAmnB,EAAA/E,EAAAriB,YAAAC,GACA,OAAA4jB,EAAA7oB,KAAAiH,KAAA8kB,KAAAK,IASA9E,EAAA7lB,UAAA0C,QAAA,SAAAc,GACA,GAAA2mB,EAAA,CACA,IAAAU,EAAArlB,KAAA8kB,KAAArrB,IAAAuE,GACA,GAAAqnB,GAAA,EACA,OAAAA,MAEG,CACH,IAAAF,EAAA/E,EAAAriB,YAAAC,GACA,GAAA4jB,EAAA7oB,KAAAiH,KAAA8kB,KAAAK,GACA,OAAAnlB,KAAA8kB,KAAAK,GAIA,UAAAjqB,MAAA,IAAA8C,EAAA,yBAQAqiB,EAAA7lB,UAAA8qB,GAAA,SAAAC,GACA,GAAAA,GAAA,GAAAA,EAAAvlB,KAAA6kB,OAAA5pB,OACA,OAAA+E,KAAA6kB,OAAAU,GAEA,UAAArqB,MAAA,yBAAAqqB,IAQAlF,EAAA7lB,UAAA8oB,QAAA,WACA,OAAAtjB,KAAA6kB,OAAAxnB,SAGAjF,EAAAioB,yCCtHAjoB,EAAA4B,YAAA,EAUA,IAAA+gB,GACA1e,MAAA,SAAAyI,EAAA0gB,EAAAngB,GASA,IARA,IAAAsQ,KACA8P,EAAA,GACAppB,GAAA,EAEAqpB,EAAA,EACAC,GAAA,EACAC,GAAA,EAEAhtB,EAAA,EAAmBA,EAAAkM,EAAA7J,OAAmBrC,IAAA,CACtC,IAAAitB,EAAA/gB,EAAAlM,GAEA+sB,EACAC,EACAA,GAAA,EACS,OAAAC,EACTD,GAAA,EACSC,IAAAF,IACTA,GAAA,GAEO,MAAAE,GAAA,MAAAA,EACPF,EAAAE,EACO,MAAAA,EACPH,GAAA,EACO,MAAAG,EACPH,EAAA,IAAAA,GAAA,GACO,IAAAA,IACP,IAAAF,EAAAtoB,QAAA2oB,KAAAxpB,GAAA,GAGAA,GACA,KAAAopB,GAAA9P,EAAA5P,KAAA0f,EAAAjf,QACAif,EAAA,GACAppB,GAAA,GAEAopB,GAAAI,EAKA,OADAxgB,GAAA,KAAAogB,IAAA9P,EAAA5P,KAAA0f,EAAAjf,QACAmP,GAeAmQ,MAAA,SAAAhhB,GAEA,OAAAiW,EAAA1e,MAAAyI,GADA,iBAiBA4I,MAAA,SAAA5I,GACA,OAAAiW,EAAA1e,MAAAyI,GAAA,WAIA1M,EAAA2I,QAAAga,EACA1iB,EAAAD,UAAA,sCC1FAA,EAAA4B,YAAA,EAwBA,IAAA+rB,EAAA,SAAA9d,GAGA,SAAA8d,EAAApmB,IAnBA,SAAAC,EAAAC,GAAiD,KAAAD,aAAAC,GAA0C,UAAAC,UAAA,qCAoB3FC,CAAAC,KAAA+lB,GAEA,IAAA9lB,EApBA,SAAAC,EAAAnH,GAAiD,IAAAmH,EAAa,UAAAC,eAAA,6DAAyF,OAAApH,GAAA,iBAAAA,GAAA,mBAAAA,EAAAmH,EAAAnH,EAoBvJqH,CAAAJ,KAAAiI,EAAAlP,KAAAiH,KAAAL,IAIA,OAFAM,EAAAI,KAAA,OACAJ,EAAAuD,QAAAvD,EAAAuD,UACAvD,EAwFA,OA9GA,SAAAK,EAAAC,GAA0C,sBAAAA,GAAA,OAAAA,EAA+D,UAAAT,UAAA,kEAAAS,GAAuGD,EAAA9F,UAAAlB,OAAAY,OAAAqG,KAAA/F,WAAyEgG,aAAe3G,MAAAyG,EAAA9G,YAAA,EAAAiH,UAAA,EAAAC,cAAA,KAA6EH,IAAAjH,OAAAqH,eAAArH,OAAAqH,eAAAL,EAAAC,GAAAD,EAAAM,UAAAL,GAarXM,CAAAklB,EAAA9d,GAYA8d,EAAAvrB,UAAAgI,YAAA,SAAA4G,EAAA4c,GACA,IAAA7oB,EAAA6C,KAAA7C,MAAAiM,GAMA,OAJA4c,GAAA,IAAA7oB,GAAA6C,KAAAwD,MAAAvI,OAAA,IACA+E,KAAAwD,MAAA,GAAAhC,KAAA0C,OAAAlE,KAAAwD,MAAArG,GAAAqE,KAAA0C,QAGA+D,EAAAzN,UAAAgI,YAAAzJ,KAAAiH,KAAAoJ,IAGA2c,EAAAvrB,UAAAwB,UAAA,SAAAoN,EAAAsD,EAAArM,GACA,IAAAmD,EAAAyE,EAAAzN,UAAAwB,UAAAjD,KAAAiH,KAAAoJ,GAEA,GAAAsD,EACA,eAAArM,EACAL,KAAAwD,MAAAvI,OAAA,EACAyR,EAAAlL,KAAA0C,OAAAlE,KAAAwD,MAAA,GAAAhC,KAAA0C,cAEAwI,EAAAlL,KAAA0C,YAEO,GAAAlE,KAAA4K,QAAA8B,EACP,KAAAhJ,EAAAF,EAAAG,EAAArG,MAAAsG,QAAAF,GAAAG,EAAA,MAAAH,EAAAC,EAAAD,IAAA/J,OAAAuH,cAAkJ,CAClJ,IAAA4C,EAEA,GAAAH,EAAA,CACA,GAAAE,GAAAH,EAAAzI,OAAA,MACA6I,EAAAJ,EAAAG,SACW,CAEX,IADAA,EAAAH,EAAAK,QACAC,KAAA,MACAF,EAAAD,EAAAhK,MAGAiK,EAEAtC,KAAA0C,OAAAwI,EAAAlL,KAAA0C,QAKA,OAAAV,GAkBAuiB,EAAAvrB,UAAAyrB,SAAA,WACA,IAAAtkB,EAAA3G,UAAAC,OAAA,QAAAsG,IAAAvG,UAAA,GAAAA,UAAA,MAMA,OADA,IAHqBtC,EAAQ,IAG7B,KAFoBA,EAAQ,KAE5BsH,KAAA2B,GACAgB,aAoBAojB,EAlGA,CAlBA,SAAAjlB,GAAsC,OAAAA,KAAA9G,WAAA8G,GAAuCC,QAAAD,GAF7EE,CAFiBtI,EAAQ,IAyHxBqI,SAED3I,EAAA2I,QAAAglB,EACA1tB,EAAAD,UAAA,mTChIAM,EAAA,eAEe,SAACwtB,GAAsB,IAAdvkB,EAAc3G,UAAAC,OAAA,QAAAsG,IAAAvG,UAAA,GAAAA,UAAA,MAC9BmrB,KAECxkB,GAEPukB,EAAOE,mBAAmBve,gWCP5BnP,EAAA,KAOO,IAAM2tB,QAAM,SAACH,EAAQI,GAAT,OACjBJ,GAAUA,EAAOG,IAAIC,GAAOrsB,GAAI,mBAOrBssB,eAAa,SAAAlkB,GACxB,IACMmkB,KAMN,OAPqBnkB,EAAKmB,WAGbie,QAAQ,SAAA3d,GAAgC,IAA7BU,EAA6BV,EAA7BU,KAAM3K,EAAuBiK,EAAvBjK,MAAO0W,EAAgBzM,EAAhByM,UACnCiW,EAAMhiB,GAAQ3K,GAAS0W,EAAY,cAAgB,OAInDkW,UAAWpkB,EAAK2H,UAAY,GAC5Bwc,UAUSE,iBAAe,SAACrkB,EAAMH,GAAW,IACpC/I,EAAiBkJ,EAAjBlJ,KAAMyX,EAAWvO,EAAXuO,QACI,QAAS,aAAa1T,QAAQ/D,IAAS,EAGvDkJ,EAAKmB,MAAMie,QAAQ,SAAApf,GACjBH,EAAO6D,KAAP4gB,KACKJ,EAAWlkB,IACdukB,OAAQztB,EACRyX,cAIJ1O,EAAO6D,KAAP4gB,KACKJ,EAAWlkB,IACdukB,OAAQztB,gBAKC,SAACyO,EAAKse,GACnB,IAAMhkB,KACNmkB,EAAIH,GAAS,YAAate,IAE1B,IAAMif,EAAMpU,UAAQvT,MAAM0I,GAkB1B,OAjBAye,EAAIH,GAAS,cAAeW,IAE5BA,EAAIrjB,MAAMie,QAAQ,SAAApf,GAGhB,OAFiBA,EAAThC,MAGN,IAAK,OACH6B,EAAO6D,KAAKwgB,EAAWlkB,IACvB,MACF,IAAK,SACHqkB,EAAarkB,EAAMH,MAKzBmkB,EAAIH,GAAS,SAAUhkB,IAEhBA,iCC3ET9J,EAAA4B,YAAA,EAEA,IAEAiP,EAAAjI,EAFmBtI,EAAQ,IAM3BouB,EAAA9lB,EAFiBtI,EAAQ,KAMzB2I,EAAAL,EAFiBtI,EAAQ,IAMzBwQ,EAAAlI,EAFetI,EAAQ,IAMvBquB,EAAA/lB,EAFctI,EAAQ,IAMtBsuB,EAAAhmB,EAFctI,EAAQ,KAMtBma,EAAA7R,EAFatI,EAAQ,IAMrB8U,EAAAxM,EAFYtI,EAAQ,KAMpBuuB,EAAAjmB,EAFYtI,EAAQ,IAMpBwuB,EAAAlmB,EAFYtI,EAAQ,KAIpB,SAAAsI,EAAAF,GAAsC,OAAAA,KAAA9G,WAAA8G,GAAuCC,QAAAD,GAoB7E,SAAA2R,IACA,QAAAlP,EAAAvI,UAAAC,OAAAkX,EAAA7U,MAAAiG,GAAAE,EAAA,EAAoEA,EAAAF,EAAaE,IACjF0O,EAAA1O,GAAAzI,UAAAyI,GAMA,OAHA,IAAA0O,EAAAlX,QAAAqC,MAAAsG,QAAAuO,EAAA,MACAA,IAAA,IAEA,IAAA2U,EAAA/lB,QAAAoR,GA2EAM,EAAAvE,OAAA,SAAA/U,EAAAguB,GACA,SAAAC,IACA,IAAAC,EAAAF,EAAA9e,WAAA9G,EAAAvG,WAGA,OAFAqsB,EAAArT,cAAA7a,EACAkuB,EAAAtT,gBAAA,IAAA+S,EAAA/lB,SAAAqR,QACAiV,EAGA,IAAAC,OAAA,EAYA,OAXAhuB,OAAAC,eAAA6tB,EAAA,WACA3tB,IAAA,WAEA,OADA6tB,MAAAF,KACAE,KAIAF,EAAAliB,QAAA,SAAA0C,EAAA2f,EAAAC,GACA,OAAA/U,GAAA2U,EAAAI,KAAAtiB,QAAA0C,EAAA2f,IAGAH,GAcA3U,EAAA9P,UAAAtB,EAAAN,QAoBA0R,EAAAvT,MAAA2T,EAAA9R,QAUA0R,EAAAgV,OAAAT,EAAAjmB,QAUA0R,EAAAsI,KAAAvN,EAAAzM,QAYA0R,EAAAtC,QAAA,SAAAxQ,GACA,WAAAuJ,EAAAnI,QAAApB,IAaA8S,EAAAmU,OAAA,SAAAjnB,GACA,WAAAonB,EAAAhmB,QAAApB,IAaA8S,EAAApG,KAAA,SAAA1M,GACA,WAAAsJ,EAAAlI,QAAApB,IAaA8S,EAAAjC,KAAA,SAAA7Q,GACA,WAAAsnB,EAAAlmB,QAAApB,IAaA8S,EAAAva,KAAA,SAAAyH,GACA,WAAAunB,EAAAnmB,QAAApB,IAGAvH,EAAA2I,QAAA0R,EACApa,EAAAD,UAAA,uFCtSA,SAAA6c,GAEA7c,EAAA4B,YAAA,EAEA,IAEA0tB,EAAA1mB,EAFiBtI,EAAQ,KAMzBivB,EAAA3mB,EAFYtI,EAAQ,IAIpB,SAAAsI,EAAAF,GAAsC,OAAAA,KAAA9G,WAAA8G,GAAuCC,QAAAD,GAI7E,IAAA8mB,EAAA,WACA,SAAAA,EAAAjlB,EAAAzK,EAAAyJ,IAHA,SAAA/B,EAAAC,GAAiD,KAAAD,aAAAC,GAA0C,UAAAC,UAAA,qCAI3FC,CAAAC,KAAA4nB,GAEA5nB,KAAA2C,YACA3C,KAAA6nB,QAAAlmB,EAAAqB,QACAhD,KAAA9H,OACA8H,KAAA2B,OAiSA,OA9RAimB,EAAAptB,UAAAstB,MAAA,WACA,gBAAA9nB,KAAA2B,KAAAqB,MACAhD,KAAA2B,KAAAqB,IAEAhD,KAAA+nB,WAAA9sB,OAAA,GAIA2sB,EAAAptB,UAAAutB,SAAA,WACA,IAAA9nB,EAAAD,KAcA,OAZAA,KAAAgoB,eACAhoB,KAAAgoB,gBACAhoB,KAAA9H,KAAAwR,KAAA,SAAArH,GACA,GAAAA,EAAA9D,QAAA8D,EAAA9D,OAAAuD,MAAAkB,IAAA,CACA,IAAAA,EAAAX,EAAA9D,OAAAuD,MAAAkB,KACA,IAAA/C,EAAA+nB,aAAA9qB,QAAA8F,IACA/C,EAAA+nB,aAAAjiB,KAAA/C,OAMAhD,KAAAgoB,cAGAJ,EAAAptB,UAAAytB,SAAA,WACA,YAAAjoB,KAAA6nB,QAAAzU,OACA,OAAApT,KAAA6nB,QAAAzU,OAGA,IAAA8U,EAAAloB,KAAA6nB,QAAAK,WACA,gBAAAA,IAAA,IAAAA,MAIAloB,KAAA+nB,WAAA9sB,QACA+E,KAAA+nB,WAAAtb,KAAA,SAAA7T,GACA,OAAAA,EAAAwa,WAOAwU,EAAAptB,UAAA2tB,iBAAA,WACA,gBAAAnoB,KAAA6nB,QAAAjE,eACA5jB,KAAA6nB,QAAAjE,gBAEA5jB,KAAA+nB,WAAA9sB,QACA+E,KAAA+nB,WAAAtb,KAAA,SAAA7T,GACA,OAAAA,EAAAwvB,iBAOAR,EAAAptB,UAAA6tB,gBAAA,WACA,QAAAroB,KAAA6nB,QAAAK,WAGA,IADA,IAAA7lB,OAAA,EACAzJ,EAAAoH,KAAA9H,KAAAsL,MAAAvI,OAAA,EAA4CrC,GAAA,EAAQA,IAEpD,aADAyJ,EAAArC,KAAA9H,KAAAsL,MAAA5K,IACAyH,MACA,IAAAgC,EAAAF,KAAAjF,QAAA,wBACA8C,KAAA9H,KAAAsK,YAAA5J,IAKAgvB,EAAAptB,UAAA8tB,kBAAA,WACA,IAAA3b,EAAA3M,KAEAuoB,KACAvoB,KAAA9H,KAAAwR,KAAA,SAAArH,GACA,GAAAA,EAAA9D,OAAA,CACA,IAAA+H,EAAAjE,EAAA9D,OAAAuD,MAAAwE,KACA,GAAAA,IAAAiiB,EAAAjiB,GAAA,CACAiiB,EAAAjiB,IAAA,EACA,IAAAtJ,EAAA2P,EAAA3P,SAAAsJ,GACAqG,EAAA3J,IAAA8e,iBAAA9kB,EAAAqF,EAAA9D,OAAAuD,MAAA8F,UAMAggB,EAAAptB,UAAAguB,cAAA,WACA,IAAA9kB,EAAA1D,KAAA+nB,WAAApkB,EAAArG,MAAAsG,QAAAF,GAAAG,EAAA,MAAAH,EAAAC,EAAAD,IAAA/J,OAAAuH,cAAwJ,CACxJ,IAAA4C,EAEA,GAAAH,EAAA,CACA,GAAAE,GAAAH,EAAAzI,OAAA,MACA6I,EAAAJ,EAAAG,SACO,CAEP,IADAA,EAAAH,EAAAK,QACAC,KAAA,MACAF,EAAAD,EAAAhK,MAGA,IAAAoK,EAAAH,EAEAwC,EAAAtG,KAAAhD,SAAAiH,EAAAgK,MACA/V,EAAA+L,EAAA/L,MAAAyvB,EAAA5mB,QAAAqG,QAAAnD,EAAAgK,MACAjL,OAAA,GAEA,IAAAhD,KAAA6nB,QAAAjE,gBACA5gB,EAAA,IAAA0kB,EAAA3mB,QAAAkf,kBAAAhc,EAAA9B,OACAyhB,iBACA5gB,EAAA4gB,eAAA5gB,EAAA4gB,eAAA5gB,IAAA,WACA,eAIAA,EAAAiB,EAAAwkB,WAGAzoB,KAAAgD,IAAAmf,eAAAnf,EAAAsD,EAAAtG,KAAAhD,SAAA9E,MAIA0vB,EAAAptB,UAAAkuB,aAAA,WACA,QAAA1oB,KAAAioB,kBAEK,IAAAjoB,KAAA6nB,QAAAK,WACLloB,KAAA6nB,QAAAK,YACKloB,KAAA+nB,WAAA9sB,QACL+E,KAAA+nB,WAAAtb,KAAA,SAAA7T,GACA,OAAAA,EAAAsvB,eAOAN,EAAAptB,UAAAmuB,SAAA,SAAA3pB,GACA,OAAAiW,EACAA,EAAA3O,KAAAtH,GAAAyD,SAAA,UAEAjK,OAAAowB,KAAAC,SAAAC,mBAAA9pB,MAIA4oB,EAAAptB,UAAAuuB,cAAA,WACA,IAAApU,OAAA,EAGAA,EADA3U,KAAAioB,WACA,gCAAuCjoB,KAAA2oB,SAAA3oB,KAAAgD,IAAAP,YAClC,iBAAAzC,KAAA6nB,QAAAK,WACLloB,KAAA6nB,QAAAK,WAEAloB,KAAAgpB,aAAA,OAGA,IAAAC,EAAA,MACA,IAAAjpB,KAAA4H,IAAA1K,QAAA,UAAA+rB,EAAA,QAEAjpB,KAAA4H,KAAAqhB,EAAA,wBAAAtU,EAAA,OAGAiT,EAAAptB,UAAAwuB,WAAA,WACA,OAAAhpB,KAAA2B,KAAA4E,GACAvG,KAAAhD,SAAAgD,KAAA2B,KAAA4E,IACKvG,KAAA2B,KAAA2E,KACLtG,KAAAhD,SAAAgD,KAAA2B,KAAA2E,MAEA,UAIAshB,EAAAptB,UAAA0uB,YAAA,WAMA,OALAlpB,KAAAmpB,iBACAnpB,KAAAmoB,oBAAAnoB,KAAAsoB,oBACAtoB,KAAA+nB,WAAA9sB,OAAA,GAAA+E,KAAAwoB,gBACAxoB,KAAA0oB,gBAAA1oB,KAAA+oB,gBAEA/oB,KAAAioB,YACAjoB,KAAA4H,MAEA5H,KAAA4H,IAAA5H,KAAAgD,MAIA4kB,EAAAptB,UAAAwC,SAAA,SAAAiR,GACA,OAAAA,EAAA/Q,QAAA,YAAA+Q,EACA,eAAAlR,KAAAkR,GAAA,OAAAA,EAEA,IAAA3H,EAAAtG,KAAA2B,KAAA4E,GAAAohB,EAAA5mB,QAAAqG,QAAApH,KAAA2B,KAAA4E,IAAA,IAOA,MALA,iBAAAvG,KAAA6nB,QAAAK,aACA5hB,EAAAqhB,EAAA5mB,QAAAqG,QAAAugB,EAAA5mB,QAAAiF,QAAAM,EAAAtG,KAAA6nB,QAAAK,cAGAja,EAAA0Z,EAAA5mB,QAAA/D,SAAAsJ,EAAA2H,GACA,OAAA0Z,EAAA5mB,QAAAmG,IACA+G,EAAAnR,QAAA,WAEAmR,GAIA2Z,EAAAptB,UAAA4uB,WAAA,SAAA/mB,GACA,OAAArC,KAAA6nB,QAAAvhB,KACAtG,KAAA6nB,QAAAvhB,KAEAtG,KAAAhD,SAAAqF,EAAA9D,OAAAuD,MAAAwE,OAIAshB,EAAAptB,UAAA2uB,eAAA,WACA,IAAAE,EAAArpB,KAEAA,KAAA4H,IAAA,GACA5H,KAAAgD,IAAA,IAAA0kB,EAAA3mB,QAAAif,oBAA2D/R,KAAAjO,KAAAgpB,eAE3D,IAAAjnB,EAAA,EACAC,EAAA,EAEAyM,OAAA,EACApJ,OAAA,EACArF,KAAA2C,UAAA3C,KAAA9H,KAAA,SAAA8G,EAAAqD,EAAAhC,GACAgpB,EAAAzhB,KAAA5I,EAEAqD,GAAA,QAAAhC,IACAgC,EAAA9D,QAAA8D,EAAA9D,OAAAwG,MACAskB,EAAArmB,IAAAue,YACAhjB,OAAA8qB,EAAAD,WAAA/mB,GACAgf,WAAwBtf,OAAAC,SAAA,GACxBsf,UACAvf,KAAAM,EAAA9D,OAAAwG,MAAAhD,KACAC,OAAAK,EAAA9D,OAAAwG,MAAA/C,OAAA,KAIAqnB,EAAArmB,IAAAue,YACAhjB,OAAA,cACA+iB,UAAuBvf,KAAA,EAAAC,OAAA,GACvBqf,WAAwBtf,OAAAC,SAAA,OAKxByM,EAAAzP,EAAAzD,MAAA,SAEAwG,GAAA0M,EAAAxT,OACAoK,EAAArG,EAAA5B,YAAA,MACA4E,EAAAhD,EAAA/D,OAAAoK,GAEArD,GAAAhD,EAAA/D,OAGAoH,GAAA,UAAAhC,IACAgC,EAAA9D,QAAA8D,EAAA9D,OAAAmI,IACA2iB,EAAArmB,IAAAue,YACAhjB,OAAA8qB,EAAAD,WAAA/mB,GACAgf,WAAwBtf,OAAAC,SAAA,GACxBsf,UACAvf,KAAAM,EAAA9D,OAAAmI,IAAA3E,KACAC,OAAAK,EAAA9D,OAAAmI,IAAA1E,UAIAqnB,EAAArmB,IAAAue,YACAhjB,OAAA,cACA+iB,UAAuBvf,KAAA,EAAAC,OAAA,GACvBqf,WAAwBtf,OAAAC,SAAA,SAOxB4lB,EAAAptB,UAAAka,SAAA,WAGA,GAFA1U,KAAAqoB,kBAEAroB,KAAA8nB,QACA,OAAA9nB,KAAAkpB,cAEA,IAAAhnB,EAAA,GAIA,OAHAlC,KAAA2C,UAAA3C,KAAA9H,KAAA,SAAAU,GACAsJ,GAAAtJ,KAEAsJ,IAIA0lB,EAxSA,GA2SAxvB,EAAA2I,QAAA6mB,EACAvvB,EAAAD,UAAA,iDC5TA,IAAAkxB,EAGAA,EAAA,WACA,OAAAtpB,KADA,GAIA,IAEAspB,KAAAC,SAAA,cAAAA,KAAA,EAAAC,MAAA,QACC,MAAA1hB,GAED,iBAAAtP,SAAA8wB,EAAA9wB,QAOAH,EAAAD,QAAAkxB,gCCjBAlxB,EAAAyd,WAuCA,SAAA4T,GACA,IAAAC,EAAAC,EAAAF,GACAG,EAAAF,EAAA,GACAG,EAAAH,EAAA,GACA,UAAAE,EAAAC,GAAA,EAAAA,GA1CAzxB,EAAAunB,YAiDA,SAAA8J,GAeA,IAdA,IAAAK,EACAJ,EAAAC,EAAAF,GACAG,EAAAF,EAAA,GACAG,EAAAH,EAAA,GAEAjjB,EAAA,IAAAsjB,EAVA,SAAAN,EAAAG,EAAAC,GACA,UAAAD,EAAAC,GAAA,EAAAA,EASAG,CAAAP,EAAAG,EAAAC,IAEAI,EAAA,EAGAxiB,EAAAoiB,EAAA,EACAD,EAAA,EACAA,EAEAhxB,EAAA,EAAiBA,EAAA6O,EAAS7O,GAAA,EAC1BkxB,EACAI,EAAAT,EAAA9rB,WAAA/E,KAAA,GACAsxB,EAAAT,EAAA9rB,WAAA/E,EAAA,QACAsxB,EAAAT,EAAA9rB,WAAA/E,EAAA,OACAsxB,EAAAT,EAAA9rB,WAAA/E,EAAA,IACA6N,EAAAwjB,KAAAH,GAAA,OACArjB,EAAAwjB,KAAAH,GAAA,MACArjB,EAAAwjB,KAAA,IAAAH,EAGA,IAAAD,IACAC,EACAI,EAAAT,EAAA9rB,WAAA/E,KAAA,EACAsxB,EAAAT,EAAA9rB,WAAA/E,EAAA,OACA6N,EAAAwjB,KAAA,IAAAH,GAGA,IAAAD,IACAC,EACAI,EAAAT,EAAA9rB,WAAA/E,KAAA,GACAsxB,EAAAT,EAAA9rB,WAAA/E,EAAA,OACAsxB,EAAAT,EAAA9rB,WAAA/E,EAAA,OACA6N,EAAAwjB,KAAAH,GAAA,MACArjB,EAAAwjB,KAAA,IAAAH,GAGA,OAAArjB,GA1FArO,EAAA8gB,cAiHA,SAAAiR,GAQA,IAPA,IAAAL,EACAriB,EAAA0iB,EAAAlvB,OACAmvB,EAAA3iB,EAAA,EACArL,KAIAxD,EAAA,EAAAyxB,EAAA5iB,EAAA2iB,EAA0CxxB,EAAAyxB,EAAUzxB,GAHpD,MAIAwD,EAAA2J,KAAAukB,EACAH,EAAAvxB,IALA,MAKAyxB,IAAAzxB,EALA,QAUA,IAAAwxB,GACAN,EAAAK,EAAA1iB,EAAA,GACArL,EAAA2J,KACAwkB,EAAAT,GAAA,GACAS,EAAAT,GAAA,MACA,OAEG,IAAAM,IACHN,GAAAK,EAAA1iB,EAAA,OAAA0iB,EAAA1iB,EAAA,GACArL,EAAA2J,KACAwkB,EAAAT,GAAA,IACAS,EAAAT,GAAA,MACAS,EAAAT,GAAA,MACA,MAIA,OAAA1tB,EAAAI,KAAA,KA1IA,IALA,IAAA+tB,KACAL,KACAH,EAAA,oBAAAzU,sBAAAhY,MAEA8R,EAAA,mEACAxW,EAAA,EAAA6O,EAAA2H,EAAAnU,OAAkCrC,EAAA6O,IAAS7O,EAC3C2xB,EAAA3xB,GAAAwW,EAAAxW,GACAsxB,EAAA9a,EAAAzR,WAAA/E,MAQA,SAAA+wB,EAAAF,GACA,IAAAhiB,EAAAgiB,EAAAxuB,OAEA,GAAAwM,EAAA,IACA,UAAAvM,MAAA,kDAKA,IAAA0uB,EAAAH,EAAAvsB,QAAA,KAOA,OANA,IAAA0sB,MAAAniB,IAMAmiB,EAJAA,IAAAniB,EACA,EACA,EAAAmiB,EAAA,GA8DA,SAAAY,EAAAC,GACA,OAAAF,EAAAE,GAAA,OACAF,EAAAE,GAAA,OACAF,EAAAE,GAAA,MACAF,EAAA,GAAAE,GAGA,SAAAH,EAAAH,EAAAplB,EAAA2B,GAGA,IAFA,IAAAojB,EACAY,KACA9xB,EAAAmM,EAAqBnM,EAAA8N,EAAS9N,GAAA,EAC9BkxB,GACAK,EAAAvxB,IAAA,cACAuxB,EAAAvxB,EAAA,cACA,IAAAuxB,EAAAvxB,EAAA,IACA8xB,EAAA3kB,KAAAykB,EAAAV,IAEA,OAAAY,EAAAluB,KAAA,IAhGA0tB,EAAA,IAAAvsB,WAAA,OACAusB,EAAA,IAAAvsB,WAAA,sBCnBAvF,EAAAuf,KAAA,SAAAnB,EAAAwB,EAAA2S,EAAAC,EAAAC,GACA,IAAA/iB,EAAA9O,EACA8xB,EAAA,EAAAD,EAAAD,EAAA,EACAG,GAAA,GAAAD,GAAA,EACAE,EAAAD,GAAA,EACAE,GAAA,EACAryB,EAAA+xB,EAAAE,EAAA,IACA3xB,EAAAyxB,GAAA,IACAhwB,EAAA6b,EAAAwB,EAAApf,GAOA,IALAA,GAAAM,EAEA4O,EAAAnN,GAAA,IAAAswB,GAAA,EACAtwB,KAAAswB,EACAA,GAAAH,EACQG,EAAA,EAAWnjB,EAAA,IAAAA,EAAA0O,EAAAwB,EAAApf,MAAAM,EAAA+xB,GAAA,GAKnB,IAHAjyB,EAAA8O,GAAA,IAAAmjB,GAAA,EACAnjB,KAAAmjB,EACAA,GAAAL,EACQK,EAAA,EAAWjyB,EAAA,IAAAA,EAAAwd,EAAAwB,EAAApf,MAAAM,EAAA+xB,GAAA,GAEnB,OAAAnjB,EACAA,EAAA,EAAAkjB,MACG,IAAAljB,IAAAijB,EACH,OAAA/xB,EAAAkyB,IAAAzL,KAAA9kB,GAAA,KAEA3B,GAAA6N,KAAA0W,IAAA,EAAAqN,GACA9iB,GAAAkjB,EAEA,OAAArwB,GAAA,KAAA3B,EAAA6N,KAAA0W,IAAA,EAAAzV,EAAA8iB,IAGAxyB,EAAA+d,MAAA,SAAAK,EAAA3c,EAAAme,EAAA2S,EAAAC,EAAAC,GACA,IAAA/iB,EAAA9O,EAAAC,EACA6xB,EAAA,EAAAD,EAAAD,EAAA,EACAG,GAAA,GAAAD,GAAA,EACAE,EAAAD,GAAA,EACAI,EAAA,KAAAP,EAAA/jB,KAAA0W,IAAA,OAAA1W,KAAA0W,IAAA,SACA3kB,EAAA+xB,EAAA,EAAAE,EAAA,EACA3xB,EAAAyxB,EAAA,KACAhwB,EAAAd,EAAA,OAAAA,GAAA,EAAAA,EAAA,MAmCA,IAjCAA,EAAAgN,KAAAukB,IAAAvxB,GAEAyd,MAAAzd,QAAA4lB,KACAzmB,EAAAse,MAAAzd,GAAA,IACAiO,EAAAijB,IAEAjjB,EAAAjB,KAAAwX,MAAAxX,KAAAwf,IAAAxsB,GAAAgN,KAAAwkB,KACAxxB,GAAAZ,EAAA4N,KAAA0W,IAAA,GAAAzV,IAAA,IACAA,IACA7O,GAAA,IAGAY,GADAiO,EAAAkjB,GAAA,EACAG,EAAAlyB,EAEAkyB,EAAAtkB,KAAA0W,IAAA,IAAAyN,IAEA/xB,GAAA,IACA6O,IACA7O,GAAA,GAGA6O,EAAAkjB,GAAAD,GACA/xB,EAAA,EACA8O,EAAAijB,GACKjjB,EAAAkjB,GAAA,GACLhyB,GAAAa,EAAAZ,EAAA,GAAA4N,KAAA0W,IAAA,EAAAqN,GACA9iB,GAAAkjB,IAEAhyB,EAAAa,EAAAgN,KAAA0W,IAAA,EAAAyN,EAAA,GAAAnkB,KAAA0W,IAAA,EAAAqN,GACA9iB,EAAA,IAIQ8iB,GAAA,EAAWpU,EAAAwB,EAAApf,GAAA,IAAAI,EAAAJ,GAAAM,EAAAF,GAAA,IAAA4xB,GAAA,GAInB,IAFA9iB,KAAA8iB,EAAA5xB,EACA8xB,GAAAF,EACQE,EAAA,EAAUtU,EAAAwB,EAAApf,GAAA,IAAAkP,EAAAlP,GAAAM,EAAA4O,GAAA,IAAAgjB,GAAA,GAElBtU,EAAAwB,EAAApf,EAAAM,IAAA,IAAAyB,kBClFA,IAAA8H,KAAiBA,SAEjBpK,EAAAD,QAAAkF,MAAAsG,SAAA,SAAA6C,GACA,wBAAAhE,EAAA1J,KAAA0N,mBCIA,IAAA6kB,EAAA,mEAAAjvB,MAAA,IAKAjE,EAAAmrB,OAAA,SAAAtU,GACA,MAAAA,KAAAqc,EAAArwB,OACA,OAAAqwB,EAAArc,GAEA,UAAAnP,UAAA,6BAAAmP,IAOA7W,EAAA+rB,OAAA,SAAAoH,GAiBA,OAhBA,IAgBAA,MAfA,GAgBAA,EAjBA,GAGA,IAkBAA,MAjBA,IAkBAA,EAnBA,GASA,GANA,IAoBAA,MAnBA,GAoBAA,EArBA,GAOA,GAJA,IAsBAA,EACA,GAtBA,IA0BAA,EACA,IAIA,oBC1DA,IAAAnL,EAAW1nB,EAAQ,GAqBnB,SAAA4nB,IACAtgB,KAAA6kB,UACA7kB,KAAAwrB,SAAA,EAEAxrB,KAAAyrB,OAAgB9sB,eAAA,EAAAD,gBAAA,GAShB4hB,EAAA9lB,UAAA+nB,gBACA,SAAAmJ,EAAAC,GACA3rB,KAAA6kB,OAAApD,QAAAiK,EAAAC,IAQArL,EAAA9lB,UAAA2J,IAAA,SAAAynB,IAtCA,SAAAztB,EAAAC,GAEA,IAAAytB,EAAA1tB,EAAAQ,cACAmtB,EAAA1tB,EAAAO,cACAotB,EAAA5tB,EAAAO,gBACAstB,EAAA5tB,EAAAM,gBACA,OAAAotB,EAAAD,GAAAC,GAAAD,GAAAG,GAAAD,GACA3L,EAAAthB,oCAAAX,EAAAC,IAAA,EAgCA6tB,CAAAjsB,KAAAyrB,MAAAG,IAIA5rB,KAAAwrB,SAAA,EACAxrB,KAAA6kB,OAAA9e,KAAA6lB,KAJA5rB,KAAAyrB,MAAAG,EACA5rB,KAAA6kB,OAAA9e,KAAA6lB,KAgBAtL,EAAA9lB,UAAA8oB,QAAA,WAKA,OAJAtjB,KAAAwrB,UACAxrB,KAAA6kB,OAAAqH,KAAA9L,EAAAthB,qCACAkB,KAAAwrB,SAAA,GAEAxrB,KAAA6kB,QAGAzsB,EAAAkoB,+BCvEA,IAAAF,EAAW1nB,EAAQ,GACnByzB,EAAmBzzB,EAAQ,IAC3B2nB,EAAe3nB,EAAQ,IAAa2nB,SACpCF,EAAgBznB,EAAQ,IACxB0zB,EAAgB1zB,EAAQ,IAAc0zB,UAEtC,SAAAnM,EAAAoM,EAAAC,GACA,IAAAC,EAAAF,EAKA,MAJA,iBAAAA,IACAE,EAAAnM,EAAArhB,oBAAAstB,IAGA,MAAAE,EAAAC,SACA,IAAAC,EAAAF,EAAAD,GACA,IAAAI,EAAAH,EAAAD,GA0QA,SAAAI,EAAAL,EAAAC,GACA,IAAAC,EAAAF,EACA,iBAAAA,IACAE,EAAAnM,EAAArhB,oBAAAstB,IAGA,IAAAja,EAAAgO,EAAAxlB,OAAA2xB,EAAA,WACA/K,EAAApB,EAAAxlB,OAAA2xB,EAAA,WAGA5I,EAAAvD,EAAAxlB,OAAA2xB,EAAA,YACAntB,EAAAghB,EAAAxlB,OAAA2xB,EAAA,mBACA3I,EAAAxD,EAAAxlB,OAAA2xB,EAAA,uBACAlJ,EAAAjD,EAAAxlB,OAAA2xB,EAAA,YACAte,EAAAmS,EAAAxlB,OAAA2xB,EAAA,aAIA,GAAAna,GAAApS,KAAA8gB,SACA,UAAA5lB,MAAA,wBAAAkX,GAGAhT,IACAA,EAAAghB,EAAApkB,UAAAoD,IAGAoiB,IACAxe,IAAAsK,QAIAtK,IAAAod,EAAApkB,WAKAgH,IAAA,SAAAzE,GACA,OAAAa,GAAAghB,EAAAjkB,WAAAiD,IAAAghB,EAAAjkB,WAAAoC,GACA6hB,EAAApjB,SAAAoC,EAAAb,GACAA,IAOAyB,KAAA2gB,OAAAN,EAAA0E,UAAApB,EAAA3gB,IAAAsK,SAAA,GACAtN,KAAA0gB,SAAAL,EAAA0E,UAAAvD,GAAA,GAEAxhB,KAAA2sB,iBAAA3sB,KAAA0gB,SAAA4C,UAAAtgB,IAAA,SAAArI,GACA,OAAAylB,EAAAjhB,iBAAAC,EAAAzE,EAAA2xB,KAGAtsB,KAAAZ,aACAY,KAAA4jB,iBACA5jB,KAAA4gB,UAAAyC,EACArjB,KAAA4sB,cAAAN,EACAtsB,KAAAiO,OA4GA,SAAA4e,IACA7sB,KAAArB,cAAA,EACAqB,KAAAtB,gBAAA,EACAsB,KAAAzB,OAAA,KACAyB,KAAAxB,aAAA,KACAwB,KAAAvB,eAAA,KACAuB,KAAA7G,KAAA,KAkaA,SAAAszB,EAAAJ,EAAAC,GACA,IAAAC,EAAAF,EACA,iBAAAA,IACAE,EAAAnM,EAAArhB,oBAAAstB,IAGA,IAAAja,EAAAgO,EAAAxlB,OAAA2xB,EAAA,WACAC,EAAApM,EAAAxlB,OAAA2xB,EAAA,YAEA,GAAAna,GAAApS,KAAA8gB,SACA,UAAA5lB,MAAA,wBAAAkX,GAGApS,KAAA0gB,SAAA,IAAAL,EACArgB,KAAA2gB,OAAA,IAAAN,EAEA,IAAAyM,GACA/qB,MAAA,EACAC,OAAA,GAEAhC,KAAA+sB,UAAAP,EAAAxpB,IAAA,SAAArI,GACA,GAAAA,EAAAoB,IAGA,UAAAb,MAAA,sDAEA,IAAA8c,EAAAoI,EAAAxlB,OAAAD,EAAA,UACAqyB,EAAA5M,EAAAxlB,OAAAod,EAAA,QACAiV,EAAA7M,EAAAxlB,OAAAod,EAAA,UAEA,GAAAgV,EAAAF,EAAA/qB,MACAirB,IAAAF,EAAA/qB,MAAAkrB,EAAAH,EAAA9qB,OACA,UAAA9G,MAAA,wDAIA,OAFA4xB,EAAA9U,GAGAkV,iBAGAvuB,cAAAquB,EAAA,EACAtuB,gBAAAuuB,EAAA,GAEAxE,SAAA,IAAAxI,EAAAG,EAAAxlB,OAAAD,EAAA,OAAA2xB,MA/3BArM,EAAAc,cAAA,SAAAsL,EAAAC,GACA,OAAAI,EAAA3L,cAAAsL,EAAAC,IAMArM,EAAAzlB,UAAAsmB,SAAA,EAgCAb,EAAAzlB,UAAA2yB,oBAAA,KACA7zB,OAAAC,eAAA0mB,EAAAzlB,UAAA,sBACAkG,cAAA,EACAlH,YAAA,EACAC,IAAA,WAKA,OAJAuG,KAAAmtB,qBACAntB,KAAAotB,eAAAptB,KAAA4gB,UAAA5gB,KAAAZ,YAGAY,KAAAmtB,uBAIAlN,EAAAzlB,UAAA6yB,mBAAA,KACA/zB,OAAAC,eAAA0mB,EAAAzlB,UAAA,qBACAkG,cAAA,EACAlH,YAAA,EACAC,IAAA,WAKA,OAJAuG,KAAAqtB,oBACArtB,KAAAotB,eAAAptB,KAAA4gB,UAAA5gB,KAAAZ,YAGAY,KAAAqtB,sBAIApN,EAAAzlB,UAAA8yB,wBACA,SAAAtvB,EAAAb,GACA,IAAAlE,EAAA+E,EAAAnB,OAAAM,GACA,YAAAlE,GAAmB,MAAAA,GAQnBgnB,EAAAzlB,UAAA4yB,eACA,SAAApvB,EAAA0lB,GACA,UAAAxoB,MAAA,6CAGA+kB,EAAAsN,gBAAA,EACAtN,EAAAuN,eAAA,EAEAvN,EAAAwN,qBAAA,EACAxN,EAAAyN,kBAAA,EAkBAzN,EAAAzlB,UAAA0mB,YACA,SAAAwK,EAAAiC,EAAAC,GACA,IAGAvK,EAHAwK,EAAAF,GAAA,KAIA,OAHAC,GAAA3N,EAAAsN,iBAIA,KAAAtN,EAAAsN,gBACAlK,EAAArjB,KAAA8tB,mBACA,MACA,KAAA7N,EAAAuN,eACAnK,EAAArjB,KAAA+tB,kBACA,MACA,QACA,UAAA7yB,MAAA,+BAGA,IAAAkE,EAAAY,KAAAZ,WACAikB,EAAArgB,IAAA,SAAAme,GACA,IAAA5iB,EAAA,OAAA4iB,EAAA5iB,OAAA,KAAAyB,KAAA0gB,SAAA4E,GAAAnE,EAAA5iB,QAEA,OACAA,OAFAA,EAAA6hB,EAAAjhB,iBAAAC,EAAAb,EAAAyB,KAAA4sB,eAGAjuB,cAAAwiB,EAAAxiB,cACAD,gBAAAyiB,EAAAziB,gBACAF,aAAA2iB,EAAA3iB,aACAC,eAAA0iB,EAAA1iB,eACAtF,KAAA,OAAAgoB,EAAAhoB,KAAA,KAAA6G,KAAA2gB,OAAA2E,GAAAnE,EAAAhoB,QAEK6G,MAAAyhB,QAAAiK,EAAAmC,IAyBL5N,EAAAzlB,UAAAwzB,yBACA,SAAAnzB,GACA,IAAAkH,EAAAqe,EAAAxlB,OAAAC,EAAA,QAMAozB,GACA1vB,OAAA6hB,EAAAxlB,OAAAC,EAAA,UACA2D,aAAAuD,EACAtD,eAAA2hB,EAAAxlB,OAAAC,EAAA,aAIA,GADAozB,EAAA1vB,OAAAyB,KAAAkuB,iBAAAD,EAAA1vB,QACA0vB,EAAA1vB,OAAA,EACA,SAGA,IAAA8kB,KAEAlmB,EAAA6C,KAAAmuB,aAAAF,EACAjuB,KAAA+tB,kBACA,eACA,iBACA3N,EAAAliB,2BACAiuB,EAAAuB,mBACA,GAAAvwB,GAAA,GACA,IAAAgkB,EAAAnhB,KAAA+tB,kBAAA5wB,GAEA,QAAAoE,IAAA1G,EAAAmH,OAOA,IANA,IAAAxD,EAAA2iB,EAAA3iB,aAMA2iB,KAAA3iB,kBACA6kB,EAAAtd,MACAhE,KAAAqe,EAAAxlB,OAAAumB,EAAA,sBACAnf,OAAAoe,EAAAxlB,OAAAumB,EAAA,wBACAiN,WAAAhO,EAAAxlB,OAAAumB,EAAA,8BAGAA,EAAAnhB,KAAA+tB,oBAAA5wB,QASA,IANA,IAAAsB,EAAA0iB,EAAA1iB,eAMA0iB,GACAA,EAAA3iB,eAAAuD,GACAof,EAAA1iB,mBACA4kB,EAAAtd,MACAhE,KAAAqe,EAAAxlB,OAAAumB,EAAA,sBACAnf,OAAAoe,EAAAxlB,OAAAumB,EAAA,wBACAiN,WAAAhO,EAAAxlB,OAAAumB,EAAA,8BAGAA,EAAAnhB,KAAA+tB,oBAAA5wB,GAKA,OAAAkmB,GAGAjrB,EAAA6nB,oBAgGAyM,EAAAlyB,UAAAlB,OAAAY,OAAA+lB,EAAAzlB,WACAkyB,EAAAlyB,UAAAiuB,SAAAxI,EAMAyM,EAAAlyB,UAAA0zB,iBAAA,SAAAvL,GACA,IAWA/pB,EAXAy1B,EAAA1L,EAKA,GAJA,MAAA3iB,KAAAZ,aACAivB,EAAAjO,EAAApjB,SAAAgD,KAAAZ,WAAAivB,IAGAruB,KAAA0gB,SAAAkB,IAAAyM,GACA,OAAAruB,KAAA0gB,SAAAxjB,QAAAmxB,GAMA,IAAAz1B,EAAA,EAAaA,EAAAoH,KAAA2sB,iBAAA1xB,SAAkCrC,EAC/C,GAAAoH,KAAA2sB,iBAAA/zB,IAAA+pB,EACA,OAAA/pB,EAIA,UAYA8zB,EAAA3L,cACA,SAAAsL,EAAAC,GACA,IAAAgC,EAAAh1B,OAAAY,OAAAwyB,EAAAlyB,WAEAmpB,EAAA2K,EAAA3N,OAAAN,EAAA0E,UAAAsH,EAAA1L,OAAA2C,WAAA,GACA9B,EAAA8M,EAAA5N,SAAAL,EAAA0E,UAAAsH,EAAA3L,SAAA4C,WAAA,GACAgL,EAAAlvB,WAAAitB,EAAA7L,YACA8N,EAAA1K,eAAAyI,EAAA7I,wBAAA8K,EAAA5N,SAAA4C,UACAgL,EAAAlvB,YACAkvB,EAAArgB,KAAAoe,EAAA9L,MACA+N,EAAA1B,cAAAN,EACAgC,EAAA3B,iBAAA2B,EAAA5N,SAAA4C,UAAAtgB,IAAA,SAAArI,GACA,OAAAylB,EAAAjhB,iBAAAmvB,EAAAlvB,WAAAzE,EAAA2xB,KAYA,IAJA,IAAAiC,EAAAlC,EAAAzL,UAAA0C,UAAAjmB,QACAmxB,EAAAF,EAAAnB,uBACAsB,EAAAH,EAAAjB,sBAEAz0B,EAAA,EAAAqC,EAAAszB,EAAAtzB,OAAsDrC,EAAAqC,EAAYrC,IAAA,CAClE,IAAA81B,EAAAH,EAAA31B,GACA+1B,EAAA,IAAA9B,EACA8B,EAAAhwB,cAAA+vB,EAAA/vB,cACAgwB,EAAAjwB,gBAAAgwB,EAAAhwB,gBAEAgwB,EAAAnwB,SACAowB,EAAApwB,OAAAijB,EAAAtkB,QAAAwxB,EAAAnwB,QACAowB,EAAAnwB,aAAAkwB,EAAAlwB,aACAmwB,EAAAlwB,eAAAiwB,EAAAjwB,eAEAiwB,EAAAv1B,OACAw1B,EAAAx1B,KAAAwqB,EAAAzmB,QAAAwxB,EAAAv1B,OAGAs1B,EAAA1oB,KAAA4oB,IAGAH,EAAAzoB,KAAA4oB,GAKA,OAFAvC,EAAAkC,EAAAjB,mBAAAjN,EAAAliB,4BAEAowB,GAMA5B,EAAAlyB,UAAAsmB,SAAA,EAKAxnB,OAAAC,eAAAmzB,EAAAlyB,UAAA,WACAf,IAAA,WACA,OAAAuG,KAAA2sB,iBAAAtvB,WAqBAqvB,EAAAlyB,UAAA4yB,eACA,SAAApvB,EAAA0lB,GAeA,IAdA,IAYAvC,EAAAniB,EAAA4vB,EAAAloB,EAAA7M,EAZA8E,EAAA,EACAokB,EAAA,EACAG,EAAA,EACAD,EAAA,EACAG,EAAA,EACAD,EAAA,EACAloB,EAAA+C,EAAA/C,OACAkC,EAAA,EACA0xB,KACAC,KACAC,KACAR,KAGApxB,EAAAlC,GACA,SAAA+C,EAAAnB,OAAAM,GACAwB,IACAxB,IACA4lB,EAAA,OAEA,SAAA/kB,EAAAnB,OAAAM,GACAA,QAEA,CASA,KARAgkB,EAAA,IAAA0L,GACAluB,gBAOA+H,EAAAvJ,EAAyBuJ,EAAAzL,IACzB+E,KAAAstB,wBAAAtvB,EAAA0I,GADuCA,KAQvC,GADAkoB,EAAAC,EAFA7vB,EAAAhB,EAAAX,MAAAF,EAAAuJ,IAIAvJ,GAAA6B,EAAA/D,WACS,CAET,IADA2zB,KACAzxB,EAAAuJ,GACAyZ,EAAAgE,OAAAnmB,EAAAb,EAAA2xB,GACAj1B,EAAAi1B,EAAAj1B,MACAsD,EAAA2xB,EAAApK,KACAkK,EAAA7oB,KAAAlM,GAGA,OAAA+0B,EAAA3zB,OACA,UAAAC,MAAA,0CAGA,OAAA0zB,EAAA3zB,OACA,UAAAC,MAAA,0CAGA2zB,EAAA7vB,GAAA4vB,EAIAzN,EAAAziB,gBAAAqkB,EAAA6L,EAAA,GACA7L,EAAA5B,EAAAziB,gBAEAkwB,EAAA3zB,OAAA,IAEAkmB,EAAA5iB,OAAA6kB,EAAAwL,EAAA,GACAxL,GAAAwL,EAAA,GAGAzN,EAAA3iB,aAAA0kB,EAAA0L,EAAA,GACA1L,EAAA/B,EAAA3iB,aAEA2iB,EAAA3iB,cAAA,EAGA2iB,EAAA1iB,eAAAwkB,EAAA2L,EAAA,GACA3L,EAAA9B,EAAA1iB,eAEAmwB,EAAA3zB,OAAA,IAEAkmB,EAAAhoB,KAAAgqB,EAAAyL,EAAA,GACAzL,GAAAyL,EAAA,KAIAL,EAAAxoB,KAAAob,GACA,iBAAAA,EAAA3iB,cACAuwB,EAAAhpB,KAAAob,GAKAiL,EAAAmC,EAAAnO,EAAAxhB,qCACAoB,KAAAmtB,oBAAAoB,EAEAnC,EAAA2C,EAAA3O,EAAAliB,4BACA8B,KAAAqtB,mBAAA0B,GAOArC,EAAAlyB,UAAA2zB,aACA,SAAAa,EAAAC,EAAAC,EACAC,EAAAC,EAAAC,GAMA,GAAAL,EAAAE,IAAA,EACA,UAAApvB,UAAA,gDACAkvB,EAAAE,IAEA,GAAAF,EAAAG,GAAA,EACA,UAAArvB,UAAA,kDACAkvB,EAAAG,IAGA,OAAAhD,EAAAmD,OAAAN,EAAAC,EAAAG,EAAAC,IAOA3C,EAAAlyB,UAAA+0B,mBACA,WACA,QAAApyB,EAAA,EAAuBA,EAAA6C,KAAA8tB,mBAAA7yB,SAAwCkC,EAAA,CAC/D,IAAAgkB,EAAAnhB,KAAA8tB,mBAAA3wB,GAMA,GAAAA,EAAA,EAAA6C,KAAA8tB,mBAAA7yB,OAAA,CACA,IAAAu0B,EAAAxvB,KAAA8tB,mBAAA3wB,EAAA,GAEA,GAAAgkB,EAAAxiB,gBAAA6wB,EAAA7wB,cAAA,CACAwiB,EAAAsO,oBAAAD,EAAA9wB,gBAAA,EACA,UAKAyiB,EAAAsO,oBAAAhQ,MA4BAiN,EAAAlyB,UAAAgoB,oBACA,SAAA3nB,GACA,IAAAozB,GACAtvB,cAAAyhB,EAAAxlB,OAAAC,EAAA,QACA6D,gBAAA0hB,EAAAxlB,OAAAC,EAAA,WAGAsC,EAAA6C,KAAAmuB,aACAF,EACAjuB,KAAA8tB,mBACA,gBACA,kBACA1N,EAAAxhB,oCACAwhB,EAAAxlB,OAAAC,EAAA,OAAAolB,EAAAwN,uBAGA,GAAAtwB,GAAA,GACA,IAAAgkB,EAAAnhB,KAAA8tB,mBAAA3wB,GAEA,GAAAgkB,EAAAxiB,gBAAAsvB,EAAAtvB,cAAA,CACA,IAAAJ,EAAA6hB,EAAAxlB,OAAAumB,EAAA,eACA,OAAA5iB,IACAA,EAAAyB,KAAA0gB,SAAA4E,GAAA/mB,GACAA,EAAA6hB,EAAAjhB,iBAAAa,KAAAZ,WAAAb,EAAAyB,KAAA4sB,gBAEA,IAAAzzB,EAAAinB,EAAAxlB,OAAAumB,EAAA,aAIA,OAHA,OAAAhoB,IACAA,EAAA6G,KAAA2gB,OAAA2E,GAAAnsB,KAGAoF,SACAwD,KAAAqe,EAAAxlB,OAAAumB,EAAA,qBACAnf,OAAAoe,EAAAxlB,OAAAumB,EAAA,uBACAhoB,SAKA,OACAoF,OAAA,KACAwD,KAAA,KACAC,OAAA,KACA7I,KAAA,OAQAuzB,EAAAlyB,UAAAk1B,wBACA,WACA,QAAA1vB,KAAA4jB,iBAGA5jB,KAAA4jB,eAAA3oB,QAAA+E,KAAA0gB,SAAA7J,SACA7W,KAAA4jB,eAAAnX,KAAA,SAAAkjB,GAA+C,aAAAA,MAQ/CjD,EAAAlyB,UAAAqnB,iBACA,SAAAc,EAAAiN,GACA,IAAA5vB,KAAA4jB,eACA,YAGA,IAAAzmB,EAAA6C,KAAAkuB,iBAAAvL,GACA,GAAAxlB,GAAA,EACA,OAAA6C,KAAA4jB,eAAAzmB,GAGA,IAKApB,EALAsyB,EAAA1L,EAMA,GALA,MAAA3iB,KAAAZ,aACAivB,EAAAjO,EAAApjB,SAAAgD,KAAAZ,WAAAivB,IAIA,MAAAruB,KAAAZ,aACArD,EAAAqkB,EAAA/kB,SAAA2E,KAAAZ,aAAA,CAKA,IAAAywB,EAAAxB,EAAAvxB,QAAA,iBACA,WAAAf,EAAAP,QACAwE,KAAA0gB,SAAAkB,IAAAiO,GACA,OAAA7vB,KAAA4jB,eAAA5jB,KAAA0gB,SAAAxjB,QAAA2yB,IAGA,KAAA9zB,EAAAH,MAAA,KAAAG,EAAAH,OACAoE,KAAA0gB,SAAAkB,IAAA,IAAAyM,GACA,OAAAruB,KAAA4jB,eAAA5jB,KAAA0gB,SAAAxjB,QAAA,IAAAmxB,IAQA,GAAAuB,EACA,YAGA,UAAA10B,MAAA,IAAAmzB,EAAA,+BA2BA3B,EAAAlyB,UAAAs1B,qBACA,SAAAj1B,GACA,IAAA0D,EAAA6hB,EAAAxlB,OAAAC,EAAA,UAEA,IADA0D,EAAAyB,KAAAkuB,iBAAA3vB,IACA,EACA,OACAwD,KAAA,KACAC,OAAA,KACAosB,WAAA,MAIA,IAAAH,GACA1vB,SACAC,aAAA4hB,EAAAxlB,OAAAC,EAAA,QACA4D,eAAA2hB,EAAAxlB,OAAAC,EAAA,WAGAsC,EAAA6C,KAAAmuB,aACAF,EACAjuB,KAAA+tB,kBACA,eACA,iBACA3N,EAAAliB,2BACAkiB,EAAAxlB,OAAAC,EAAA,OAAAolB,EAAAwN,uBAGA,GAAAtwB,GAAA,GACA,IAAAgkB,EAAAnhB,KAAA+tB,kBAAA5wB,GAEA,GAAAgkB,EAAA5iB,SAAA0vB,EAAA1vB,OACA,OACAwD,KAAAqe,EAAAxlB,OAAAumB,EAAA,sBACAnf,OAAAoe,EAAAxlB,OAAAumB,EAAA,wBACAiN,WAAAhO,EAAAxlB,OAAAumB,EAAA,6BAKA,OACApf,KAAA,KACAC,OAAA,KACAosB,WAAA,OAIAh2B,EAAAs0B,yBAmGAD,EAAAjyB,UAAAlB,OAAAY,OAAA+lB,EAAAzlB,WACAiyB,EAAAjyB,UAAAgG,YAAAyf,EAKAwM,EAAAjyB,UAAAsmB,SAAA,EAKAxnB,OAAAC,eAAAkzB,EAAAjyB,UAAA,WACAf,IAAA,WAEA,IADA,IAAA+nB,KACA5oB,EAAA,EAAmBA,EAAAoH,KAAA+sB,UAAA9xB,OAA2BrC,IAC9C,QAAAqK,EAAA,EAAqBA,EAAAjD,KAAA+sB,UAAAn0B,GAAA6vB,SAAAjH,QAAAvmB,OAA+CgI,IACpEue,EAAAzb,KAAA/F,KAAA+sB,UAAAn0B,GAAA6vB,SAAAjH,QAAAve,IAGA,OAAAue,KAuBAiL,EAAAjyB,UAAAgoB,oBACA,SAAA3nB,GACA,IAAAozB,GACAtvB,cAAAyhB,EAAAxlB,OAAAC,EAAA,QACA6D,gBAAA0hB,EAAAxlB,OAAAC,EAAA,WAKAk1B,EAAA5D,EAAAmD,OAAArB,EAAAjuB,KAAA+sB,UACA,SAAAkB,EAAA+B,GACA,IAAA1xB,EAAA2vB,EAAAtvB,cAAAqxB,EAAA9C,gBAAAvuB,cACA,OAAAL,GAIA2vB,EAAAvvB,gBACAsxB,EAAA9C,gBAAAxuB,kBAEAsxB,EAAAhwB,KAAA+sB,UAAAgD,GAEA,OAAAC,EASAA,EAAAvH,SAAAjG,qBACAzgB,KAAAksB,EAAAtvB,eACAqxB,EAAA9C,gBAAAvuB,cAAA,GACAqD,OAAAisB,EAAAvvB,iBACAsxB,EAAA9C,gBAAAvuB,gBAAAsvB,EAAAtvB,cACAqxB,EAAA9C,gBAAAxuB,gBAAA,EACA,GACAuxB,KAAAp1B,EAAAo1B,QAdA1xB,OAAA,KACAwD,KAAA,KACAC,OAAA,KACA7I,KAAA,OAmBAszB,EAAAjyB,UAAAk1B,wBACA,WACA,OAAA1vB,KAAA+sB,UAAAxgB,MAAA,SAAA5R,GACA,OAAAA,EAAA8tB,SAAAiH,6BASAjD,EAAAjyB,UAAAqnB,iBACA,SAAAc,EAAAiN,GACA,QAAAh3B,EAAA,EAAmBA,EAAAoH,KAAA+sB,UAAA9xB,OAA2BrC,IAAA,CAC9C,IAEA+b,EAFA3U,KAAA+sB,UAAAn0B,GAEA6vB,SAAA5G,iBAAAc,GAAA,GACA,GAAAhO,EACA,OAAAA,EAGA,GAAAib,EACA,YAGA,UAAA10B,MAAA,IAAAynB,EAAA,+BAsBA8J,EAAAjyB,UAAAs1B,qBACA,SAAAj1B,GACA,QAAAjC,EAAA,EAAmBA,EAAAoH,KAAA+sB,UAAA9xB,OAA2BrC,IAAA,CAC9C,IAAAo3B,EAAAhwB,KAAA+sB,UAAAn0B,GAIA,QAAAo3B,EAAAvH,SAAAyF,iBAAA9N,EAAAxlB,OAAAC,EAAA,YAGA,IAAAq1B,EAAAF,EAAAvH,SAAAqH,qBAAAj1B,GACA,GAAAq1B,EASA,OAPAnuB,KAAAmuB,EAAAnuB,MACAiuB,EAAA9C,gBAAAvuB,cAAA,GACAqD,OAAAkuB,EAAAluB,QACAguB,EAAA9C,gBAAAvuB,gBAAAuxB,EAAAnuB,KACAiuB,EAAA9C,gBAAAxuB,gBAAA,EACA,KAMA,OACAqD,KAAA,KACAC,OAAA,OASAyqB,EAAAjyB,UAAA4yB,eACA,SAAApvB,EAAA0lB,GACA1jB,KAAAmtB,uBACAntB,KAAAqtB,sBACA,QAAAz0B,EAAA,EAAmBA,EAAAoH,KAAA+sB,UAAA9xB,OAA2BrC,IAG9C,IAFA,IAAAo3B,EAAAhwB,KAAA+sB,UAAAn0B,GACAu3B,EAAAH,EAAAvH,SAAAqF,mBACA7qB,EAAA,EAAqBA,EAAAktB,EAAAl1B,OAA4BgI,IAAA,CACjD,IAAAke,EAAAgP,EAAAltB,GAEA1E,EAAAyxB,EAAAvH,SAAA/H,SAAA4E,GAAAnE,EAAA5iB,QACAA,EAAA6hB,EAAAjhB,iBAAA6wB,EAAAvH,SAAArpB,WAAAb,EAAAyB,KAAA4sB,eACA5sB,KAAA0gB,SAAAvc,IAAA5F,GACAA,EAAAyB,KAAA0gB,SAAAxjB,QAAAqB,GAEA,IAAApF,EAAA,KACAgoB,EAAAhoB,OACAA,EAAA62B,EAAAvH,SAAA9H,OAAA2E,GAAAnE,EAAAhoB,MACA6G,KAAA2gB,OAAAxc,IAAAhL,GACAA,EAAA6G,KAAA2gB,OAAAzjB,QAAA/D,IAOA,IAAAi3B,GACA7xB,SACAI,cAAAwiB,EAAAxiB,eACAqxB,EAAA9C,gBAAAvuB,cAAA,GACAD,gBAAAyiB,EAAAziB,iBACAsxB,EAAA9C,gBAAAvuB,gBAAAwiB,EAAAxiB,cACAqxB,EAAA9C,gBAAAxuB,gBAAA,EACA,GACAF,aAAA2iB,EAAA3iB,aACAC,eAAA0iB,EAAA1iB,eACAtF,QAGA6G,KAAAmtB,oBAAApnB,KAAAqqB,GACA,iBAAAA,EAAA5xB,cACAwB,KAAAqtB,mBAAAtnB,KAAAqqB,GAKAhE,EAAApsB,KAAAmtB,oBAAA/M,EAAAxhB,qCACAwtB,EAAApsB,KAAAqtB,mBAAAjN,EAAAliB,6BAGA9F,EAAAq0B,0CCjnCAr0B,EAAAq1B,qBAAA,EACAr1B,EAAAs1B,kBAAA,EAgFAt1B,EAAAk3B,OAAA,SAAAN,EAAAqB,EAAAC,EAAAjB,GACA,OAAAgB,EAAAp1B,OACA,SAGA,IAAAkC,EAtEA,SAAAozB,EAAAC,EAAAC,EAAAzB,EAAAqB,EAAAC,EAAAjB,GAUA,IAAAqB,EAAA7pB,KAAAwX,OAAAoS,EAAAD,GAAA,GAAAA,EACAlyB,EAAAgyB,EAAAtB,EAAAqB,EAAAK,IAAA,GACA,WAAApyB,EAEAoyB,EAEApyB,EAAA,EAEAmyB,EAAAC,EAAA,EAEAH,EAAAG,EAAAD,EAAAzB,EAAAqB,EAAAC,EAAAjB,GAKAA,GAAAj3B,EAAAs1B,kBACA+C,EAAAJ,EAAAp1B,OAAAw1B,GAAA,EAEAC,EAKAA,EAAAF,EAAA,EAEAD,EAAAC,EAAAE,EAAA1B,EAAAqB,EAAAC,EAAAjB,GAIAA,GAAAj3B,EAAAs1B,kBACAgD,EAEAF,EAAA,KAAAA,EA4BAD,EAAA,EAAAF,EAAAp1B,OAAA+zB,EAAAqB,EACAC,EAAAjB,GAAAj3B,EAAAq1B,sBACA,GAAAtwB,EAAA,EACA,SAMA,KAAAA,EAAA,MACA,IAAAmzB,EAAAD,EAAAlzB,GAAAkzB,EAAAlzB,EAAA,UAGAA,EAGA,OAAAA,kBClFA,SAAAga,EAAAwZ,EAAA9V,EAAAC,GACA,IAAAgU,EAAA6B,EAAA9V,GACA8V,EAAA9V,GAAA8V,EAAA7V,GACA6V,EAAA7V,GAAAgU,EA2BA,SAAA8B,EAAAD,EAAAE,EAAAn2B,EAAAhB,GAKA,GAAAgB,EAAAhB,EAAA,CAYA,IACAd,EAAA8B,EAAA,EAEAyc,EAAAwZ,EApCA,SAAAG,EAAAC,GACA,OAAAlqB,KAAAmqB,MAAAF,EAAAjqB,KAAAoqB,UAAAF,EAAAD,IAgCAI,CAAAx2B,EAAAhB,GAGAA,GASA,IARA,IAAAy3B,EAAAR,EAAAj3B,GAQAuJ,EAAAvI,EAAmBuI,EAAAvJ,EAAOuJ,IAC1B4tB,EAAAF,EAAA1tB,GAAAkuB,IAAA,GAEAha,EAAAwZ,EADA/3B,GAAA,EACAqK,GAIAkU,EAAAwZ,EAAA/3B,EAAA,EAAAqK,GACA,IAAAmuB,EAAAx4B,EAAA,EAIAg4B,EAAAD,EAAAE,EAAAn2B,EAAA02B,EAAA,GACAR,EAAAD,EAAAE,EAAAO,EAAA,EAAA13B,IAYAtB,EAAAg0B,UAAA,SAAAuE,EAAAE,GACAD,EAAAD,EAAAE,EAAA,EAAAF,EAAA11B,OAAA,qBCzGA,IAAA+kB,EAAyBtnB,EAAQ,IAAwBsnB,mBACzDI,EAAW1nB,EAAQ,GAInB24B,EAAA,UAQAC,EAAA,qBAcA,SAAApR,EAAAqR,EAAAC,EAAA7O,EAAA8O,EAAA32B,GACAkF,KAAAoI,YACApI,KAAA0xB,kBACA1xB,KAAA+B,KAAA,MAAAwvB,EAAA,KAAAA,EACAvxB,KAAAgC,OAAA,MAAAwvB,EAAA,KAAAA,EACAxxB,KAAAzB,OAAA,MAAAokB,EAAA,KAAAA,EACA3iB,KAAA7G,KAAA,MAAA2B,EAAA,KAAAA,EACAkF,KAAAsxB,IAAA,EACA,MAAAG,GAAAzxB,KAAAmE,IAAAstB,GAWAvR,EAAAyR,wBACA,SAAAC,EAAA5Q,EAAA6Q,GAGA,IAAAxvB,EAAA,IAAA6d,EAMA4R,EAAAF,EAAAv1B,MAAAg1B,GACAU,EAAA,EACAC,EAAA,WAIA,OAHAC,KAEAA,KAAA,IAGA,SAAAA,IACA,OAAAF,EAAAD,EAAA72B,OACA62B,EAAAC,UAAAxwB,IAKA2wB,EAAA,EAAAzC,EAAA,EAKA0C,EAAA,KAgEA,OA9DAnR,EAAAE,YAAA,SAAAC,GACA,UAAAgR,EAAA,CAGA,KAAAD,EAAA/Q,EAAAxiB,eAMS,CAIT,IACAyQ,GADAgjB,EAAAN,EAAAC,IAAA,IACAx0B,OAAA,EAAA4jB,EAAAziB,gBACA+wB,GAOA,OANAqC,EAAAC,GAAAK,EAAA70B,OAAA4jB,EAAAziB,gBACA+wB,GACAA,EAAAtO,EAAAziB,gBACA2zB,EAAAF,EAAA/iB,QAEA+iB,EAAAhR,GAhBAkR,EAAAF,EAAAH,KACAE,IACAzC,EAAA,EAqBA,KAAAyC,EAAA/Q,EAAAxiB,eACA0D,EAAA8B,IAAA6tB,KACAE,IAEA,GAAAzC,EAAAtO,EAAAziB,gBAAA,CACA,IAAA0zB,EAAAN,EAAAC,IAAA,GACA1vB,EAAA8B,IAAAiuB,EAAA70B,OAAA,EAAA4jB,EAAAziB,kBACAozB,EAAAC,GAAAK,EAAA70B,OAAA4jB,EAAAziB,iBACA+wB,EAAAtO,EAAAziB,gBAEAyzB,EAAAhR,GACKnhB,MAEL+xB,EAAAD,EAAA72B,SACAk3B,GAEAE,EAAAF,EAAAH,KAGA3vB,EAAA8B,IAAA2tB,EAAAv1B,OAAAw1B,GAAAv1B,KAAA,MAIAwkB,EAAAQ,QAAAC,QAAA,SAAAC,GACA,IAAA/M,EAAAqM,EAAAa,iBAAAH,GACA,MAAA/M,IACA,MAAAkd,IACAnQ,EAAAtB,EAAA5jB,KAAAq1B,EAAAnQ,IAEArf,EAAAyf,iBAAAJ,EAAA/M,MAIAtS,EAEA,SAAAgwB,EAAAlR,EAAA/R,GACA,UAAA+R,QAAA5f,IAAA4f,EAAA5iB,OACA8D,EAAA8B,IAAAiL,OACO,CACP,IAAA7Q,EAAAszB,EACAzR,EAAA5jB,KAAAq1B,EAAA1Q,EAAA5iB,QACA4iB,EAAA5iB,OACA8D,EAAA8B,IAAA,IAAA+b,EAAAiB,EAAA3iB,aACA2iB,EAAA1iB,eACAF,EACA6Q,EACA+R,EAAAhoB,UAWA+mB,EAAA1lB,UAAA2J,IAAA,SAAAmuB,GACA,GAAAh1B,MAAAsG,QAAA0uB,GACAA,EAAA7Q,QAAA,SAAA8Q,GACAvyB,KAAAmE,IAAAouB,IACKvyB,UAEL,KAAAsyB,EAAAhB,IAAA,iBAAAgB,EAMA,UAAAxyB,UACA,8EAAAwyB,GANAA,GACAtyB,KAAAoI,SAAArC,KAAAusB,GAQA,OAAAtyB,MASAkgB,EAAA1lB,UAAA8N,QAAA,SAAAgqB,GACA,GAAAh1B,MAAAsG,QAAA0uB,GACA,QAAA15B,EAAA05B,EAAAr3B,OAAA,EAAiCrC,GAAA,EAAQA,IACzCoH,KAAAsI,QAAAgqB,EAAA15B,QAGA,KAAA05B,EAAAhB,IAAA,iBAAAgB,EAIA,UAAAxyB,UACA,8EAAAwyB,GAJAtyB,KAAAoI,SAAA9C,QAAAgtB,GAOA,OAAAtyB,MAUAkgB,EAAA1lB,UAAAkP,KAAA,SAAA8oB,GAEA,IADA,IAAAD,EACA35B,EAAA,EAAA6O,EAAAzH,KAAAoI,SAAAnN,OAA6CrC,EAAA6O,EAAS7O,KACtD25B,EAAAvyB,KAAAoI,SAAAxP,IACA04B,GACAiB,EAAA7oB,KAAA8oB,GAGA,KAAAD,GACAC,EAAAD,GAAoBh0B,OAAAyB,KAAAzB,OACpBwD,KAAA/B,KAAA+B,KACAC,OAAAhC,KAAAgC,OACA7I,KAAA6G,KAAA7G,QAYA+mB,EAAA1lB,UAAAgC,KAAA,SAAAi2B,GACA,IAAAC,EACA95B,EACA6O,EAAAzH,KAAAoI,SAAAnN,OACA,GAAAwM,EAAA,GAEA,IADAirB,KACA95B,EAAA,EAAeA,EAAA6O,EAAA,EAAW7O,IAC1B85B,EAAA3sB,KAAA/F,KAAAoI,SAAAxP,IACA85B,EAAA3sB,KAAA0sB,GAEAC,EAAA3sB,KAAA/F,KAAAoI,SAAAxP,IACAoH,KAAAoI,SAAAsqB,EAEA,OAAA1yB,MAUAkgB,EAAA1lB,UAAAm4B,aAAA,SAAAC,EAAAC,GACA,IAAAC,EAAA9yB,KAAAoI,SAAApI,KAAAoI,SAAAnN,OAAA,GAUA,OATA63B,EAAAxB,GACAwB,EAAAH,aAAAC,EAAAC,GAEA,iBAAAC,EACA9yB,KAAAoI,SAAApI,KAAAoI,SAAAnN,OAAA,GAAA63B,EAAAh2B,QAAA81B,EAAAC,GAGA7yB,KAAAoI,SAAArC,KAAA,GAAAjJ,QAAA81B,EAAAC,IAEA7yB,MAUAkgB,EAAA1lB,UAAAsnB,iBACA,SAAAE,EAAAC,GACAjiB,KAAA0xB,eAAAtR,EAAAriB,YAAAikB,IAAAC,GASA/B,EAAA1lB,UAAAu4B,mBACA,SAAAP,GACA,QAAA55B,EAAA,EAAA6O,EAAAzH,KAAAoI,SAAAnN,OAA+CrC,EAAA6O,EAAS7O,IACxDoH,KAAAoI,SAAAxP,GAAA04B,IACAtxB,KAAAoI,SAAAxP,GAAAm6B,mBAAAP,GAIA,IAAAhR,EAAAloB,OAAA4oB,KAAAliB,KAAA0xB,gBACA,IAAA94B,EAAA,EAAA6O,EAAA+Z,EAAAvmB,OAAyCrC,EAAA6O,EAAS7O,IAClD45B,EAAApS,EAAAniB,cAAAujB,EAAA5oB,IAAAoH,KAAA0xB,eAAAlQ,EAAA5oB,MAQAsnB,EAAA1lB,UAAAiI,SAAA,WACA,IAAAzD,EAAA,GAIA,OAHAgB,KAAA0J,KAAA,SAAA6oB,GACAvzB,GAAAuzB,IAEAvzB,GAOAkhB,EAAA1lB,UAAAw4B,sBAAA,SAAAn4B,GACA,IAAAwmB,GACAjS,KAAA,GACArN,KAAA,EACAC,OAAA,GAEAgB,EAAA,IAAAgd,EAAAnlB,GACAo4B,GAAA,EACAC,EAAA,KACAC,EAAA,KACAC,EAAA,KACAC,EAAA,KAqEA,OApEArzB,KAAA0J,KAAA,SAAA6oB,EAAAjR,GACAD,EAAAjS,MAAAmjB,EACA,OAAAjR,EAAA/iB,QACA,OAAA+iB,EAAAvf,MACA,OAAAuf,EAAAtf,QACAkxB,IAAA5R,EAAA/iB,QACA40B,IAAA7R,EAAAvf,MACAqxB,IAAA9R,EAAAtf,QACAqxB,IAAA/R,EAAAnoB,MACA6J,EAAAue,YACAhjB,OAAA+iB,EAAA/iB,OACA+iB,UACAvf,KAAAuf,EAAAvf,KACAC,OAAAsf,EAAAtf,QAEAqf,WACAtf,KAAAsf,EAAAtf,KACAC,OAAAqf,EAAArf,QAEA7I,KAAAmoB,EAAAnoB,OAGA+5B,EAAA5R,EAAA/iB,OACA40B,EAAA7R,EAAAvf,KACAqxB,EAAA9R,EAAAtf,OACAqxB,EAAA/R,EAAAnoB,KACA85B,GAAA,GACKA,IACLjwB,EAAAue,YACAF,WACAtf,KAAAsf,EAAAtf,KACAC,OAAAqf,EAAArf,UAGAkxB,EAAA,KACAD,GAAA,GAEA,QAAA5N,EAAA,EAAApqB,EAAAs3B,EAAAt3B,OAA4CoqB,EAAApqB,EAAcoqB,IA3W1D,KA4WAkN,EAAA50B,WAAA0nB,IACAhE,EAAAtf,OACAsf,EAAArf,OAAA,EAEAqjB,EAAA,IAAApqB,GACAi4B,EAAA,KACAD,GAAA,GACSA,GACTjwB,EAAAue,YACAhjB,OAAA+iB,EAAA/iB,OACA+iB,UACAvf,KAAAuf,EAAAvf,KACAC,OAAAsf,EAAAtf,QAEAqf,WACAtf,KAAAsf,EAAAtf,KACAC,OAAAqf,EAAArf,QAEA7I,KAAAmoB,EAAAnoB,QAIAkoB,EAAArf,WAIAhC,KAAA+yB,mBAAA,SAAArR,EAAA4R,GACAtwB,EAAA8e,iBAAAJ,EAAA4R,MAGUlkB,KAAAiS,EAAAjS,KAAApM,QAGV5K,EAAA8nB,4BC3ZA,IAOAqT,EACAC,EARAtuB,EAAA7M,EAAAD,WAUA,SAAAq7B,IACA,UAAAv4B,MAAA,mCAEA,SAAAw4B,IACA,UAAAx4B,MAAA,qCAsBA,SAAAy4B,EAAAC,GACA,GAAAL,IAAAM,WAEA,OAAAA,WAAAD,EAAA,GAGA,IAAAL,IAAAE,IAAAF,IAAAM,WAEA,OADAN,EAAAM,WACAA,WAAAD,EAAA,GAEA,IAEA,OAAAL,EAAAK,EAAA,GACK,MAAA9rB,GACL,IAEA,OAAAyrB,EAAAx6B,KAAA,KAAA66B,EAAA,GACS,MAAA9rB,GAET,OAAAyrB,EAAAx6B,KAAAiH,KAAA4zB,EAAA,MAvCA,WACA,IAEAL,EADA,mBAAAM,WACAA,WAEAJ,EAEK,MAAA3rB,GACLyrB,EAAAE,EAEA,IAEAD,EADA,mBAAAM,aACAA,aAEAJ,EAEK,MAAA5rB,GACL0rB,EAAAE,GAjBA,GAwEA,IAEAK,EAFAC,KACAC,GAAA,EAEAC,GAAA,EAEA,SAAAC,IACAF,GAAAF,IAGAE,GAAA,EACAF,EAAA94B,OACA+4B,EAAAD,EAAA9sB,OAAA+sB,GAEAE,GAAA,EAEAF,EAAA/4B,QACAm5B,KAIA,SAAAA,IACA,IAAAH,EAAA,CAGA,IAAAI,EAAAV,EAAAQ,GACAF,GAAA,EAGA,IADA,IAAAxsB,EAAAusB,EAAA/4B,OACAwM,GAAA,CAGA,IAFAssB,EAAAC,EACAA,OACAE,EAAAzsB,GACAssB,GACAA,EAAAG,GAAA5f,MAGA4f,GAAA,EACAzsB,EAAAusB,EAAA/4B,OAEA84B,EAAA,KACAE,GAAA,EAnEA,SAAAK,GACA,GAAAd,IAAAM,aAEA,OAAAA,aAAAQ,GAGA,IAAAd,IAAAE,IAAAF,IAAAM,aAEA,OADAN,EAAAM,aACAA,aAAAQ,GAEA,IAEAd,EAAAc,GACK,MAAAxsB,GACL,IAEA,OAAA0rB,EAAAz6B,KAAA,KAAAu7B,GACS,MAAAxsB,GAGT,OAAA0rB,EAAAz6B,KAAAiH,KAAAs0B,KAgDAC,CAAAF,IAiBA,SAAAG,EAAAZ,EAAAje,GACA3V,KAAA4zB,MACA5zB,KAAA2V,QAYA,SAAA8e,KA5BAvvB,EAAAwvB,SAAA,SAAAd,GACA,IAAAe,EAAA,IAAAr3B,MAAAtC,UAAAC,OAAA,GACA,GAAAD,UAAAC,OAAA,EACA,QAAArC,EAAA,EAAuBA,EAAAoC,UAAAC,OAAsBrC,IAC7C+7B,EAAA/7B,EAAA,GAAAoC,UAAApC,GAGAo7B,EAAAjuB,KAAA,IAAAyuB,EAAAZ,EAAAe,IACA,IAAAX,EAAA/4B,QAAAg5B,GACAN,EAAAS,IASAI,EAAAh6B,UAAA8Z,IAAA,WACAtU,KAAA4zB,IAAAvrB,MAAA,KAAArI,KAAA2V,QAEAzQ,EAAA0vB,MAAA,UACA1vB,EAAA2vB,SAAA,EACA3vB,EAAA4vB,OACA5vB,EAAA6vB,QACA7vB,EAAAkN,QAAA,GACAlN,EAAA8vB,YAIA9vB,EAAA+vB,GAAAR,EACAvvB,EAAAgwB,YAAAT,EACAvvB,EAAAiwB,KAAAV,EACAvvB,EAAAkwB,IAAAX,EACAvvB,EAAAmwB,eAAAZ,EACAvvB,EAAAowB,mBAAAb,EACAvvB,EAAAqwB,KAAAd,EACAvvB,EAAAswB,gBAAAf,EACAvvB,EAAAuwB,oBAAAhB,EAEAvvB,EAAAwwB,UAAA,SAAAv8B,GAAqC,UAErC+L,EAAAywB,QAAA,SAAAx8B,GACA,UAAA+B,MAAA,qCAGAgK,EAAAiB,IAAA,WAA2B,WAC3BjB,EAAA0wB,MAAA,SAAAvuB,GACA,UAAAnM,MAAA,mCAEAgK,EAAA2wB,MAAA,WAA4B,wCCrL5Bz9B,EAAA4B,YAAA,EACA5B,EAAA2I,QAGA,SAAAW,GACA,GAAAo0B,EAAAp0B,GAAA,OACAo0B,EAAAp0B,IAAA,EAEA,oBAAAwS,iBAAAjS,MACAiS,QAAAjS,KAAAP,IAPA,IAAAo0B,KAUAz9B,EAAAD,UAAA,sCCZAA,EAAA4B,YAAA,EAEA,IAAA0O,EAAA,WAAgC,SAAAC,EAAAC,EAAAC,GAA2C,QAAAjQ,EAAA,EAAgBA,EAAAiQ,EAAA5N,OAAkBrC,IAAA,CAAO,IAAAkQ,EAAAD,EAAAjQ,GAA2BkQ,EAAAtP,WAAAsP,EAAAtP,aAAA,EAAwDsP,EAAApI,cAAA,EAAgC,UAAAoI,MAAArI,UAAA,GAAuDnH,OAAAC,eAAAqP,EAAAE,EAAA3O,IAAA2O,IAA+D,gBAAAjJ,EAAAkJ,EAAAC,GAA2L,OAAlID,GAAAJ,EAAA9I,EAAArF,UAAAuO,GAAqEC,GAAAL,EAAA9I,EAAAmJ,GAA6DnJ,GAAxhB,GAIAk2B,EAEA,SAAAj1B,GAAsC,OAAAA,KAAA9G,WAAA8G,GAAuCC,QAAAD,GAF7EE,CAFetI,EAAQ,KAsBvB,IAAAs9B,EAAA,WAOA,SAAAA,EAAA/iB,EAAA/a,EAAAyJ,IAvBA,SAAA/B,EAAAC,GAAiD,KAAAD,aAAAC,GAA0C,UAAAC,UAAA,qCAwB3FC,CAAAC,KAAAg2B,GAcAh2B,KAAAiT,YAmBAjT,KAAA4U,YASA5U,KAAA9H,OAUA8H,KAAA2B,OASA3B,KAAA4H,SAAArG,EAeAvB,KAAAgD,SAAAzB,EAuFA,OA1EAy0B,EAAAx7B,UAAAiI,SAAA,WACA,OAAAzC,KAAA4H,KAqBAouB,EAAAx7B,UAAAyH,KAAA,SAAAE,GACA,IAAAR,EAAA3G,UAAAC,OAAA,QAAAsG,IAAAvG,UAAA,GAAAA,UAAA,MAEA2G,EAAAuM,QACAlO,KAAAyU,YAAAzU,KAAAyU,WAAAT,gBACArS,EAAAuM,OAAAlO,KAAAyU,WAAAT,eAIA,IAAAiiB,EAAA,IAAAF,EAAAh1B,QAAAoB,EAAAR,GAGA,OAFA3B,KAAA4U,SAAA7O,KAAAkwB,GAEAA,GAgBAD,EAAAx7B,UAAA8Y,SAAA,WACA,OAAAtT,KAAA4U,SAAAjP,OAAA,SAAA/M,GACA,kBAAAA,EAAAyH,QAeAqI,EAAAstB,IACA77B,IAAA,UACAV,IAAA,WACA,OAAAuG,KAAA4H,QAIAouB,EA3KA,GA8KA59B,EAAA2I,QAAAi1B,EAQA39B,EAAAD,UAAA,sCChNAA,EAAA4B,YAAA,EAYA,IAAAk8B,EAAA,WAYA,SAAAA,EAAA/zB,GACA,IAAAR,EAAA3G,UAAAC,OAAA,QAAAsG,IAAAvG,UAAA,GAAAA,UAAA,MAwBA,GA/CA,SAAA4E,EAAAC,GAAiD,KAAAD,aAAAC,GAA0C,UAAAC,UAAA,qCAyB3FC,CAAAC,KAAAk2B,GAWAl2B,KAAAK,KAAA,UASAL,KAAAmC,OAEAR,EAAAU,MAAAV,EAAAU,KAAA9D,OAAA,CACA,IAAAqD,EAAAD,EAAAU,KAAAR,WAAAF,GAQA3B,KAAA+B,KAAAH,EAAAG,KASA/B,KAAAgC,OAAAJ,EAAAI,OAGA,QAAAm0B,KAAAx0B,EACA3B,KAAAm2B,GAAAx0B,EAAAw0B,GA+CA,OAjCAD,EAAA17B,UAAAiI,SAAA,WACA,OAAAzC,KAAAqC,KACArC,KAAAqC,KAAAZ,MAAAzB,KAAAmC,MACA+L,OAAAlO,KAAAkO,OACA/Q,MAAA6C,KAAA7C,MACA6H,KAAAhF,KAAAgF,OACOtD,QACF1B,KAAAkO,OACLlO,KAAAkO,OAAA,KAAAlO,KAAAmC,KAEAnC,KAAAmC,MAuBA+zB,EA1GA,GA6GA99B,EAAA2I,QAAAm1B,EACA79B,EAAAD,UAAA,sCC1HAA,EAAA4B,YAAA,EAEA,IAEAiP,EAAAjI,EAFmBtI,EAAQ,IAM3B09B,EAAAp1B,EAFgBtI,EAAQ,KAMxBwQ,EAAAlI,EAFetI,EAAQ,IAMvBquB,EAAA/lB,EAFctI,EAAQ,IAMtBwuB,EAAAlmB,EAFYtI,EAAQ,KAMpBuuB,EAAAjmB,EAFYtI,EAAQ,IAIpB,SAAAsI,EAAAF,GAAsC,OAAAA,KAAA9G,WAAA8G,GAAuCC,QAAAD,GAI7E,IAAAu1B,EAAA,WACA,SAAAA,EAAAv0B,IAHA,SAAAlC,EAAAC,GAAiD,KAAAD,aAAAC,GAA0C,UAAAC,UAAA,qCAI3FC,CAAAC,KAAAq2B,GAEAr2B,KAAA8B,QAEA9B,KAAA9H,KAAA,IAAAgvB,EAAAnmB,QACAf,KAAAylB,QAAAzlB,KAAA9H,KACA8H,KAAAs2B,OAAA,GACAt2B,KAAAiQ,WAAA,EAEAjQ,KAAAu2B,kBACAv2B,KAAA9H,KAAAqG,QAAwBuD,QAAAiD,OAAuBhD,KAAA,EAAAC,OAAA,IAmf/C,OAhfAq0B,EAAA77B,UAAA+7B,gBAAA,WACAv2B,KAAAw2B,WAAA,EAAAJ,EAAAr1B,SAAAf,KAAA8B,QAGAu0B,EAAA77B,UAAA0E,MAAA,WAEA,IADA,IAAAu3B,OAAA,GACAz2B,KAAAw2B,UAAAE,aAGA,QAFAD,EAAAz2B,KAAAw2B,UAAAG,aAEA,IACA,YACA32B,KAAAs2B,QAAAG,EAAA,GACA,MAEA,QACAz2B,KAAA42B,cAAAH,GACA,MAEA,QACAz2B,KAAA0G,IAAA+vB,GACA,MAEA,cACAz2B,KAAAmQ,QAAAsmB,GACA,MAEA,cACAz2B,KAAA2Q,OAAA8lB,GACA,MAEA,QACAz2B,KAAA62B,UAAAJ,GACA,MAEA,QACAz2B,KAAA82B,MAAAL,GAIAz2B,KAAA+2B,WAGAV,EAAA77B,UAAA2V,QAAA,SAAAsmB,GACA,IAAAp0B,EAAA,IAAA6G,EAAAnI,QACAf,KAAAg3B,KAAA30B,EAAAo0B,EAAA,GAAAA,EAAA,IACAp0B,EAAA9D,OAAAmI,KAAuB3E,KAAA00B,EAAA,GAAAz0B,OAAAy0B,EAAA,IAEvB,IAAAt0B,EAAAs0B,EAAA,GAAAp5B,MAAA,MACA,WAAAN,KAAAoF,GACAE,EAAAF,KAAA,GACAE,EAAAb,KAAA4O,KAAAjO,EACAE,EAAAb,KAAA6O,MAAA,OACK,CACL,IAAA9U,EAAA4G,EAAA5G,MAAA,2BACA8G,EAAAF,KAAA5G,EAAA,GACA8G,EAAAb,KAAA4O,KAAA7U,EAAA,GACA8G,EAAAb,KAAA6O,MAAA9U,EAAA,KAIA86B,EAAA77B,UAAAq8B,UAAA,SAAAJ,GACA,IAAAp0B,EAAA,IAAA4kB,EAAAlmB,QACAf,KAAAg3B,KAAA30B,EAAAo0B,EAAA,GAAAA,EAAA,IACAp0B,EAAA2H,SAAA,GACA3H,EAAAb,KAAAoD,QAAA,GACA5E,KAAAylB,QAAApjB,GAGAg0B,EAAA77B,UAAAs8B,MAAA,SAAA/xB,GASA,IARA,IAAA2B,GAAA,EACArG,EAAA,KACAiP,GAAA,EACA2nB,EAAA,KACAC,KAEAC,KACAV,EAAA1xB,EACA0xB,GAAA,CAIA,GAHAp2B,EAAAo2B,EAAA,GACAU,EAAApxB,KAAA0wB,GAEA,MAAAp2B,GAAA,MAAAA,EACA42B,MAAAR,GACAS,EAAAnxB,KAAA,MAAA1F,EAAA,cACO,OAAA62B,EAAAj8B,OAAA,CACP,SAAAoF,EAAuB,CACvB,GAAAiP,EAEA,YADAtP,KAAAqM,KAAA8qB,GAGA,MAES,SAAA92B,EAET,YADAL,KAAAwQ,KAAA2mB,GAES,SAAA92B,EAAqB,CAC9BL,KAAAw2B,UAAAY,KAAAD,EAAAE,OACA3wB,GAAA,EACA,MACS,MAAArG,IACTiP,GAAA,QAEOjP,IAAA62B,IAAAj8B,OAAA,KACPi8B,EAAAG,MACA,IAAAH,EAAAj8B,SAAAg8B,EAAA,OAGAR,EAAAz2B,KAAAw2B,UAAAG,YAMA,GAHA32B,KAAAw2B,UAAAE,cAAAhwB,GAAA,GACAwwB,EAAAj8B,OAAA,GAAA+E,KAAAs3B,gBAAAL,GAEAvwB,GAAA4I,EAAA,CACA,KAAA6nB,EAAAl8B,SAEA,WADAw7B,EAAAU,IAAAl8B,OAAA,QACA,YAAAw7B,IACAz2B,KAAAw2B,UAAAY,KAAAD,EAAAE,OAEAr3B,KAAAqM,KAAA8qB,QAEAn3B,KAAAu3B,YAAAJ,IAIAd,EAAA77B,UAAAgW,KAAA,SAAA2mB,GACAA,EAAAE,MAEA,IAAAh1B,EAAA,IAAA4kB,EAAAlmB,QACAf,KAAAg3B,KAAA30B,EAAA80B,EAAA,MAAAA,EAAA,OAEA90B,EAAAb,KAAAoD,QAAA5E,KAAAw3B,yBAAAL,GACAn3B,KAAAuE,IAAAlC,EAAA,WAAA80B,GACAn3B,KAAAylB,QAAApjB,GAGAg0B,EAAA77B,UAAA6R,KAAA,SAAA8qB,GACA,IAAA90B,EAAA,IAAA4G,EAAAlI,QACAf,KAAAg3B,KAAA30B,GAEA,IAAAgD,EAAA8xB,IAAAl8B,OAAA,GAWA,IAVA,MAAAoK,EAAA,KACArF,KAAAiQ,WAAA,EACAknB,EAAAE,OAEAhyB,EAAA,GACAhD,EAAA9D,OAAAmI,KAAyB3E,KAAAsD,EAAA,GAAArD,OAAAqD,EAAA,IAEzBhD,EAAA9D,OAAAmI,KAAyB3E,KAAAsD,EAAA,GAAArD,OAAAqD,EAAA,IAGzB,SAAA8xB,EAAA,OACA,IAAAA,EAAAl8B,QAAA+E,KAAAu3B,YAAAJ,GACA90B,EAAAb,KAAA0C,QAAAizB,EAAA5S,QAAA,GAKA,IAHAliB,EAAA9D,OAAAwG,OAAyBhD,KAAAo1B,EAAA,MAAAn1B,OAAAm1B,EAAA,OAEzB90B,EAAAmC,KAAA,GACA2yB,EAAAl8B,QAAA,CACA,IAAAoF,EAAA82B,EAAA,MACA,SAAA92B,GAAA,UAAAA,GAAA,YAAAA,EACA,MAEAgC,EAAAmC,MAAA2yB,EAAA5S,QAAA,GAGAliB,EAAAb,KAAAoD,QAAA,GAGA,IADA,IAAA6xB,OAAA,EACAU,EAAAl8B,QAAA,CAGA,UAFAw7B,EAAAU,EAAA5S,SAEA,IACAliB,EAAAb,KAAAoD,SAAA6xB,EAAA,GACA,MAEAp0B,EAAAb,KAAAoD,SAAA6xB,EAAA,GAIA,MAAAp0B,EAAAmC,KAAA,UAAAnC,EAAAmC,KAAA,KACAnC,EAAAb,KAAA0C,QAAA7B,EAAAmC,KAAA,GACAnC,EAAAmC,KAAAnC,EAAAmC,KAAAnH,MAAA,IAEAgF,EAAAb,KAAAoD,SAAA5E,KAAAy3B,2BAAAN,GACAn3B,KAAA03B,wBAAAP,GAEA,QAAAv+B,EAAAu+B,EAAAl8B,OAAA,EAAmCrC,EAAA,EAAOA,IAAA,CAE1C,mBADA69B,EAAAU,EAAAv+B,IACA,GAAAse,cAAA,CACA7U,EAAAkO,WAAA,EACA,IAAAzL,EAAA9E,KAAA23B,WAAAR,EAAAv+B,GAEA,iBADAkM,EAAA9E,KAAA43B,cAAAT,GAAAryB,KACAzC,EAAAb,KAAA+O,UAAAzL,GACA,MACO,iBAAA2xB,EAAA,GAAAvf,cAAA,CAGP,IAFA,IAAAoQ,EAAA6P,EAAA95B,MAAA,GACA2B,EAAA,GACAiE,EAAArK,EAAuBqK,EAAA,EAAOA,IAAA,CAC9B,IAAA40B,EAAAvQ,EAAArkB,GAAA,GACA,OAAAjE,EAAAwH,OAAAtJ,QAAA,gBAAA26B,EACA,MAEA74B,EAAAsoB,EAAA+P,MAAA,GAAAr4B,EAEA,IAAAA,EAAAwH,OAAAtJ,QAAA,OACAmF,EAAAkO,WAAA,EACAlO,EAAAb,KAAA+O,UAAAvR,EACAm4B,EAAA7P,GAIA,aAAAmP,EAAA,gBAAAA,EAAA,GACA,MAIAz2B,KAAAuE,IAAAlC,EAAA,QAAA80B,IAEA,IAAA90B,EAAAxI,MAAAqD,QAAA,MAAA8C,KAAA83B,qBAAAX,IAGAd,EAAA77B,UAAAmW,OAAA,SAAA8lB,GACA,IAAAp0B,EAAA,IAAA0kB,EAAAhmB,QACAsB,EAAAlJ,KAAAs9B,EAAA,GAAAp5B,MAAA,GACA,KAAAgF,EAAAlJ,MACA6G,KAAA+3B,cAAA11B,EAAAo0B,GAEAz2B,KAAAg3B,KAAA30B,EAAAo0B,EAAA,GAAAA,EAAA,IAQA,IANA,IAAAxyB,OAAA,EACAsgB,OAAA,EACAlf,GAAA,EACA2yB,GAAA,EACApnB,MAEA5Q,KAAAw2B,UAAAE,aAAA,CAGA,UAFAD,EAAAz2B,KAAAw2B,UAAAG,aAEA,GAAyB,CACzBt0B,EAAA9D,OAAAmI,KAA2B3E,KAAA00B,EAAA,GAAAz0B,OAAAy0B,EAAA,IAC3Bz2B,KAAAiQ,WAAA,EACA,MACO,SAAAwmB,EAAA,GAAyB,CAChCuB,GAAA,EACA,MACO,SAAAvB,EAAA,GAAyB,CAChC,GAAA7lB,EAAA3V,OAAA,GAGA,IADAgJ,EAAA2M,EADA2T,EAAA3T,EAAA3V,OAAA,GAEAgJ,GAAA,UAAAA,EAAA,IACAA,EAAA2M,IAAA2T,GAEAtgB,IACA5B,EAAA9D,OAAAmI,KAA+B3E,KAAAkC,EAAA,GAAAjC,OAAAiC,EAAA,KAG/BjE,KAAA0G,IAAA+vB,GACA,MAKA,GAHA7lB,EAAA7K,KAAA0wB,GAGAz2B,KAAAw2B,UAAAE,YAAA,CACArxB,GAAA,EACA,OAIAhD,EAAAb,KAAAoD,QAAA5E,KAAAw3B,yBAAA5mB,GACAA,EAAA3V,QACAoH,EAAAb,KAAAqP,UAAA7Q,KAAAy3B,2BAAA7mB,GACA5Q,KAAAuE,IAAAlC,EAAA,SAAAuO,GACAvL,IACAoxB,EAAA7lB,IAAA3V,OAAA,GACAoH,EAAA9D,OAAAmI,KAA2B3E,KAAA00B,EAAA,GAAAz0B,OAAAy0B,EAAA,IAC3Bz2B,KAAAs2B,OAAAj0B,EAAAb,KAAAoD,QACAvC,EAAAb,KAAAoD,QAAA,MAGAvC,EAAAb,KAAAqP,UAAA,GACAxO,EAAAuO,OAAA,IAGAonB,IACA31B,EAAAmB,SACAxD,KAAAylB,QAAApjB,IAIAg0B,EAAA77B,UAAAkM,IAAA,SAAA+vB,GACAz2B,KAAAylB,QAAAjiB,OAAAxD,KAAAylB,QAAAjiB,MAAAvI,SACA+E,KAAAylB,QAAAjkB,KAAAyO,UAAAjQ,KAAAiQ,WAEAjQ,KAAAiQ,WAAA,EAEAjQ,KAAAylB,QAAAjkB,KAAA4C,OAAApE,KAAAylB,QAAAjkB,KAAA4C,OAAA,IAAApE,KAAAs2B,OACAt2B,KAAAs2B,OAAA,GAEAt2B,KAAAylB,QAAAljB,QACAvC,KAAAylB,QAAAlnB,OAAAmI,KAAiC3E,KAAA00B,EAAA,GAAAz0B,OAAAy0B,EAAA,IACjCz2B,KAAAylB,QAAAzlB,KAAAylB,QAAAljB,QAEAvC,KAAAi4B,gBAAAxB,IAIAJ,EAAA77B,UAAAu8B,QAAA,WACA/2B,KAAAylB,QAAAljB,QAAAvC,KAAAk4B,gBACAl4B,KAAAylB,QAAAjiB,OAAAxD,KAAAylB,QAAAjiB,MAAAvI,SACA+E,KAAAylB,QAAAjkB,KAAAyO,UAAAjQ,KAAAiQ,WAEAjQ,KAAAylB,QAAAjkB,KAAA4C,OAAApE,KAAAylB,QAAAjkB,KAAA4C,OAAA,IAAApE,KAAAs2B,QAGAD,EAAA77B,UAAAo8B,cAAA,SAAAH,GAEA,GADAz2B,KAAAs2B,QAAAG,EAAA,GACAz2B,KAAAylB,QAAAjiB,MAAA,CACA,IAAAS,EAAAjE,KAAAylB,QAAAjiB,MAAAxD,KAAAylB,QAAAjiB,MAAAvI,OAAA,GACAgJ,GAAA,SAAAA,EAAA5D,OAAA4D,EAAAzC,KAAAkP,eACAzM,EAAAzC,KAAAkP,aAAA1Q,KAAAs2B,OACAt2B,KAAAs2B,OAAA,MAOAD,EAAA77B,UAAAw8B,KAAA,SAAA30B,EAAAN,EAAAC,GACAhC,KAAAylB,QAAA1f,KAAA1D,GAEAA,EAAA9D,QAAmBwG,OAAShD,OAAAC,UAA6BF,MAAA9B,KAAA8B,OACzDO,EAAAb,KAAA0C,OAAAlE,KAAAs2B,OACAt2B,KAAAs2B,OAAA,GACA,YAAAj0B,EAAAhC,OAAAL,KAAAiQ,WAAA,IAGAomB,EAAA77B,UAAA+J,IAAA,SAAAlC,EAAAmC,EAAA2yB,GAUA,IATA,IAAAV,OAAA,EACAp2B,OAAA,EACApF,EAAAk8B,EAAAl8B,OACApB,EAAA,GACAs+B,GAAA,EACAp0B,OAAA,EACAE,OAAA,EACAmI,EAAA,oBAEAxT,EAAA,EAAmBA,EAAAqC,EAAYrC,GAAA,EAI/B,aAFAyH,GADAo2B,EAAAU,EAAAv+B,IACA,KAEA,SAAAyJ,EAAAhC,KAaA,YAAAA,GAAA,UAAAA,GAAAzH,IAAAqC,EAAA,EACAk9B,GAAA,EAEAt+B,GAAA48B,EAAA,IAfAxyB,EAAAkzB,EAAAv+B,EAAA,GACAmL,EAAAozB,EAAAv+B,EAAA,GAEA,UAAAqL,EAAA,cAAAF,EAAA,IAAAqI,EAAArP,KAAAkH,EAAA,KAAAmI,EAAArP,KAAAgH,EAAA,IACAlK,GAAA48B,EAAA,GAEA0B,GAAA,GAYA,IAAAA,EAAA,CACA,IAAA5zB,EAAA4yB,EAAAiB,OAAA,SAAAC,EAAAz/B,GACA,OAAAy/B,EAAAz/B,EAAA,IACO,IACPyJ,EAAAb,KAAAgD,IAAyB3K,QAAA0K,OAEzBlC,EAAAmC,GAAA3K,GAGAw8B,EAAA77B,UAAAg9B,yBAAA,SAAAL,GAGA,IAFA,IAAAmB,OAAA,EACAhC,EAAA,GACAa,EAAAl8B,SAEA,WADAq9B,EAAAnB,IAAAl8B,OAAA,QACA,YAAAq9B,IACAhC,EAAAa,EAAAE,MAAA,GAAAf,EAEA,OAAAA,GAGAD,EAAA77B,UAAAi9B,2BAAA,SAAAN,GAGA,IAFA,IAAApzB,OAAA,EACAuyB,EAAA,GACAa,EAAAl8B,SAEA,WADA8I,EAAAozB,EAAA,QACA,YAAApzB,IACAuyB,GAAAa,EAAA5S,QAAA,GAEA,OAAA+R,GAGAD,EAAA77B,UAAAo9B,cAAA,SAAAT,GAGA,IAFA,IACAb,EAAA,GACAa,EAAAl8B,QAEA,UADAk8B,IAAAl8B,OAAA,OAEAq7B,EAAAa,EAAAE,MAAA,GAAAf,EAEA,OAAAA,GAGAD,EAAA77B,UAAAm9B,WAAA,SAAAR,EAAA7wB,GAEA,IADA,IAAApE,EAAA,GACAtJ,EAAA0N,EAAsB1N,EAAAu+B,EAAAl8B,OAAmBrC,IACzCsJ,GAAAi1B,EAAAv+B,GAAA,GAGA,OADAu+B,EAAA56B,OAAA+J,EAAA6wB,EAAAl8B,OAAAqL,GACApE,GAGAm0B,EAAA77B,UAAA8U,MAAA,SAAA6nB,GAKA,IAJA,IAAAD,EAAA,EACAT,OAAA,EACAp2B,OAAA,EACA4D,OAAA,EACArL,EAAA,EAAmBA,EAAAu+B,EAAAl8B,OAAmBrC,IAAA,CAItC,UAFAyH,GADAo2B,EAAAU,EAAAv+B,IACA,IAGAs+B,GAAA,OACO,SAAA72B,EACP62B,GAAA,OACO,OAAAA,GAAA,MAAA72B,EAAA,CACP,GAAA4D,EAES,aAAAA,EAAA,eAAAA,EAAA,GACT,SAEA,OAAArL,EAJAoH,KAAAu4B,YAAA9B,GAQAxyB,EAAAwyB,EAEA,UAKAJ,EAAA77B,UAAA88B,gBAAA,SAAAL,GACA,MAAAj3B,KAAA8B,MAAAL,MAAA,mBAAAw1B,EAAA,GAAAA,EAAA,KAGAZ,EAAA77B,UAAA+8B,YAAA,SAAAJ,GACA,MAAAn3B,KAAA8B,MAAAL,MAAA,eAAA01B,EAAA,MAAAA,EAAA,QAGAd,EAAA77B,UAAAy9B,gBAAA,SAAAxB,GACA,MAAAz2B,KAAA8B,MAAAL,MAAA,eAAwCg1B,EAAA,GAAAA,EAAA,KAGxCJ,EAAA77B,UAAA09B,cAAA,WACA,IAAAt2B,EAAA5B,KAAAylB,QAAAlnB,OAAAwG,MACA,MAAA/E,KAAA8B,MAAAL,MAAA,iBAAAG,EAAAG,KAAAH,EAAAI,SAGAq0B,EAAA77B,UAAA+9B,YAAA,SAAA9B,GACA,MAAAz2B,KAAA8B,MAAAL,MAAA,eAAAg1B,EAAA,GAAAA,EAAA,KAGAJ,EAAA77B,UAAAu9B,cAAA,SAAA11B,EAAAo0B,GACA,MAAAz2B,KAAA8B,MAAAL,MAAA,uBAAAg1B,EAAA,GAAAA,EAAA,KAGAJ,EAAA77B,UAAAk9B,wBAAA,aAIArB,EAAA77B,UAAAs9B,qBAAA,SAAAX,GACA,IAAA7nB,EAAAtP,KAAAsP,MAAA6nB,GACA,QAAA7nB,EAAA,CAIA,IAFA,IAAAkpB,EAAA,EACA/B,OAAA,EACAxzB,EAAAqM,EAAA,EAA2BrM,GAAA,IAE3B,WADAwzB,EAAAU,EAAAl0B,IACA,IAEA,KADAu1B,GAAA,IAHmCv1B,KAOnC,MAAAjD,KAAA8B,MAAAL,MAAA,mBAAAg1B,EAAA,GAAAA,EAAA,MAGAJ,EA/fA,GAkgBAj+B,EAAA2I,QAAAs1B,EACAh+B,EAAAD,UAAA,sCCjiBAA,EAAA4B,YAAA,EACA5B,EAAA2I,QA0BA,SAAAe,GACA,IAAAqkB,EAAAnrB,UAAAC,OAAA,QAAAsG,IAAAvG,UAAA,GAAAA,UAAA,MAEA4M,EAAA9F,EAAA8F,IAAA6wB,UACAzS,EAAAG,EAAAuS,aAEAtpB,OAAA,EACArL,OAAA,EACA4hB,OAAA,EACAlX,OAAA,EACApJ,OAAA,EACAsP,OAAA,EACAiR,OAAA,EACAwM,OAAA,EACAuG,OAAA,EACAC,OAAA,EACAC,OAAA,EACA50B,OAAA,EACA5J,OAAA,EACAy+B,OAAA,EAEA79B,EAAA2M,EAAA3M,OACA+c,GAAA,EACAjW,EAAA,EACAH,EAAA,EACA4U,KACAuiB,KAEA,SAAAC,EAAAC,GACA,MAAAn3B,EAAAL,MAAA,YAAAw3B,EAAAl3B,EAAAH,EAAAoW,GAgPA,OACAof,KALA,SAAAX,GACAsC,EAAAhzB,KAAA0wB,IAKAE,UA3OA,WACA,GAAAoC,EAAA99B,OAAA,OAAA89B,EAAA1B,MACA,GAAAz1B,GAAA3G,EAAA,SAEAmU,EAAAxH,EAAAjK,WAAAiE,MACAs3B,GAAA9pB,IAAA+pB,GAAA/pB,IAAAgqB,GAAAxxB,EAAAjK,WAAAiE,EAAA,KAAAs3B,KACAlhB,EAAApW,EACAG,GAAA,GAGA,OAAAqN,GACA,KAAA8pB,EACA,KAAAG,EACA,KAAAC,EACA,KAAAF,EACA,KAAAD,EACAp1B,EAAAnC,EACA,GACAmC,GAAA,GACAqL,EAAAxH,EAAAjK,WAAAoG,MACAm1B,IACAlhB,EAAAjU,EACAhC,GAAA,SAESqN,IAAAiqB,GAAAjqB,IAAA8pB,GAAA9pB,IAAAkqB,GAAAlqB,IAAAgqB,GAAAhqB,IAAA+pB,GAETL,GAAA,QAAAlxB,EAAAvK,MAAAuE,EAAAmC,IACAnC,EAAAmC,EAAA,EACA,MAEA,KAAAw1B,EACAT,GAAA,QAAA/2B,EAAAH,EAAAoW,GACA,MAEA,KAAAwhB,EACAV,GAAA,QAAA/2B,EAAAH,EAAAoW,GACA,MAEA,KAAAyhB,EACAX,GAAA,IAA0B,IAAK/2B,EAAAH,EAAAoW,GAC/B,MAEA,KAAA0hB,EACAZ,GAAA,IAA0B,IAAK/2B,EAAAH,EAAAoW,GAC/B,MAEA,KAAA2hB,EACAb,GAAA,QAAA/2B,EAAAH,EAAAoW,GACA,MAEA,KAAA4hB,EACAd,GAAA,IAA0B,IAAK/2B,EAAAH,EAAAoW,GAC/B,MAEA,KAAA6hB,EAGA,GAFA51B,EAAAuS,EAAAvb,OAAAub,EAAA6gB,MAAA,MACAh9B,EAAAuN,EAAAjK,WAAAiE,EAAA,GACA,QAAAqC,GAAA5J,IAAAy/B,GAAAz/B,IAAA0/B,GAAA1/B,IAAAg/B,GAAAh/B,IAAA6+B,GAAA7+B,IAAAi/B,GAAAj/B,IAAA8+B,GAAA9+B,IAAA++B,EAAA,CACAr1B,EAAAnC,EACA,GAGA,GAFAg3B,GAAA,GAEA,KADA70B,EAAA6D,EAAA1K,QAAA,IAAA6G,EAAA,IACA,CACA,GAAAiiB,EAAA,CACAjiB,EAAAnC,EACA,MAEAo3B,EAAA,WAIA,IADAH,EAAA90B,EACA6D,EAAAjK,WAAAk7B,EAAA,KAAAmB,GACAnB,GAAA,EACAD,WAEWA,GAEXE,GAAA,WAAAlxB,EAAAvK,MAAAuE,EAAAmC,EAAA,GAAAhC,EAAAH,EAAAoW,EAAAjW,EAAAgC,EAAAiU,GAEApW,EAAAmC,OAEAA,EAAA6D,EAAA1K,QAAA,IAAA0E,EAAA,GACA+S,EAAA/M,EAAAvK,MAAAuE,EAAAmC,EAAA,IAEA,IAAAA,GAAAk2B,EAAAl9B,KAAA4X,GACAmkB,GAAA,QAAA/2B,EAAAH,EAAAoW,IAEA8gB,GAAA,WAAAnkB,EAAA5S,EAAAH,EAAAoW,EAAAjW,EAAAgC,EAAAiU,GACApW,EAAAmC,GAIA,MAEA,KAAAm2B,EACApB,GAAA,QAAA/2B,EAAAH,EAAAoW,GACA,MAEA,KAAA8hB,EACA,KAAAC,EACApU,EAAAvW,IAAA0qB,EAAA,QACA/1B,EAAAnC,EACA,GAGA,GAFAg3B,GAAA,GAEA,KADA70B,EAAA6D,EAAA1K,QAAAyoB,EAAA5hB,EAAA,IACA,CACA,GAAAiiB,EAAA,CACAjiB,EAAAnC,EAAA,EACA,MAEAo3B,EAAA,UAIA,IADAH,EAAA90B,EACA6D,EAAAjK,WAAAk7B,EAAA,KAAAmB,GACAnB,GAAA,EACAD,WAESA,GAETjkB,EAAA/M,EAAAvK,MAAAuE,EAAAmC,EAAA,GACA0K,EAAAkG,EAAAtY,MAAA,OACAgJ,EAAAoJ,EAAAxT,OAAA,GAEA,GACAm3B,EAAArwB,EAAAsD,EACAszB,EAAA50B,EAAA0K,EAAApJ,GAAApK,SAEAm3B,EAAArwB,EACA42B,EAAA3gB,GAGA8gB,GAAA,SAAAlxB,EAAAvK,MAAAuE,EAAAmC,EAAA,GAAAhC,EAAAH,EAAAoW,EAAAoa,EAAAruB,EAAA40B,GAEA3gB,EAAA2gB,EACA52B,EAAAqwB,EACAxwB,EAAAmC,EACA,MAEA,KAAAo2B,EACAC,EAAAC,UAAAz4B,EAAA,EACAw4B,EAAAr9B,KAAA6K,GAEA7D,EADA,IAAAq2B,EAAAC,UACAzyB,EAAA3M,OAAA,EAEAm/B,EAAAC,UAAA,EAGAvB,GAAA,UAAAlxB,EAAAvK,MAAAuE,EAAAmC,EAAA,GAAAhC,EAAAH,EAAAoW,EAAAjW,EAAAgC,EAAAiU,GAEApW,EAAAmC,EACA,MAEA,KAAAi2B,EAGA,IAFAj2B,EAAAnC,EACAgkB,GAAA,EACAhe,EAAAjK,WAAAoG,EAAA,KAAAi2B,GACAj2B,GAAA,EACA6hB,KAGA,GADAxW,EAAAxH,EAAAjK,WAAAoG,EAAA,GACA6hB,GAAAxW,IAAAkrB,GAAAlrB,IAAAiqB,GAAAjqB,IAAA8pB,GAAA9pB,IAAAkqB,GAAAlqB,IAAAgqB,GAAAhqB,IAAA+pB,IACAp1B,GAAA,EACAw2B,EAAAx9B,KAAA6K,EAAA/K,OAAAkH,KAAA,CACA,KAAAw2B,EAAAx9B,KAAA6K,EAAA/K,OAAAkH,EAAA,KACAA,GAAA,EAEA6D,EAAAjK,WAAAoG,EAAA,KAAAs1B,IACAt1B,GAAA,GAKA+0B,GAAA,OAAAlxB,EAAAvK,MAAAuE,EAAAmC,EAAA,GAAAhC,EAAAH,EAAAoW,EAAAjW,EAAAgC,EAAAiU,GAEApW,EAAAmC,EACA,MAEA,QACAqL,IAAAkrB,GAAA1yB,EAAAjK,WAAAiE,EAAA,KAAA44B,GAEA,KADAz2B,EAAA6D,EAAA1K,QAAA,KAAA0E,EAAA,QAEAokB,EACAjiB,EAAA6D,EAAA3M,OAEA+9B,EAAA,YAIArkB,EAAA/M,EAAAvK,MAAAuE,EAAAmC,EAAA,GACA0K,EAAAkG,EAAAtY,MAAA,OACAgJ,EAAAoJ,EAAAxT,OAAA,GAEA,GACAm3B,EAAArwB,EAAAsD,EACAszB,EAAA50B,EAAA0K,EAAApJ,GAAApK,SAEAm3B,EAAArwB,EACA42B,EAAA3gB,GAGA8gB,GAAA,UAAAnkB,EAAA5S,EAAAH,EAAAoW,EAAAoa,EAAAruB,EAAA40B,GAEA3gB,EAAA2gB,EACA52B,EAAAqwB,EACAxwB,EAAAmC,IAEA02B,EAAAJ,UAAAz4B,EAAA,EACA64B,EAAA19B,KAAA6K,GAEA7D,EADA,IAAA02B,EAAAJ,UACAzyB,EAAA3M,OAAA,EAEAw/B,EAAAJ,UAAA,EAGAvB,GAAA,OAAAlxB,EAAAvK,MAAAuE,EAAAmC,EAAA,GAAAhC,EAAAH,EAAAoW,EAAAjW,EAAAgC,EAAAiU,GAEAxB,EAAAzQ,KAAA+yB,GAEAl3B,EAAAmC,GAOA,OADAnC,IACAk3B,GAUApC,UAhPA,WACA,WAAAqC,EAAA99B,QAAA2G,GAAA3G,KA1DA,IAAA6+B,EAAA,GACAC,EAAA,GACAC,EAAA,GACAM,EAAA,GACApB,EAAA,GACAG,EAAA,GACAF,EAAA,GACAG,EAAA,EACAF,EAAA,GACAG,EAAA,GACAC,EAAA,GACAK,EAAA,GACAK,EAAA,GACAT,EAAA,IACAC,EAAA,IACAE,EAAA,GACAY,EAAA,GACAb,EAAA,GACAQ,EAAA,GAEAC,EAAA,6BACAK,EAAA,wCACAR,EAAA,cACAM,EAAA,YAqRAliC,EAAAD,UAAA,sCC9SAA,EAAA4B,YAAA,EAEA,IAAAiH,EAAA,mBAAAtH,QAAA,iBAAAA,OAAAuH,SAAA,SAAAJ,GAAoG,cAAAA,GAAqB,SAAAA,GAAmB,OAAAA,GAAA,mBAAAnH,QAAAmH,EAAAN,cAAA7G,QAAAmH,IAAAnH,OAAAa,UAAA,gBAAAsG,GAE5I4H,EAAA,WAAgC,SAAAC,EAAAC,EAAAC,GAA2C,QAAAjQ,EAAA,EAAgBA,EAAAiQ,EAAA5N,OAAkBrC,IAAA,CAAO,IAAAkQ,EAAAD,EAAAjQ,GAA2BkQ,EAAAtP,WAAAsP,EAAAtP,aAAA,EAAwDsP,EAAApI,cAAA,EAAgC,UAAAoI,MAAArI,UAAA,GAAuDnH,OAAAC,eAAAqP,EAAAE,EAAA3O,IAAA2O,IAA+D,gBAAAjJ,EAAAkJ,EAAAC,GAA2L,OAAlID,GAAAJ,EAAA9I,EAAArF,UAAAuO,GAAqEC,GAAAL,EAAA9I,EAAAmJ,GAA6DnJ,GAAxhB,GAIAsB,EAAAH,EAFsBtI,EAAQ,KAM9BgiC,EAAA15B,EAFmBtI,EAAQ,KAM3BivB,EAAA3mB,EAFYtI,EAAQ,IAIpB,SAAAsI,EAAAF,GAAsC,OAAAA,KAAA9G,WAAA8G,GAAuCC,QAAAD,GAI7E,IAAA65B,EAAA,EAUAC,EAAA,WAKA,SAAAA,EAAAhzB,GACA,IAAAjG,EAAA3G,UAAAC,OAAA,QAAAsG,IAAAvG,UAAA,GAAAA,UAAA,MAIA,GAtBA,SAAA4E,EAAAC,GAAiD,KAAAD,aAAAC,GAA0C,UAAAC,UAAA,qCAoB3FC,CAAAC,KAAA46B,GAEA,OAAAhzB,GAAA,qBAAAA,EAAA,YAAA3G,EAAA2G,QAAAnF,SACA,UAAAvH,MAAA,oBAAA0M,EAAA,0BAYA5H,KAAA4H,MAAAnF,WAEA,WAAAzC,KAAA4H,IAAA,UAAA5H,KAAA4H,IAAA,KACA5H,KAAA4H,IAAA5H,KAAA4H,IAAAvK,MAAA,IAGAsE,EAAA2E,OACA,YAAAvJ,KAAA4E,EAAA2E,MAWAtG,KAAAiO,KAAAtM,EAAA2E,KAEAtG,KAAAiO,KAAA0Z,EAAA5mB,QAAAiF,QAAArE,EAAA2E,OAIA,IAAAtD,EAAA,IAAA03B,EAAA35B,QAAAf,KAAA4H,IAAAjG,GACA,GAAAqB,EAAAb,KAAA,CAUAnC,KAAAgD,MACA,IAAAiL,EAAAjL,EAAAylB,WAAAxa,MACAjO,KAAAiO,UAAAjO,KAAAiO,KAAAjO,KAAA66B,WAAA5sB,IAGAjO,KAAAiO,OACA0sB,GAAA,EAYA36B,KAAAyJ,GAAA,cAAAkxB,EAAA,KAEA36B,KAAAgD,MAAAhD,KAAAgD,IAAAiL,KAAAjO,KAAAsG,MAoFA,OAjFAs0B,EAAApgC,UAAAiH,MAAA,SAAAC,EAAAK,EAAAC,GACA,IAAAL,EAAA3G,UAAAC,OAAA,QAAAsG,IAAAvG,UAAA,GAAAA,UAAA,MAEAkH,OAAA,EACA44B,EAAA96B,KAAA86B,OAAA/4B,EAAAC,GAUA,OARAE,EADA44B,EACA,IAAA35B,EAAAJ,QAAAW,EAAAo5B,EAAA/4B,KAAA+4B,EAAA94B,OAAA84B,EAAAv8B,OAAAu8B,EAAA7sB,KAAAtM,EAAAuM,QAEA,IAAA/M,EAAAJ,QAAAW,EAAAK,EAAAC,EAAAhC,KAAA4H,IAAA5H,KAAAiO,KAAAtM,EAAAuM,SAGApM,OAAoBC,OAAAC,SAAAzD,OAAAyB,KAAA4H,KACpB5H,KAAAiO,OAAA/L,EAAAJ,MAAAmM,KAAAjO,KAAAiO,MAEA/L,GAkBA04B,EAAApgC,UAAAsgC,OAAA,SAAA/4B,EAAAC,GACA,IAAAhC,KAAAgD,IAAA,SACA,IAAAylB,EAAAzoB,KAAAgD,IAAAylB,WAEAniB,EAAAmiB,EAAAjG,qBAA6CzgB,OAAAC,WAC7C,IAAAsE,EAAA/H,OAAA,SAEA,IAAA2D,GACA+L,KAAAjO,KAAA66B,WAAAv0B,EAAA/H,QACAwD,KAAAuE,EAAAvE,KACAC,OAAAsE,EAAAtE,QAGAzD,EAAAkqB,EAAA5G,iBAAAvb,EAAA/H,QAGA,OAFAA,IAAA2D,EAAA3D,UAEA2D,GAGA04B,EAAApgC,UAAAqgC,WAAA,SAAA5sB,GACA,kBAAAlR,KAAAkR,GACAA,EAEA0Z,EAAA5mB,QAAAiF,QAAAhG,KAAAgD,IAAAylB,WAAArpB,YAAA,IAAA6O,IAmBAvF,EAAAkyB,IACAzgC,IAAA,OACAV,IAAA,WACA,OAAAuG,KAAAiO,MAAAjO,KAAAyJ,OAIAmxB,EAlKA,GAqKAxiC,EAAA2I,QAAA65B,EASAviC,EAAAD,UAAA,uCChNA,SAAA6c,GAEA7c,EAAA4B,YAAA,EAEA,IAAAiH,EAAA,mBAAAtH,QAAA,iBAAAA,OAAAuH,SAAA,SAAAJ,GAAoG,cAAAA,GAAqB,SAAAA,GAAmB,OAAAA,GAAA,mBAAAnH,QAAAmH,EAAAN,cAAA7G,QAAAmH,IAAAnH,OAAAa,UAAA,gBAAAsG,GAI5I4mB,EAAA1mB,EAFiBtI,EAAQ,KAMzBivB,EAAA3mB,EAFYtI,EAAQ,IAMpBqiC,EAAA/5B,EAFUtI,EAAQ,KAIlB,SAAAsI,EAAAF,GAAsC,OAAAA,KAAA9G,WAAA8G,GAAuCC,QAAAD,GAwB7E,IAAAk6B,EAAA,WAKA,SAAAA,EAAApzB,EAAAjG,IA3BA,SAAA/B,EAAAC,GAAiD,KAAAD,aAAAC,GAA0C,UAAAC,UAAA,qCA4B3FC,CAAAC,KAAAg7B,GAEAh7B,KAAAi7B,eAAArzB,GAMA5H,KAAAoT,OAAApT,KAAAk7B,UAAAl7B,KAAAkoB,WAAA,SAEA,IAAAjkB,EAAAtC,EAAAqB,IAAArB,EAAAqB,IAAAiB,UAAA1C,EACAY,EAAAnC,KAAAm7B,QAAAx5B,EAAA2E,KAAArC,GACA9B,IAAAnC,KAAAmC,QAmGA,OArFA64B,EAAAxgC,UAAAiuB,SAAA,WAIA,OAHAzoB,KAAAo7B,gBACAp7B,KAAAo7B,cAAA,IAAA1T,EAAA3mB,QAAAkf,kBAAAjgB,KAAAmC,OAEAnC,KAAAo7B,eAUAJ,EAAAxgC,UAAA4tB,YAAA,WACA,SAAApoB,KAAAyoB,WAAA7E,gBAAA5jB,KAAAyoB,WAAA7E,eAAA3oB,OAAA,IAGA+/B,EAAAxgC,UAAA0gC,UAAA,SAAAp2B,EAAAC,GACA,QAAAD,GACAA,EAAAvH,OAAA,EAAAwH,EAAA9J,UAAA8J,GAGAi2B,EAAAxgC,UAAAygC,eAAA,SAAArzB,GACA,IAAArM,EAAAqM,EAAArM,MAAA,yCACAA,IAAAyE,KAAAkoB,WAAA3sB,EAAA,GAAAiL,SAGAw0B,EAAAxgC,UAAA6gC,aAAA,SAAAl5B,GACA,IAEAm5B,EAAA,yBAEA,GAAAt7B,KAAAk7B,UAAA/4B,EAAAm5B,GACA,OAAAC,mBAAAp5B,EAAA5E,OAAA+9B,EAAArgC,SACK,GANL,iDAMK8B,KAAAoF,IALL,kCAKKpF,KAAAoF,GACL,OAxFA,SAAAnD,GACA,OAAAiW,EACAA,EAAA3O,KAAAtH,EAAA,UAAAyD,WAEAjK,OAAAgjC,KAAAx8B,GAoFAy8B,CAAAt5B,EAAA5E,OAAAuM,OAAA4xB,UAAAzgC,SAEA,IAAA+a,EAAA7T,EAAA5G,MAAA,mCAAwD,GACxD,UAAAL,MAAA,mCAAA8a,IAIAglB,EAAAxgC,UAAA2gC,QAAA,SAAAltB,EAAAhK,GACA,QAAAA,EAAA,SAEA,GAAAA,EAAA,CACA,oBAAAA,EACA,OAAAA,EACO,sBAAAA,EAAA,CACP,IAAA03B,EAAA13B,EAAAgK,GACA,GAAA0tB,GAAAZ,EAAAh6B,QAAA66B,YAAAb,EAAAh6B,QAAA66B,WAAAD,GACA,OAAAZ,EAAAh6B,QAAA86B,aAAAF,EAAA,SAAAl5B,WAAA+D,OAEA,UAAAtL,MAAA,uCAAAygC,EAAAl5B,YAEO,GAAAwB,aAAAyjB,EAAA3mB,QAAAkf,kBACP,OAAAyH,EAAA3mB,QAAAif,mBAAAe,cAAA9c,GAAAxB,WACO,GAAAwB,aAAAyjB,EAAA3mB,QAAAif,mBACP,OAAA/b,EAAAxB,WACO,GAAAzC,KAAA8nB,MAAA7jB,GACP,OAAAhF,KAAA0D,UAAAsB,GAEA,UAAA/I,MAAA,2CAAA+I,EAAAxB,YAEK,GAAAzC,KAAAoT,OACL,OAAApT,KAAAq7B,aAAAr7B,KAAAkoB,YACK,GAAAloB,KAAAkoB,WAAA,CACL,IAAAllB,EAAAhD,KAAAkoB,WAIA,OAHAja,IAAAjL,EAAA2kB,EAAA5mB,QAAAvE,KAAAmrB,EAAA5mB,QAAAqG,QAAA6G,GAAAjL,IAEAhD,KAAA9H,KAAAyvB,EAAA5mB,QAAAqG,QAAApE,MACA+3B,EAAAh6B,QAAA66B,aAAAb,EAAAh6B,QAAA66B,WAAA54B,KACA+3B,EAAAh6B,QAAA86B,aAAA74B,EAAA,SAAAP,WAAA+D,SAOAw0B,EAAAxgC,UAAAstB,MAAA,SAAA9kB,GACA,2BAAAA,EAAA,YAAA/B,EAAA+B,MACA,iBAAAA,EAAAqgB,UAAA,iBAAArgB,EAAA4d,YAGAoa,EArHA,GAwHA5iC,EAAA2I,QAAAi6B,EACA3iC,EAAAD,UAAA,gFCjKAA,EAAA4B,YAAA,EA+CA5B,EAAA2I,SAzBA+6B,OAAA,SAAAt3B,GACA,IAAAjJ,EAAAiJ,EAAAjJ,MAAA,YACA,OAAAA,EACAA,EAAA,GAEA,IAeAwgC,WAAA,SAAAv3B,GACA,OAAAA,EAAA1H,QAAA,eAKAzE,EAAAD,UAAA","file":"dist/grapesjs-parser-postcss.min.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"grapesjs-parser-postcss\"] = factory();\n\telse\n\t\troot[\"grapesjs-parser-postcss\"] = factory();\n})(window, function() {\nreturn "," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 21);\n","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\n/**\n * This is a helper function for getting values from parameter/options\n * objects.\n *\n * @param args The object we are extracting values from\n * @param name The name of the property we are getting.\n * @param defaultValue An optional value to return if the property is missing\n * from the object. If this is not specified and the property is missing, an\n * error will be thrown.\n */\nfunction getArg(aArgs, aName, aDefaultValue) {\n  if (aName in aArgs) {\n    return aArgs[aName];\n  } else if (arguments.length === 3) {\n    return aDefaultValue;\n  } else {\n    throw new Error('\"' + aName + '\" is a required argument.');\n  }\n}\nexports.getArg = getArg;\n\nvar urlRegexp = /^(?:([\\w+\\-.]+):)?\\/\\/(?:(\\w+:\\w+)@)?([\\w.-]*)(?::(\\d+))?(.*)$/;\nvar dataUrlRegexp = /^data:.+\\,.+$/;\n\nfunction urlParse(aUrl) {\n  var match = aUrl.match(urlRegexp);\n  if (!match) {\n    return null;\n  }\n  return {\n    scheme: match[1],\n    auth: match[2],\n    host: match[3],\n    port: match[4],\n    path: match[5]\n  };\n}\nexports.urlParse = urlParse;\n\nfunction urlGenerate(aParsedUrl) {\n  var url = '';\n  if (aParsedUrl.scheme) {\n    url += aParsedUrl.scheme + ':';\n  }\n  url += '//';\n  if (aParsedUrl.auth) {\n    url += aParsedUrl.auth + '@';\n  }\n  if (aParsedUrl.host) {\n    url += aParsedUrl.host;\n  }\n  if (aParsedUrl.port) {\n    url += \":\" + aParsedUrl.port\n  }\n  if (aParsedUrl.path) {\n    url += aParsedUrl.path;\n  }\n  return url;\n}\nexports.urlGenerate = urlGenerate;\n\n/**\n * Normalizes a path, or the path portion of a URL:\n *\n * - Replaces consecutive slashes with one slash.\n * - Removes unnecessary '.' parts.\n * - Removes unnecessary '<dir>/..' parts.\n *\n * Based on code in the Node.js 'path' core module.\n *\n * @param aPath The path or url to normalize.\n */\nfunction normalize(aPath) {\n  var path = aPath;\n  var url = urlParse(aPath);\n  if (url) {\n    if (!url.path) {\n      return aPath;\n    }\n    path = url.path;\n  }\n  var isAbsolute = exports.isAbsolute(path);\n\n  var parts = path.split(/\\/+/);\n  for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {\n    part = parts[i];\n    if (part === '.') {\n      parts.splice(i, 1);\n    } else if (part === '..') {\n      up++;\n    } else if (up > 0) {\n      if (part === '') {\n        // The first part is blank if the path is absolute. Trying to go\n        // above the root is a no-op. Therefore we can remove all '..' parts\n        // directly after the root.\n        parts.splice(i + 1, up);\n        up = 0;\n      } else {\n        parts.splice(i, 2);\n        up--;\n      }\n    }\n  }\n  path = parts.join('/');\n\n  if (path === '') {\n    path = isAbsolute ? '/' : '.';\n  }\n\n  if (url) {\n    url.path = path;\n    return urlGenerate(url);\n  }\n  return path;\n}\nexports.normalize = normalize;\n\n/**\n * Joins two paths/URLs.\n *\n * @param aRoot The root path or URL.\n * @param aPath The path or URL to be joined with the root.\n *\n * - If aPath is a URL or a data URI, aPath is returned, unless aPath is a\n *   scheme-relative URL: Then the scheme of aRoot, if any, is prepended\n *   first.\n * - Otherwise aPath is a path. If aRoot is a URL, then its path portion\n *   is updated with the result and aRoot is returned. Otherwise the result\n *   is returned.\n *   - If aPath is absolute, the result is aPath.\n *   - Otherwise the two paths are joined with a slash.\n * - Joining for example 'http://' and 'www.example.com' is also supported.\n */\nfunction join(aRoot, aPath) {\n  if (aRoot === \"\") {\n    aRoot = \".\";\n  }\n  if (aPath === \"\") {\n    aPath = \".\";\n  }\n  var aPathUrl = urlParse(aPath);\n  var aRootUrl = urlParse(aRoot);\n  if (aRootUrl) {\n    aRoot = aRootUrl.path || '/';\n  }\n\n  // `join(foo, '//www.example.org')`\n  if (aPathUrl && !aPathUrl.scheme) {\n    if (aRootUrl) {\n      aPathUrl.scheme = aRootUrl.scheme;\n    }\n    return urlGenerate(aPathUrl);\n  }\n\n  if (aPathUrl || aPath.match(dataUrlRegexp)) {\n    return aPath;\n  }\n\n  // `join('http://', 'www.example.com')`\n  if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {\n    aRootUrl.host = aPath;\n    return urlGenerate(aRootUrl);\n  }\n\n  var joined = aPath.charAt(0) === '/'\n    ? aPath\n    : normalize(aRoot.replace(/\\/+$/, '') + '/' + aPath);\n\n  if (aRootUrl) {\n    aRootUrl.path = joined;\n    return urlGenerate(aRootUrl);\n  }\n  return joined;\n}\nexports.join = join;\n\nexports.isAbsolute = function (aPath) {\n  return aPath.charAt(0) === '/' || urlRegexp.test(aPath);\n};\n\n/**\n * Make a path relative to a URL or another path.\n *\n * @param aRoot The root path or URL.\n * @param aPath The path or URL to be made relative to aRoot.\n */\nfunction relative(aRoot, aPath) {\n  if (aRoot === \"\") {\n    aRoot = \".\";\n  }\n\n  aRoot = aRoot.replace(/\\/$/, '');\n\n  // It is possible for the path to be above the root. In this case, simply\n  // checking whether the root is a prefix of the path won't work. Instead, we\n  // need to remove components from the root one by one, until either we find\n  // a prefix that fits, or we run out of components to remove.\n  var level = 0;\n  while (aPath.indexOf(aRoot + '/') !== 0) {\n    var index = aRoot.lastIndexOf(\"/\");\n    if (index < 0) {\n      return aPath;\n    }\n\n    // If the only part of the root that is left is the scheme (i.e. http://,\n    // file:///, etc.), one or more slashes (/), or simply nothing at all, we\n    // have exhausted all components, so the path is not relative to the root.\n    aRoot = aRoot.slice(0, index);\n    if (aRoot.match(/^([^\\/]+:\\/)?\\/*$/)) {\n      return aPath;\n    }\n\n    ++level;\n  }\n\n  // Make sure we add a \"../\" for each component we removed from the root.\n  return Array(level + 1).join(\"../\") + aPath.substr(aRoot.length + 1);\n}\nexports.relative = relative;\n\nvar supportsNullProto = (function () {\n  var obj = Object.create(null);\n  return !('__proto__' in obj);\n}());\n\nfunction identity (s) {\n  return s;\n}\n\n/**\n * Because behavior goes wacky when you set `__proto__` on objects, we\n * have to prefix all the strings in our set with an arbitrary character.\n *\n * See https://github.com/mozilla/source-map/pull/31 and\n * https://github.com/mozilla/source-map/issues/30\n *\n * @param String aStr\n */\nfunction toSetString(aStr) {\n  if (isProtoString(aStr)) {\n    return '$' + aStr;\n  }\n\n  return aStr;\n}\nexports.toSetString = supportsNullProto ? identity : toSetString;\n\nfunction fromSetString(aStr) {\n  if (isProtoString(aStr)) {\n    return aStr.slice(1);\n  }\n\n  return aStr;\n}\nexports.fromSetString = supportsNullProto ? identity : fromSetString;\n\nfunction isProtoString(s) {\n  if (!s) {\n    return false;\n  }\n\n  var length = s.length;\n\n  if (length < 9 /* \"__proto__\".length */) {\n    return false;\n  }\n\n  if (s.charCodeAt(length - 1) !== 95  /* '_' */ ||\n      s.charCodeAt(length - 2) !== 95  /* '_' */ ||\n      s.charCodeAt(length - 3) !== 111 /* 'o' */ ||\n      s.charCodeAt(length - 4) !== 116 /* 't' */ ||\n      s.charCodeAt(length - 5) !== 111 /* 'o' */ ||\n      s.charCodeAt(length - 6) !== 114 /* 'r' */ ||\n      s.charCodeAt(length - 7) !== 112 /* 'p' */ ||\n      s.charCodeAt(length - 8) !== 95  /* '_' */ ||\n      s.charCodeAt(length - 9) !== 95  /* '_' */) {\n    return false;\n  }\n\n  for (var i = length - 10; i >= 0; i--) {\n    if (s.charCodeAt(i) !== 36 /* '$' */) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n/**\n * Comparator between two mappings where the original positions are compared.\n *\n * Optionally pass in `true` as `onlyCompareGenerated` to consider two\n * mappings with the same original source/line/column, but different generated\n * line and column the same. Useful when searching for a mapping with a\n * stubbed out mapping.\n */\nfunction compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {\n  var cmp = strcmp(mappingA.source, mappingB.source);\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.originalLine - mappingB.originalLine;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.originalColumn - mappingB.originalColumn;\n  if (cmp !== 0 || onlyCompareOriginal) {\n    return cmp;\n  }\n\n  cmp = mappingA.generatedColumn - mappingB.generatedColumn;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.generatedLine - mappingB.generatedLine;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  return strcmp(mappingA.name, mappingB.name);\n}\nexports.compareByOriginalPositions = compareByOriginalPositions;\n\n/**\n * Comparator between two mappings with deflated source and name indices where\n * the generated positions are compared.\n *\n * Optionally pass in `true` as `onlyCompareGenerated` to consider two\n * mappings with the same generated line and column, but different\n * source/name/original line and column the same. Useful when searching for a\n * mapping with a stubbed out mapping.\n */\nfunction compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {\n  var cmp = mappingA.generatedLine - mappingB.generatedLine;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.generatedColumn - mappingB.generatedColumn;\n  if (cmp !== 0 || onlyCompareGenerated) {\n    return cmp;\n  }\n\n  cmp = strcmp(mappingA.source, mappingB.source);\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.originalLine - mappingB.originalLine;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.originalColumn - mappingB.originalColumn;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  return strcmp(mappingA.name, mappingB.name);\n}\nexports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;\n\nfunction strcmp(aStr1, aStr2) {\n  if (aStr1 === aStr2) {\n    return 0;\n  }\n\n  if (aStr1 === null) {\n    return 1; // aStr2 !== null\n  }\n\n  if (aStr2 === null) {\n    return -1; // aStr1 !== null\n  }\n\n  if (aStr1 > aStr2) {\n    return 1;\n  }\n\n  return -1;\n}\n\n/**\n * Comparator between two mappings with inflated source and name strings where\n * the generated positions are compared.\n */\nfunction compareByGeneratedPositionsInflated(mappingA, mappingB) {\n  var cmp = mappingA.generatedLine - mappingB.generatedLine;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.generatedColumn - mappingB.generatedColumn;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = strcmp(mappingA.source, mappingB.source);\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.originalLine - mappingB.originalLine;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.originalColumn - mappingB.originalColumn;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  return strcmp(mappingA.name, mappingB.name);\n}\nexports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;\n\n/**\n * Strip any JSON XSSI avoidance prefix from the string (as documented\n * in the source maps specification), and then parse the string as\n * JSON.\n */\nfunction parseSourceMapInput(str) {\n  return JSON.parse(str.replace(/^\\)]}'[^\\n]*\\n/, ''));\n}\nexports.parseSourceMapInput = parseSourceMapInput;\n\n/**\n * Compute the URL of a source given the the source root, the source's\n * URL, and the source map's URL.\n */\nfunction computeSourceURL(sourceRoot, sourceURL, sourceMapURL) {\n  sourceURL = sourceURL || '';\n\n  if (sourceRoot) {\n    // This follows what Chrome does.\n    if (sourceRoot[sourceRoot.length - 1] !== '/' && sourceURL[0] !== '/') {\n      sourceRoot += '/';\n    }\n    // The spec says:\n    //   Line 4: An optional source root, useful for relocating source\n    //   files on a server or removing repeated values in the\n    //   “sources” entry.  This value is prepended to the individual\n    //   entries in the “source” field.\n    sourceURL = sourceRoot + sourceURL;\n  }\n\n  // Historically, SourceMapConsumer did not take the sourceMapURL as\n  // a parameter.  This mode is still somewhat supported, which is why\n  // this code block is conditional.  However, it's preferable to pass\n  // the source map URL to SourceMapConsumer, so that this function\n  // can implement the source URL resolution algorithm as outlined in\n  // 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 the\n  // 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 the\n  //   “sourceRoot”, the sources are resolved relative to the\n  //   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  }\n\n  return normalize(sourceURL);\n}\nexports.computeSourceURL = computeSourceURL;\n","'use strict';\n\nexports.__esModule = true;\n\nvar _node = require('./node');\n\nvar _node2 = _interopRequireDefault(_node);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\n/**\n * Represents a CSS declaration.\n *\n * @extends Node\n *\n * @example\n * const root = postcss.parse('a { color: black }')\n * const decl = root.first.first\n * decl.type       //=> 'decl'\n * decl.toString() //=> ' color: black'\n */\nvar Declaration = function (_Node) {\n  _inherits(Declaration, _Node);\n\n  function Declaration(defaults) {\n    _classCallCheck(this, Declaration);\n\n    var _this = _possibleConstructorReturn(this, _Node.call(this, defaults));\n\n    _this.type = 'decl';\n    return _this;\n  }\n\n  /**\n   * @memberof Declaration#\n   * @member {string} prop The declaration’s property name.\n   *\n   * @example\n   * const root = postcss.parse('a { color: black }')\n   * const decl = root.first.first\n   * decl.prop //=> 'color'\n   */\n\n  /**\n   * @memberof Declaration#\n   * @member {string} value The declaration’s value.\n   *\n   * @example\n   * const root = postcss.parse('a { color: black }')\n   * const decl = root.first.first\n   * decl.value //=> 'black'\n   */\n\n  /**\n   * @memberof Declaration#\n   * @member {boolean} important `true` if the declaration\n   *                             has an !important annotation.\n   *\n   * @example\n   * const root = postcss.parse('a { color: black !important; color: red }')\n   * root.first.first.important //=> true\n   * root.first.last.important  //=> undefined\n   */\n\n  /**\n   * @memberof Declaration#\n   * @member {object} raws Information to generate byte-to-byte equal\n   *                       node string as it was in the origin input.\n   *\n   * Every parser saves its own properties,\n   * but the default CSS parser uses:\n   *\n   * * `before`: the space symbols before the node. It also stores `*`\n   *   and `_` symbols before the declaration (IE hack).\n   * * `between`: the symbols between the property and value\n   *   for declarations.\n   * * `important`: the content of the important statement,\n   *   if it is not just `!important`.\n   *\n   * PostCSS cleans declaration from comments and extra spaces,\n   * but it stores origin content in raws properties.\n   * As such, if you don’t change a declaration’s value,\n   * PostCSS will use the raw value with comments.\n   *\n   * @example\n   * const root = postcss.parse('a {\\n  color:black\\n}')\n   * root.first.first.raws //=> { before: '\\n  ', between: ':' }\n   */\n\n\n  return Declaration;\n}(_node2.default);\n\nexports.default = Declaration;\nmodule.exports = exports['default'];\n//# sourceMappingURL=data:application/json;charset=utf8;base64,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\n","'use strict';\n\nexports.__esModule = true;\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nvar _cssSyntaxError = require('./css-syntax-error');\n\nvar _cssSyntaxError2 = _interopRequireDefault(_cssSyntaxError);\n\nvar _stringifier = require('./stringifier');\n\nvar _stringifier2 = _interopRequireDefault(_stringifier);\n\nvar _stringify = require('./stringify');\n\nvar _stringify2 = _interopRequireDefault(_stringify);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction cloneNode(obj, parent) {\n  var cloned = new obj.constructor();\n\n  for (var i in obj) {\n    if (!obj.hasOwnProperty(i)) continue;\n    var value = obj[i];\n    var type = typeof value === 'undefined' ? 'undefined' : _typeof(value);\n\n    if (i === 'parent' && type === 'object') {\n      if (parent) cloned[i] = parent;\n    } else if (i === 'source') {\n      cloned[i] = value;\n    } else if (value instanceof Array) {\n      cloned[i] = value.map(function (j) {\n        return cloneNode(j, cloned);\n      });\n    } else {\n      if (type === 'object' && value !== null) value = cloneNode(value);\n      cloned[i] = value;\n    }\n  }\n\n  return cloned;\n}\n\n/**\n * All node classes inherit the following common methods.\n *\n * @abstract\n */\n\nvar Node = function () {\n  /**\n   * @param {object} [defaults] Value for node properties.\n   */\n  function Node() {\n    var defaults = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n\n    _classCallCheck(this, Node);\n\n    this.raws = {};\n    if (process.env.NODE_ENV !== 'production') {\n      if ((typeof defaults === 'undefined' ? 'undefined' : _typeof(defaults)) !== 'object' && typeof defaults !== 'undefined') {\n        throw new Error('PostCSS nodes constructor accepts object, not ' + JSON.stringify(defaults));\n      }\n    }\n    for (var name in defaults) {\n      this[name] = defaults[name];\n    }\n  }\n\n  /**\n   * Returns a `CssSyntaxError` instance containing the original position\n   * of the node in the source, showing line and column numbers and also\n   * a small excerpt to facilitate debugging.\n   *\n   * If present, an input source map will be used to get the original position\n   * of the source, even from a previous compilation step\n   * (e.g., from Sass compilation).\n   *\n   * This method produces very useful error messages.\n   *\n   * @param {string} message     Error description.\n   * @param {object} [opts]      Options.\n   * @param {string} opts.plugin Plugin name that created this error.\n   *                             PostCSS will set it automatically.\n   * @param {string} opts.word   A word inside a node’s string that should\n   *                             be highlighted as the source of the error.\n   * @param {number} opts.index  An index inside a node’s string that should\n   *                             be highlighted as the source of the error.\n   *\n   * @return {CssSyntaxError} Error object to throw it.\n   *\n   * @example\n   * if (!variables[name]) {\n   *   throw decl.error('Unknown variable ' + name, { word: name })\n   *   // CssSyntaxError: postcss-vars:a.sass:4:3: Unknown variable $black\n   *   //   color: $black\n   *   // a\n   *   //          ^\n   *   //   background: white\n   * }\n   */\n\n\n  Node.prototype.error = function error(message) {\n    var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    if (this.source) {\n      var pos = this.positionBy(opts);\n      return this.source.input.error(message, pos.line, pos.column, opts);\n    } else {\n      return new _cssSyntaxError2.default(message);\n    }\n  };\n\n  /**\n   * This method is provided as a convenience wrapper for {@link Result#warn}.\n   *\n   * @param {Result} result      The {@link Result} instance\n   *                             that will receive the warning.\n   * @param {string} text        Warning message.\n   * @param {object} [opts]      Options\n   * @param {string} opts.plugin Plugin name that created this warning.\n   *                             PostCSS will set it automatically.\n   * @param {string} opts.word   A word inside a node’s string that should\n   *                             be highlighted as the source of the warning.\n   * @param {number} opts.index  An index inside a node’s string that should\n   *                             be highlighted as the source of the warning.\n   *\n   * @return {Warning} Created warning object.\n   *\n   * @example\n   * const plugin = postcss.plugin('postcss-deprecated', () => {\n   *   return (root, result) => {\n   *     root.walkDecls('bad', decl => {\n   *       decl.warn(result, 'Deprecated property bad')\n   *     })\n   *   }\n   * })\n   */\n\n\n  Node.prototype.warn = function warn(result, text, opts) {\n    var data = { node: this };\n    for (var i in opts) {\n      data[i] = opts[i];\n    }return result.warn(text, data);\n  };\n\n  /**\n   * Removes the node from its parent and cleans the parent properties\n   * from the node and its children.\n   *\n   * @example\n   * if (decl.prop.match(/^-webkit-/)) {\n   *   decl.remove()\n   * }\n   *\n   * @return {Node} Node to make calls chain.\n   */\n\n\n  Node.prototype.remove = function remove() {\n    if (this.parent) {\n      this.parent.removeChild(this);\n    }\n    this.parent = undefined;\n    return this;\n  };\n\n  /**\n   * Returns a CSS string representing the node.\n   *\n   * @param {stringifier|syntax} [stringifier] A syntax to use\n   *                                           in string generation.\n   *\n   * @return {string} CSS string of this node.\n   *\n   * @example\n   * postcss.rule({ selector: 'a' }).toString() //=> \"a {}\"\n   */\n\n\n  Node.prototype.toString = function toString() {\n    var stringifier = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _stringify2.default;\n\n    if (stringifier.stringify) stringifier = stringifier.stringify;\n    var result = '';\n    stringifier(this, function (i) {\n      result += i;\n    });\n    return result;\n  };\n\n  /**\n   * Returns an exact clone of the node.\n   *\n   * The resulting cloned node and its (cloned) children will retain\n   * code style properties.\n   *\n   * @param {object} [overrides] New properties to override in the clone.\n   *\n   * @example\n   * decl.raws.before    //=> \"\\n  \"\n   * const cloned = decl.clone({ prop: '-moz-' + decl.prop })\n   * cloned.raws.before  //=> \"\\n  \"\n   * cloned.toString()   //=> -moz-transform: scale(0)\n   *\n   * @return {Node} Clone of the node.\n   */\n\n\n  Node.prototype.clone = function clone() {\n    var overrides = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n\n    var cloned = cloneNode(this);\n    for (var name in overrides) {\n      cloned[name] = overrides[name];\n    }\n    return cloned;\n  };\n\n  /**\n   * Shortcut to clone the node and insert the resulting cloned node\n   * before the current node.\n   *\n   * @param {object} [overrides] Mew properties to override in the clone.\n   *\n   * @example\n   * decl.cloneBefore({ prop: '-moz-' + decl.prop })\n   *\n   * @return {Node} New node\n   */\n\n\n  Node.prototype.cloneBefore = function cloneBefore() {\n    var overrides = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n\n    var cloned = this.clone(overrides);\n    this.parent.insertBefore(this, cloned);\n    return cloned;\n  };\n\n  /**\n   * Shortcut to clone the node and insert the resulting cloned node\n   * after the current node.\n   *\n   * @param {object} [overrides] New properties to override in the clone.\n   *\n   * @return {Node} New node.\n   */\n\n\n  Node.prototype.cloneAfter = function cloneAfter() {\n    var overrides = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n\n    var cloned = this.clone(overrides);\n    this.parent.insertAfter(this, cloned);\n    return cloned;\n  };\n\n  /**\n   * Inserts node(s) before the current node and removes the current node.\n   *\n   * @param {...Node} nodes Mode(s) to replace current one.\n   *\n   * @example\n   * if (atrule.name === 'mixin') {\n   *   atrule.replaceWith(mixinRules[atrule.params])\n   * }\n   *\n   * @return {Node} Current node to methods chain.\n   */\n\n\n  Node.prototype.replaceWith = function replaceWith() {\n    if (this.parent) {\n      for (var _len = arguments.length, nodes = Array(_len), _key = 0; _key < _len; _key++) {\n        nodes[_key] = arguments[_key];\n      }\n\n      for (var _iterator = nodes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {\n        var _ref;\n\n        if (_isArray) {\n          if (_i >= _iterator.length) break;\n          _ref = _iterator[_i++];\n        } else {\n          _i = _iterator.next();\n          if (_i.done) break;\n          _ref = _i.value;\n        }\n\n        var node = _ref;\n\n        this.parent.insertBefore(this, node);\n      }\n\n      this.remove();\n    }\n\n    return this;\n  };\n\n  /**\n   * Returns the next child of the node’s parent.\n   * Returns `undefined` if the current node is the last child.\n   *\n   * @return {Node|undefined} Next node.\n   *\n   * @example\n   * if (comment.text === 'delete next') {\n   *   const next = comment.next()\n   *   if (next) {\n   *     next.remove()\n   *   }\n   * }\n   */\n\n\n  Node.prototype.next = function next() {\n    if (!this.parent) return undefined;\n    var index = this.parent.index(this);\n    return this.parent.nodes[index + 1];\n  };\n\n  /**\n   * Returns the previous child of the node’s parent.\n   * Returns `undefined` if the current node is the first child.\n   *\n   * @return {Node|undefined} Previous node.\n   *\n   * @example\n   * const annotation = decl.prev()\n   * if (annotation.type === 'comment') {\n   *   readAnnotation(annotation.text)\n   * }\n   */\n\n\n  Node.prototype.prev = function prev() {\n    if (!this.parent) return undefined;\n    var index = this.parent.index(this);\n    return this.parent.nodes[index - 1];\n  };\n\n  /**\n   * Insert new node before current node to current node’s parent.\n   *\n   * Just alias for `node.parent.insertBefore(node, add)`.\n   *\n   * @param {Node|object|string|Node[]} add New node.\n   *\n   * @return {Node} This node for methods chain.\n   *\n   * @example\n   * decl.before('content: \"\"')\n   */\n\n\n  Node.prototype.before = function before(add) {\n    this.parent.insertBefore(this, add);\n    return this;\n  };\n\n  /**\n   * Insert new node after current node to current node’s parent.\n   *\n   * Just alias for `node.parent.insertAfter(node, add)`.\n   *\n   * @param {Node|object|string|Node[]} add New node.\n   *\n   * @return {Node} This node for methods chain.\n   *\n   * @example\n   * decl.after('color: black')\n   */\n\n\n  Node.prototype.after = function after(add) {\n    this.parent.insertAfter(this, add);\n    return this;\n  };\n\n  Node.prototype.toJSON = function toJSON() {\n    var fixed = {};\n\n    for (var name in this) {\n      if (!this.hasOwnProperty(name)) continue;\n      if (name === 'parent') continue;\n      var value = this[name];\n\n      if (value instanceof Array) {\n        fixed[name] = value.map(function (i) {\n          if ((typeof i === 'undefined' ? 'undefined' : _typeof(i)) === 'object' && i.toJSON) {\n            return i.toJSON();\n          } else {\n            return i;\n          }\n        });\n      } else if ((typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object' && value.toJSON) {\n        fixed[name] = value.toJSON();\n      } else {\n        fixed[name] = value;\n      }\n    }\n\n    return fixed;\n  };\n\n  /**\n   * Returns a {@link Node#raws} value. If the node is missing\n   * the code style property (because the node was manually built or cloned),\n   * PostCSS will try to autodetect the code style property by looking\n   * at other nodes in the tree.\n   *\n   * @param {string} prop          Name of code style property.\n   * @param {string} [defaultType] Name of default value, it can be missed\n   *                               if the value is the same as prop.\n   *\n   * @example\n   * const root = postcss.parse('a { background: white }')\n   * root.nodes[0].append({ prop: 'color', value: 'black' })\n   * root.nodes[0].nodes[1].raws.before   //=> undefined\n   * root.nodes[0].nodes[1].raw('before') //=> ' '\n   *\n   * @return {string} Code style value.\n   */\n\n\n  Node.prototype.raw = function raw(prop, defaultType) {\n    var str = new _stringifier2.default();\n    return str.raw(this, prop, defaultType);\n  };\n\n  /**\n   * Finds the Root instance of the node’s tree.\n   *\n   * @example\n   * root.nodes[0].nodes[0].root() === root\n   *\n   * @return {Root} Root parent.\n   */\n\n\n  Node.prototype.root = function root() {\n    var result = this;\n    while (result.parent) {\n      result = result.parent;\n    }return result;\n  };\n\n  /**\n   * Clear the code style properties for the node and its children.\n   *\n   * @param {boolean} [keepBetween] Keep the raws.between symbols.\n   *\n   * @return {undefined}\n   *\n   * @example\n   * node.raws.before  //=> ' '\n   * node.cleanRaws()\n   * node.raws.before  //=> undefined\n   */\n\n\n  Node.prototype.cleanRaws = function cleanRaws(keepBetween) {\n    delete this.raws.before;\n    delete this.raws.after;\n    if (!keepBetween) delete this.raws.between;\n  };\n\n  Node.prototype.positionInside = function positionInside(index) {\n    var string = this.toString();\n    var column = this.source.start.column;\n    var line = this.source.start.line;\n\n    for (var i = 0; i < index; i++) {\n      if (string[i] === '\\n') {\n        column = 1;\n        line += 1;\n      } else {\n        column += 1;\n      }\n    }\n\n    return { line: line, column: column };\n  };\n\n  Node.prototype.positionBy = function positionBy(opts) {\n    var pos = this.source.start;\n    if (opts.index) {\n      pos = this.positionInside(opts.index);\n    } else if (opts.word) {\n      var index = this.toString().indexOf(opts.word);\n      if (index !== -1) pos = this.positionInside(index);\n    }\n    return pos;\n  };\n\n  /**\n   * @memberof Node#\n   * @member {string} type String representing the node’s type.\n   *                       Possible values are `root`, `atrule`, `rule`,\n   *                       `decl`, or `comment`.\n   *\n   * @example\n   * postcss.decl({ prop: 'color', value: 'black' }).type //=> 'decl'\n   */\n\n  /**\n   * @memberof Node#\n   * @member {Container} parent The node’s parent node.\n   *\n   * @example\n   * root.nodes[0].parent === root\n   */\n\n  /**\n   * @memberof Node#\n   * @member {source} source The input source of the node.\n   *\n   * The property is used in source map generation.\n   *\n   * If you create a node manually (e.g., with `postcss.decl()`),\n   * that node will not have a `source` property and will be absent\n   * from the source map. For this reason, the plugin developer should\n   * consider cloning nodes to create new ones (in which case the new node’s\n   * source will reference the original, cloned node) or setting\n   * the `source` property manually.\n   *\n   * ```js\n   * // Bad\n   * const prefixed = postcss.decl({\n   *   prop: '-moz-' + decl.prop,\n   *   value: decl.value\n   * })\n   *\n   * // Good\n   * const prefixed = decl.clone({ prop: '-moz-' + decl.prop })\n   * ```\n   *\n   * ```js\n   * if (atrule.name === 'add-link') {\n   *   const rule = postcss.rule({ selector: 'a', source: atrule.source })\n   *   atrule.parent.insertBefore(atrule, rule)\n   * }\n   * ```\n   *\n   * @example\n   * decl.source.input.from //=> '/home/ai/a.sass'\n   * decl.source.start      //=> { line: 10, column: 2 }\n   * decl.source.end        //=> { line: 10, column: 12 }\n   */\n\n  /**\n   * @memberof Node#\n   * @member {object} raws Information to generate byte-to-byte equal\n   *                       node string as it was in the origin input.\n   *\n   * Every parser saves its own properties,\n   * but the default CSS parser uses:\n   *\n   * * `before`: the space symbols before the node. It also stores `*`\n   *   and `_` symbols before the declaration (IE hack).\n   * * `after`: the space symbols after the last child of the node\n   *   to the end of the node.\n   * * `between`: the symbols between the property and value\n   *   for declarations, selector and `{` for rules, or last parameter\n   *   and `{` for at-rules.\n   * * `semicolon`: contains true if the last child has\n   *   an (optional) semicolon.\n   * * `afterName`: the space between the at-rule name and its parameters.\n   * * `left`: the space symbols between `/*` and the comment’s text.\n   * * `right`: the space symbols between the comment’s text\n   *   and <code>*&#47;</code>.\n   * * `important`: the content of the important statement,\n   *   if it is not just `!important`.\n   *\n   * PostCSS cleans selectors, declaration values and at-rule parameters\n   * from comments and extra spaces, but it stores origin content in raws\n   * properties. As such, if you don’t change a declaration’s value,\n   * PostCSS will use the raw value with comments.\n   *\n   * @example\n   * const root = postcss.parse('a {\\n  color:black\\n}')\n   * root.first.first.raws //=> { before: '\\n  ', between: ':' }\n   */\n\n\n  return Node;\n}();\n\nexports.default = Node;\n\n/**\n * @typedef {object} position\n * @property {number} line   Source line in file.\n * @property {number} column Source column in file.\n */\n\n/**\n * @typedef {object} source\n * @property {Input} input    {@link Input} with input file\n * @property {position} start The starting position of the node’s source.\n * @property {position} end   The ending position of the node’s source.\n */\n\nmodule.exports = exports['default'];\n//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["node.es6"],"names":["cloneNode","obj","parent","cloned","constructor","i","hasOwnProperty","value","type","Array","map","j","Node","defaults","raws","process","env","NODE_ENV","Error","JSON","stringify","name","error","message","opts","source","pos","positionBy","input","line","column","CssSyntaxError","warn","result","text","data","node","remove","removeChild","undefined","toString","stringifier","clone","overrides","cloneBefore","insertBefore","cloneAfter","insertAfter","replaceWith","nodes","next","index","prev","before","add","after","toJSON","fixed","raw","prop","defaultType","str","Stringifier","root","cleanRaws","keepBetween","between","positionInside","string","start","word","indexOf"],"mappings":"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","file":"node.js","sourcesContent":["import CssSyntaxError from './css-syntax-error'\nimport Stringifier from './stringifier'\nimport stringify from './stringify'\n\nfunction cloneNode (obj, parent) {\n  let cloned = new obj.constructor()\n\n  for (let i in obj) {\n    if (!obj.hasOwnProperty(i)) continue\n    let value = obj[i]\n    let type = typeof value\n\n    if (i === 'parent' && type === 'object') {\n      if (parent) cloned[i] = parent\n    } else if (i === 'source') {\n      cloned[i] = value\n    } else if (value instanceof Array) {\n      cloned[i] = value.map(j => cloneNode(j, cloned))\n    } else {\n      if (type === 'object' && value !== null) value = cloneNode(value)\n      cloned[i] = value\n    }\n  }\n\n  return cloned\n}\n\n/**\n * All node classes inherit the following common methods.\n *\n * @abstract\n */\nclass Node {\n  /**\n   * @param {object} [defaults] Value for node properties.\n   */\n  constructor (defaults = { }) {\n    this.raws = { }\n    if (process.env.NODE_ENV !== 'production') {\n      if (typeof defaults !== 'object' && typeof defaults !== 'undefined') {\n        throw new Error(\n          'PostCSS nodes constructor accepts object, not ' +\n          JSON.stringify(defaults)\n        )\n      }\n    }\n    for (let name in defaults) {\n      this[name] = defaults[name]\n    }\n  }\n\n  /**\n   * Returns a `CssSyntaxError` instance containing the original position\n   * of the node in the source, showing line and column numbers and also\n   * a small excerpt to facilitate debugging.\n   *\n   * If present, an input source map will be used to get the original position\n   * of the source, even from a previous compilation step\n   * (e.g., from Sass compilation).\n   *\n   * This method produces very useful error messages.\n   *\n   * @param {string} message     Error description.\n   * @param {object} [opts]      Options.\n   * @param {string} opts.plugin Plugin name that created this error.\n   *                             PostCSS will set it automatically.\n   * @param {string} opts.word   A word inside a node’s string that should\n   *                             be highlighted as the source of the error.\n   * @param {number} opts.index  An index inside a node’s string that should\n   *                             be highlighted as the source of the error.\n   *\n   * @return {CssSyntaxError} Error object to throw it.\n   *\n   * @example\n   * if (!variables[name]) {\n   *   throw decl.error('Unknown variable ' + name, { word: name })\n   *   // CssSyntaxError: postcss-vars:a.sass:4:3: Unknown variable $black\n   *   //   color: $black\n   *   // a\n   *   //          ^\n   *   //   background: white\n   * }\n   */\n  error (message, opts = { }) {\n    if (this.source) {\n      let pos = this.positionBy(opts)\n      return this.source.input.error(message, pos.line, pos.column, opts)\n    } else {\n      return new CssSyntaxError(message)\n    }\n  }\n\n  /**\n   * This method is provided as a convenience wrapper for {@link Result#warn}.\n   *\n   * @param {Result} result      The {@link Result} instance\n   *                             that will receive the warning.\n   * @param {string} text        Warning message.\n   * @param {object} [opts]      Options\n   * @param {string} opts.plugin Plugin name that created this warning.\n   *                             PostCSS will set it automatically.\n   * @param {string} opts.word   A word inside a node’s string that should\n   *                             be highlighted as the source of the warning.\n   * @param {number} opts.index  An index inside a node’s string that should\n   *                             be highlighted as the source of the warning.\n   *\n   * @return {Warning} Created warning object.\n   *\n   * @example\n   * const plugin = postcss.plugin('postcss-deprecated', () => {\n   *   return (root, result) => {\n   *     root.walkDecls('bad', decl => {\n   *       decl.warn(result, 'Deprecated property bad')\n   *     })\n   *   }\n   * })\n   */\n  warn (result, text, opts) {\n    let data = { node: this }\n    for (let i in opts) data[i] = opts[i]\n    return result.warn(text, data)\n  }\n\n  /**\n   * Removes the node from its parent and cleans the parent properties\n   * from the node and its children.\n   *\n   * @example\n   * if (decl.prop.match(/^-webkit-/)) {\n   *   decl.remove()\n   * }\n   *\n   * @return {Node} Node to make calls chain.\n   */\n  remove () {\n    if (this.parent) {\n      this.parent.removeChild(this)\n    }\n    this.parent = undefined\n    return this\n  }\n\n  /**\n   * Returns a CSS string representing the node.\n   *\n   * @param {stringifier|syntax} [stringifier] A syntax to use\n   *                                           in string generation.\n   *\n   * @return {string} CSS string of this node.\n   *\n   * @example\n   * postcss.rule({ selector: 'a' }).toString() //=> \"a {}\"\n   */\n  toString (stringifier = stringify) {\n    if (stringifier.stringify) stringifier = stringifier.stringify\n    let result = ''\n    stringifier(this, i => {\n      result += i\n    })\n    return result\n  }\n\n  /**\n   * Returns an exact clone of the node.\n   *\n   * The resulting cloned node and its (cloned) children will retain\n   * code style properties.\n   *\n   * @param {object} [overrides] New properties to override in the clone.\n   *\n   * @example\n   * decl.raws.before    //=> \"\\n  \"\n   * const cloned = decl.clone({ prop: '-moz-' + decl.prop })\n   * cloned.raws.before  //=> \"\\n  \"\n   * cloned.toString()   //=> -moz-transform: scale(0)\n   *\n   * @return {Node} Clone of the node.\n   */\n  clone (overrides = { }) {\n    let cloned = cloneNode(this)\n    for (let name in overrides) {\n      cloned[name] = overrides[name]\n    }\n    return cloned\n  }\n\n  /**\n   * Shortcut to clone the node and insert the resulting cloned node\n   * before the current node.\n   *\n   * @param {object} [overrides] Mew properties to override in the clone.\n   *\n   * @example\n   * decl.cloneBefore({ prop: '-moz-' + decl.prop })\n   *\n   * @return {Node} New node\n   */\n  cloneBefore (overrides = { }) {\n    let cloned = this.clone(overrides)\n    this.parent.insertBefore(this, cloned)\n    return cloned\n  }\n\n  /**\n   * Shortcut to clone the node and insert the resulting cloned node\n   * after the current node.\n   *\n   * @param {object} [overrides] New properties to override in the clone.\n   *\n   * @return {Node} New node.\n   */\n  cloneAfter (overrides = { }) {\n    let cloned = this.clone(overrides)\n    this.parent.insertAfter(this, cloned)\n    return cloned\n  }\n\n  /**\n   * Inserts node(s) before the current node and removes the current node.\n   *\n   * @param {...Node} nodes Mode(s) to replace current one.\n   *\n   * @example\n   * if (atrule.name === 'mixin') {\n   *   atrule.replaceWith(mixinRules[atrule.params])\n   * }\n   *\n   * @return {Node} Current node to methods chain.\n   */\n  replaceWith (...nodes) {\n    if (this.parent) {\n      for (let node of nodes) {\n        this.parent.insertBefore(this, node)\n      }\n\n      this.remove()\n    }\n\n    return this\n  }\n\n  /**\n   * Returns the next child of the node’s parent.\n   * Returns `undefined` if the current node is the last child.\n   *\n   * @return {Node|undefined} Next node.\n   *\n   * @example\n   * if (comment.text === 'delete next') {\n   *   const next = comment.next()\n   *   if (next) {\n   *     next.remove()\n   *   }\n   * }\n   */\n  next () {\n    if (!this.parent) return undefined\n    let index = this.parent.index(this)\n    return this.parent.nodes[index + 1]\n  }\n\n  /**\n   * Returns the previous child of the node’s parent.\n   * Returns `undefined` if the current node is the first child.\n   *\n   * @return {Node|undefined} Previous node.\n   *\n   * @example\n   * const annotation = decl.prev()\n   * if (annotation.type === 'comment') {\n   *   readAnnotation(annotation.text)\n   * }\n   */\n  prev () {\n    if (!this.parent) return undefined\n    let index = this.parent.index(this)\n    return this.parent.nodes[index - 1]\n  }\n\n  /**\n   * Insert new node before current node to current node’s parent.\n   *\n   * Just alias for `node.parent.insertBefore(node, add)`.\n   *\n   * @param {Node|object|string|Node[]} add New node.\n   *\n   * @return {Node} This node for methods chain.\n   *\n   * @example\n   * decl.before('content: \"\"')\n   */\n  before (add) {\n    this.parent.insertBefore(this, add)\n    return this\n  }\n\n  /**\n   * Insert new node after current node to current node’s parent.\n   *\n   * Just alias for `node.parent.insertAfter(node, add)`.\n   *\n   * @param {Node|object|string|Node[]} add New node.\n   *\n   * @return {Node} This node for methods chain.\n   *\n   * @example\n   * decl.after('color: black')\n   */\n  after (add) {\n    this.parent.insertAfter(this, add)\n    return this\n  }\n\n  toJSON () {\n    let fixed = { }\n\n    for (let name in this) {\n      if (!this.hasOwnProperty(name)) continue\n      if (name === 'parent') continue\n      let value = this[name]\n\n      if (value instanceof Array) {\n        fixed[name] = value.map(i => {\n          if (typeof i === 'object' && i.toJSON) {\n            return i.toJSON()\n          } else {\n            return i\n          }\n        })\n      } else if (typeof value === 'object' && value.toJSON) {\n        fixed[name] = value.toJSON()\n      } else {\n        fixed[name] = value\n      }\n    }\n\n    return fixed\n  }\n\n  /**\n   * Returns a {@link Node#raws} value. If the node is missing\n   * the code style property (because the node was manually built or cloned),\n   * PostCSS will try to autodetect the code style property by looking\n   * at other nodes in the tree.\n   *\n   * @param {string} prop          Name of code style property.\n   * @param {string} [defaultType] Name of default value, it can be missed\n   *                               if the value is the same as prop.\n   *\n   * @example\n   * const root = postcss.parse('a { background: white }')\n   * root.nodes[0].append({ prop: 'color', value: 'black' })\n   * root.nodes[0].nodes[1].raws.before   //=> undefined\n   * root.nodes[0].nodes[1].raw('before') //=> ' '\n   *\n   * @return {string} Code style value.\n   */\n  raw (prop, defaultType) {\n    let str = new Stringifier()\n    return str.raw(this, prop, defaultType)\n  }\n\n  /**\n   * Finds the Root instance of the node’s tree.\n   *\n   * @example\n   * root.nodes[0].nodes[0].root() === root\n   *\n   * @return {Root} Root parent.\n   */\n  root () {\n    let result = this\n    while (result.parent) result = result.parent\n    return result\n  }\n\n  /**\n   * Clear the code style properties for the node and its children.\n   *\n   * @param {boolean} [keepBetween] Keep the raws.between symbols.\n   *\n   * @return {undefined}\n   *\n   * @example\n   * node.raws.before  //=> ' '\n   * node.cleanRaws()\n   * node.raws.before  //=> undefined\n   */\n  cleanRaws (keepBetween) {\n    delete this.raws.before\n    delete this.raws.after\n    if (!keepBetween) delete this.raws.between\n  }\n\n  positionInside (index) {\n    let string = this.toString()\n    let column = this.source.start.column\n    let line = this.source.start.line\n\n    for (let i = 0; i < index; i++) {\n      if (string[i] === '\\n') {\n        column = 1\n        line += 1\n      } else {\n        column += 1\n      }\n    }\n\n    return { line, column }\n  }\n\n  positionBy (opts) {\n    let pos = this.source.start\n    if (opts.index) {\n      pos = this.positionInside(opts.index)\n    } else if (opts.word) {\n      let index = this.toString().indexOf(opts.word)\n      if (index !== -1) pos = this.positionInside(index)\n    }\n    return pos\n  }\n\n  /**\n   * @memberof Node#\n   * @member {string} type String representing the node’s type.\n   *                       Possible values are `root`, `atrule`, `rule`,\n   *                       `decl`, or `comment`.\n   *\n   * @example\n   * postcss.decl({ prop: 'color', value: 'black' }).type //=> 'decl'\n   */\n\n  /**\n   * @memberof Node#\n   * @member {Container} parent The node’s parent node.\n   *\n   * @example\n   * root.nodes[0].parent === root\n   */\n\n  /**\n   * @memberof Node#\n   * @member {source} source The input source of the node.\n   *\n   * The property is used in source map generation.\n   *\n   * If you create a node manually (e.g., with `postcss.decl()`),\n   * that node will not have a `source` property and will be absent\n   * from the source map. For this reason, the plugin developer should\n   * consider cloning nodes to create new ones (in which case the new node’s\n   * source will reference the original, cloned node) or setting\n   * the `source` property manually.\n   *\n   * ```js\n   * // Bad\n   * const prefixed = postcss.decl({\n   *   prop: '-moz-' + decl.prop,\n   *   value: decl.value\n   * })\n   *\n   * // Good\n   * const prefixed = decl.clone({ prop: '-moz-' + decl.prop })\n   * ```\n   *\n   * ```js\n   * if (atrule.name === 'add-link') {\n   *   const rule = postcss.rule({ selector: 'a', source: atrule.source })\n   *   atrule.parent.insertBefore(atrule, rule)\n   * }\n   * ```\n   *\n   * @example\n   * decl.source.input.from //=> '/home/ai/a.sass'\n   * decl.source.start      //=> { line: 10, column: 2 }\n   * decl.source.end        //=> { line: 10, column: 12 }\n   */\n\n  /**\n   * @memberof Node#\n   * @member {object} raws Information to generate byte-to-byte equal\n   *                       node string as it was in the origin input.\n   *\n   * Every parser saves its own properties,\n   * but the default CSS parser uses:\n   *\n   * * `before`: the space symbols before the node. It also stores `*`\n   *   and `_` symbols before the declaration (IE hack).\n   * * `after`: the space symbols after the last child of the node\n   *   to the end of the node.\n   * * `between`: the symbols between the property and value\n   *   for declarations, selector and `{` for rules, or last parameter\n   *   and `{` for at-rules.\n   * * `semicolon`: contains true if the last child has\n   *   an (optional) semicolon.\n   * * `afterName`: the space between the at-rule name and its parameters.\n   * * `left`: the space symbols between `/*` and the comment’s text.\n   * * `right`: the space symbols between the comment’s text\n   *   and <code>*&#47;</code>.\n   * * `important`: the content of the important statement,\n   *   if it is not just `!important`.\n   *\n   * PostCSS cleans selectors, declaration values and at-rule parameters\n   * from comments and extra spaces, but it stores origin content in raws\n   * properties. As such, if you don’t change a declaration’s value,\n   * PostCSS will use the raw value with comments.\n   *\n   * @example\n   * const root = postcss.parse('a {\\n  color:black\\n}')\n   * root.first.first.raws //=> { before: '\\n  ', between: ':' }\n   */\n}\n\nexport default Node\n\n/**\n * @typedef {object} position\n * @property {number} line   Source line in file.\n * @property {number} column Source column in file.\n */\n\n/**\n * @typedef {object} source\n * @property {Input} input    {@link Input} with input file\n * @property {position} start The starting position of the node’s source.\n * @property {position} end   The ending position of the node’s source.\n */\n"]}\n","'use strict';\n\nexports.__esModule = true;\n\nvar _stringifier = require('./stringifier');\n\nvar _stringifier2 = _interopRequireDefault(_stringifier);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction stringify(node, builder) {\n  var str = new _stringifier2.default(builder);\n  str.stringify(node);\n}\n\nexports.default = stringify;\nmodule.exports = exports['default'];\n//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0cmluZ2lmeS5lczYiXSwibmFtZXMiOlsic3RyaW5naWZ5Iiwibm9kZSIsImJ1aWxkZXIiLCJzdHIiLCJTdHJpbmdpZmllciJdLCJtYXBwaW5ncyI6Ijs7OztBQUFBOzs7Ozs7QUFFQSxTQUFTQSxTQUFULENBQW9CQyxJQUFwQixFQUEwQkMsT0FBMUIsRUFBbUM7QUFDakMsTUFBSUMsTUFBTSxJQUFJQyxxQkFBSixDQUFnQkYsT0FBaEIsQ0FBVjtBQUNBQyxNQUFJSCxTQUFKLENBQWNDLElBQWQ7QUFDRDs7a0JBRWNELFMiLCJmaWxlIjoic3RyaW5naWZ5LmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFN0cmluZ2lmaWVyIGZyb20gJy4vc3RyaW5naWZpZXInXG5cbmZ1bmN0aW9uIHN0cmluZ2lmeSAobm9kZSwgYnVpbGRlcikge1xuICBsZXQgc3RyID0gbmV3IFN0cmluZ2lmaWVyKGJ1aWxkZXIpXG4gIHN0ci5zdHJpbmdpZnkobm9kZSlcbn1cblxuZXhwb3J0IGRlZmF1bHQgc3RyaW5naWZ5XG4iXX0=\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// resolves . and .. elements in a path array with directory names there\n// must be no slashes, empty elements, or device names (c:\\) in the array\n// (so also no leading and trailing slashes - it does not distinguish\n// relative and absolute paths)\nfunction normalizeArray(parts, allowAboveRoot) {\n  // if the path tries to go above the root, `up` ends up > 0\n  var up = 0;\n  for (var i = parts.length - 1; i >= 0; i--) {\n    var last = parts[i];\n    if (last === '.') {\n      parts.splice(i, 1);\n    } else if (last === '..') {\n      parts.splice(i, 1);\n      up++;\n    } else if (up) {\n      parts.splice(i, 1);\n      up--;\n    }\n  }\n\n  // if the path is allowed to go above the root, restore leading ..s\n  if (allowAboveRoot) {\n    for (; up--; up) {\n      parts.unshift('..');\n    }\n  }\n\n  return parts;\n}\n\n// Split a filename into [root, dir, basename, ext], unix version\n// 'root' is just a slash, or nothing.\nvar splitPathRe =\n    /^(\\/?|)([\\s\\S]*?)((?:\\.{1,2}|[^\\/]+?|)(\\.[^.\\/]*|))(?:[\\/]*)$/;\nvar splitPath = function(filename) {\n  return splitPathRe.exec(filename).slice(1);\n};\n\n// path.resolve([from ...], to)\n// posix version\nexports.resolve = function() {\n  var resolvedPath = '',\n      resolvedAbsolute = false;\n\n  for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n    var path = (i >= 0) ? arguments[i] : process.cwd();\n\n    // Skip empty and invalid entries\n    if (typeof path !== 'string') {\n      throw new TypeError('Arguments to path.resolve must be strings');\n    } else if (!path) {\n      continue;\n    }\n\n    resolvedPath = path + '/' + resolvedPath;\n    resolvedAbsolute = path.charAt(0) === '/';\n  }\n\n  // At this point the path should be resolved to a full absolute path, but\n  // handle relative paths to be safe (might happen when process.cwd() fails)\n\n  // Normalize the path\n  resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {\n    return !!p;\n  }), !resolvedAbsolute).join('/');\n\n  return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';\n};\n\n// path.normalize(path)\n// posix version\nexports.normalize = function(path) {\n  var isAbsolute = exports.isAbsolute(path),\n      trailingSlash = substr(path, -1) === '/';\n\n  // Normalize the path\n  path = normalizeArray(filter(path.split('/'), function(p) {\n    return !!p;\n  }), !isAbsolute).join('/');\n\n  if (!path && !isAbsolute) {\n    path = '.';\n  }\n  if (path && trailingSlash) {\n    path += '/';\n  }\n\n  return (isAbsolute ? '/' : '') + path;\n};\n\n// posix version\nexports.isAbsolute = function(path) {\n  return path.charAt(0) === '/';\n};\n\n// posix version\nexports.join = function() {\n  var paths = Array.prototype.slice.call(arguments, 0);\n  return exports.normalize(filter(paths, function(p, index) {\n    if (typeof p !== 'string') {\n      throw new TypeError('Arguments to path.join must be strings');\n    }\n    return p;\n  }).join('/'));\n};\n\n\n// path.relative(from, to)\n// posix version\nexports.relative = function(from, to) {\n  from = exports.resolve(from).substr(1);\n  to = exports.resolve(to).substr(1);\n\n  function trim(arr) {\n    var start = 0;\n    for (; start < arr.length; start++) {\n      if (arr[start] !== '') break;\n    }\n\n    var end = arr.length - 1;\n    for (; end >= 0; end--) {\n      if (arr[end] !== '') break;\n    }\n\n    if (start > end) return [];\n    return arr.slice(start, end - start + 1);\n  }\n\n  var fromParts = trim(from.split('/'));\n  var toParts = trim(to.split('/'));\n\n  var length = Math.min(fromParts.length, toParts.length);\n  var samePartsLength = length;\n  for (var i = 0; i < length; i++) {\n    if (fromParts[i] !== toParts[i]) {\n      samePartsLength = i;\n      break;\n    }\n  }\n\n  var outputParts = [];\n  for (var i = samePartsLength; i < fromParts.length; i++) {\n    outputParts.push('..');\n  }\n\n  outputParts = outputParts.concat(toParts.slice(samePartsLength));\n\n  return outputParts.join('/');\n};\n\nexports.sep = '/';\nexports.delimiter = ':';\n\nexports.dirname = function(path) {\n  var result = splitPath(path),\n      root = result[0],\n      dir = result[1];\n\n  if (!root && !dir) {\n    // No dirname whatsoever\n    return '.';\n  }\n\n  if (dir) {\n    // It has a dirname, strip trailing slash\n    dir = dir.substr(0, dir.length - 1);\n  }\n\n  return root + dir;\n};\n\n\nexports.basename = function(path, ext) {\n  var f = splitPath(path)[2];\n  // TODO: make this comparison case-insensitive on windows?\n  if (ext && f.substr(-1 * ext.length) === ext) {\n    f = f.substr(0, f.length - ext.length);\n  }\n  return f;\n};\n\n\nexports.extname = function(path) {\n  return splitPath(path)[3];\n};\n\nfunction filter (xs, f) {\n    if (xs.filter) return xs.filter(f);\n    var res = [];\n    for (var i = 0; i < xs.length; i++) {\n        if (f(xs[i], i, xs)) res.push(xs[i]);\n    }\n    return res;\n}\n\n// String.prototype.substr - negative index don't work in IE8\nvar substr = 'ab'.substr(-1) === 'b'\n    ? function (str, start, len) { return str.substr(start, len) }\n    : function (str, start, len) {\n        if (start < 0) start = str.length + start;\n        return str.substr(start, len);\n    }\n;\n","'use strict';\n\nexports.__esModule = true;\n\nvar _parser = require('./parser');\n\nvar _parser2 = _interopRequireDefault(_parser);\n\nvar _input = require('./input');\n\nvar _input2 = _interopRequireDefault(_input);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction parse(css, opts) {\n  var input = new _input2.default(css, opts);\n  var parser = new _parser2.default(input);\n  try {\n    parser.parse();\n  } catch (e) {\n    if (process.env.NODE_ENV !== 'production') {\n      if (e.name === 'CssSyntaxError' && opts && opts.from) {\n        if (/\\.scss$/i.test(opts.from)) {\n          e.message += '\\nYou tried to parse SCSS with ' + 'the standard CSS parser; ' + 'try again with the postcss-scss parser';\n        } else if (/\\.sass/i.test(opts.from)) {\n          e.message += '\\nYou tried to parse Sass with ' + 'the standard CSS parser; ' + 'try again with the postcss-sass parser';\n        } else if (/\\.less$/i.test(opts.from)) {\n          e.message += '\\nYou tried to parse Less with ' + 'the standard CSS parser; ' + 'try again with the postcss-less parser';\n        }\n      }\n    }\n    throw e;\n  }\n\n  return parser.root;\n}\n\nexports.default = parse;\nmodule.exports = exports['default'];\n//# sourceMappingURL=data:application/json;charset=utf8;base64,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\n","'use strict';\n\nexports.__esModule = true;\n\nvar _node = require('./node');\n\nvar _node2 = _interopRequireDefault(_node);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\n/**\n * Represents a comment between declarations or statements (rule and at-rules).\n *\n * Comments inside selectors, at-rule parameters, or declaration values\n * will be stored in the `raws` properties explained above.\n *\n * @extends Node\n */\nvar Comment = function (_Node) {\n  _inherits(Comment, _Node);\n\n  function Comment(defaults) {\n    _classCallCheck(this, Comment);\n\n    var _this = _possibleConstructorReturn(this, _Node.call(this, defaults));\n\n    _this.type = 'comment';\n    return _this;\n  }\n\n  /**\n   * @memberof Comment#\n   * @member {string} text The comment’s text.\n   */\n\n  /**\n   * @memberof Comment#\n   * @member {object} raws Information to generate byte-to-byte equal\n   *                       node string as it was in the origin input.\n   *\n   * Every parser saves its own properties,\n   * but the default CSS parser uses:\n   *\n   * * `before`: the space symbols before the node.\n   * * `left`: the space symbols between `/*` and the comment’s text.\n   * * `right`: the space symbols between the comment’s text.\n   */\n\n\n  return Comment;\n}(_node2.default);\n\nexports.default = Comment;\nmodule.exports = exports['default'];\n//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbW1lbnQuZXM2Il0sIm5hbWVzIjpbIkNvbW1lbnQiLCJkZWZhdWx0cyIsInR5cGUiLCJOb2RlIl0sIm1hcHBpbmdzIjoiOzs7O0FBQUE7Ozs7Ozs7Ozs7OztBQUVBOzs7Ozs7OztJQVFNQSxPOzs7QUFDSixtQkFBYUMsUUFBYixFQUF1QjtBQUFBOztBQUFBLGlEQUNyQixpQkFBTUEsUUFBTixDQURxQjs7QUFFckIsVUFBS0MsSUFBTCxHQUFZLFNBQVo7QUFGcUI7QUFHdEI7O0FBRUQ7Ozs7O0FBS0E7Ozs7Ozs7Ozs7Ozs7OztFQVhvQkMsYzs7a0JBeUJQSCxPIiwiZmlsZSI6ImNvbW1lbnQuanMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgTm9kZSBmcm9tICcuL25vZGUnXG5cbi8qKlxuICogUmVwcmVzZW50cyBhIGNvbW1lbnQgYmV0d2VlbiBkZWNsYXJhdGlvbnMgb3Igc3RhdGVtZW50cyAocnVsZSBhbmQgYXQtcnVsZXMpLlxuICpcbiAqIENvbW1lbnRzIGluc2lkZSBzZWxlY3RvcnMsIGF0LXJ1bGUgcGFyYW1ldGVycywgb3IgZGVjbGFyYXRpb24gdmFsdWVzXG4gKiB3aWxsIGJlIHN0b3JlZCBpbiB0aGUgYHJhd3NgIHByb3BlcnRpZXMgZXhwbGFpbmVkIGFib3ZlLlxuICpcbiAqIEBleHRlbmRzIE5vZGVcbiAqL1xuY2xhc3MgQ29tbWVudCBleHRlbmRzIE5vZGUge1xuICBjb25zdHJ1Y3RvciAoZGVmYXVsdHMpIHtcbiAgICBzdXBlcihkZWZhdWx0cylcbiAgICB0aGlzLnR5cGUgPSAnY29tbWVudCdcbiAgfVxuXG4gIC8qKlxuICAgKiBAbWVtYmVyb2YgQ29tbWVudCNcbiAgICogQG1lbWJlciB7c3RyaW5nfSB0ZXh0IFRoZSBjb21tZW504oCZcyB0ZXh0LlxuICAgKi9cblxuICAvKipcbiAgICogQG1lbWJlcm9mIENvbW1lbnQjXG4gICAqIEBtZW1iZXIge29iamVjdH0gcmF3cyBJbmZvcm1hdGlvbiB0byBnZW5lcmF0ZSBieXRlLXRvLWJ5dGUgZXF1YWxcbiAgICogICAgICAgICAgICAgICAgICAgICAgIG5vZGUgc3RyaW5nIGFzIGl0IHdhcyBpbiB0aGUgb3JpZ2luIGlucHV0LlxuICAgKlxuICAgKiBFdmVyeSBwYXJzZXIgc2F2ZXMgaXRzIG93biBwcm9wZXJ0aWVzLFxuICAgKiBidXQgdGhlIGRlZmF1bHQgQ1NTIHBhcnNlciB1c2VzOlxuICAgKlxuICAgKiAqIGBiZWZvcmVgOiB0aGUgc3BhY2Ugc3ltYm9scyBiZWZvcmUgdGhlIG5vZGUuXG4gICAqICogYGxlZnRgOiB0aGUgc3BhY2Ugc3ltYm9scyBiZXR3ZWVuIGAvKmAgYW5kIHRoZSBjb21tZW504oCZcyB0ZXh0LlxuICAgKiAqIGByaWdodGA6IHRoZSBzcGFjZSBzeW1ib2xzIGJldHdlZW4gdGhlIGNvbW1lbnTigJlzIHRleHQuXG4gICAqL1xufVxuXG5leHBvcnQgZGVmYXVsdCBDb21tZW50XG4iXX0=\n","'use strict';\n\nexports.__esModule = true;\n\nvar _container = require('./container');\n\nvar _container2 = _interopRequireDefault(_container);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\n/**\n * Represents an at-rule.\n *\n * If it’s followed in the CSS by a {} block, this node will have\n * a nodes property representing its children.\n *\n * @extends Container\n *\n * @example\n * const root = postcss.parse('@charset \"UTF-8\"; @media print {}')\n *\n * const charset = root.first\n * charset.type  //=> 'atrule'\n * charset.nodes //=> undefined\n *\n * const media = root.last\n * media.nodes   //=> []\n */\nvar AtRule = function (_Container) {\n  _inherits(AtRule, _Container);\n\n  function AtRule(defaults) {\n    _classCallCheck(this, AtRule);\n\n    var _this = _possibleConstructorReturn(this, _Container.call(this, defaults));\n\n    _this.type = 'atrule';\n    return _this;\n  }\n\n  AtRule.prototype.append = function append() {\n    var _Container$prototype$;\n\n    if (!this.nodes) this.nodes = [];\n\n    for (var _len = arguments.length, children = Array(_len), _key = 0; _key < _len; _key++) {\n      children[_key] = arguments[_key];\n    }\n\n    return (_Container$prototype$ = _Container.prototype.append).call.apply(_Container$prototype$, [this].concat(children));\n  };\n\n  AtRule.prototype.prepend = function prepend() {\n    var _Container$prototype$2;\n\n    if (!this.nodes) this.nodes = [];\n\n    for (var _len2 = arguments.length, children = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n      children[_key2] = arguments[_key2];\n    }\n\n    return (_Container$prototype$2 = _Container.prototype.prepend).call.apply(_Container$prototype$2, [this].concat(children));\n  };\n\n  /**\n   * @memberof AtRule#\n   * @member {string} name The at-rule’s name immediately follows the `@`.\n   *\n   * @example\n   * const root  = postcss.parse('@media print {}')\n   * media.name //=> 'media'\n   * const media = root.first\n   */\n\n  /**\n   * @memberof AtRule#\n   * @member {string} params The at-rule’s parameters, the values\n   *                         that follow the at-rule’s name but precede\n   *                         any {} block.\n   *\n   * @example\n   * const root  = postcss.parse('@media print, screen {}')\n   * const media = root.first\n   * media.params //=> 'print, screen'\n   */\n\n  /**\n   * @memberof AtRule#\n   * @member {object} raws Information to generate byte-to-byte equal\n   *                        node string as it was in the origin input.\n   *\n   * Every parser saves its own properties,\n   * but the default CSS parser uses:\n   *\n   * * `before`: the space symbols before the node. It also stores `*`\n   *   and `_` symbols before the declaration (IE hack).\n   * * `after`: the space symbols after the last child of the node\n   *   to the end of the node.\n   * * `between`: the symbols between the property and value\n   *   for declarations, selector and `{` for rules, or last parameter\n   *   and `{` for at-rules.\n   * * `semicolon`: contains true if the last child has\n   *   an (optional) semicolon.\n   * * `afterName`: the space between the at-rule name and its parameters.\n   *\n   * PostCSS cleans at-rule parameters from comments and extra spaces,\n   * but it stores origin content in raws properties.\n   * As such, if you don’t change a declaration’s value,\n   * PostCSS will use the raw value with comments.\n   *\n   * @example\n   * const root = postcss.parse('  @media\\nprint {\\n}')\n   * root.first.first.raws //=> { before: '  ',\n   *                       //     between: ' ',\n   *                       //     afterName: '\\n',\n   *                       //     after: '\\n' }\n   */\n\n\n  return AtRule;\n}(_container2.default);\n\nexports.default = AtRule;\nmodule.exports = exports['default'];\n//# sourceMappingURL=data:application/json;charset=utf8;base64,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\n","'use strict';\n\nexports.__esModule = true;\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _declaration = require('./declaration');\n\nvar _declaration2 = _interopRequireDefault(_declaration);\n\nvar _comment = require('./comment');\n\nvar _comment2 = _interopRequireDefault(_comment);\n\nvar _node = require('./node');\n\nvar _node2 = _interopRequireDefault(_node);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nfunction cleanSource(nodes) {\n  return nodes.map(function (i) {\n    if (i.nodes) i.nodes = cleanSource(i.nodes);\n    delete i.source;\n    return i;\n  });\n}\n\n/**\n * The {@link Root}, {@link AtRule}, and {@link Rule} container nodes\n * inherit some common methods to help work with their children.\n *\n * Note that all containers can store any content. If you write a rule inside\n * a rule, PostCSS will parse it.\n *\n * @extends Node\n * @abstract\n */\n\nvar Container = function (_Node) {\n  _inherits(Container, _Node);\n\n  function Container() {\n    _classCallCheck(this, Container);\n\n    return _possibleConstructorReturn(this, _Node.apply(this, arguments));\n  }\n\n  Container.prototype.push = function push(child) {\n    child.parent = this;\n    this.nodes.push(child);\n    return this;\n  };\n\n  /**\n   * Iterates through the container’s immediate children,\n   * calling `callback` for each child.\n   *\n   * Returning `false` in the callback will break iteration.\n   *\n   * This method only iterates through the container’s immediate children.\n   * If you need to recursively iterate through all the container’s descendant\n   * nodes, use {@link Container#walk}.\n   *\n   * Unlike the for `{}`-cycle or `Array#forEach` this iterator is safe\n   * if you are mutating the array of child nodes during iteration.\n   * PostCSS will adjust the current index to match the mutations.\n   *\n   * @param {childIterator} callback Iterator receives each node and index.\n   *\n   * @return {false|undefined} Returns `false` if iteration was broke.\n   *\n   * @example\n   * const root = postcss.parse('a { color: black; z-index: 1 }')\n   * const rule = root.first\n   *\n   * for (const decl of rule.nodes) {\n   *   decl.cloneBefore({ prop: '-webkit-' + decl.prop })\n   *   // Cycle will be infinite, because cloneBefore moves the current node\n   *   // to the next index\n   * }\n   *\n   * rule.each(decl => {\n   *   decl.cloneBefore({ prop: '-webkit-' + decl.prop })\n   *   // Will be executed only for color and z-index\n   * })\n   */\n\n\n  Container.prototype.each = function each(callback) {\n    if (!this.lastEach) this.lastEach = 0;\n    if (!this.indexes) this.indexes = {};\n\n    this.lastEach += 1;\n    var id = this.lastEach;\n    this.indexes[id] = 0;\n\n    if (!this.nodes) return undefined;\n\n    var index = void 0,\n        result = void 0;\n    while (this.indexes[id] < this.nodes.length) {\n      index = this.indexes[id];\n      result = callback(this.nodes[index], index);\n      if (result === false) break;\n\n      this.indexes[id] += 1;\n    }\n\n    delete this.indexes[id];\n\n    return result;\n  };\n\n  /**\n   * Traverses the container’s descendant nodes, calling callback\n   * for each node.\n   *\n   * Like container.each(), this method is safe to use\n   * if you are mutating arrays during iteration.\n   *\n   * If you only need to iterate through the container’s immediate children,\n   * use {@link Container#each}.\n   *\n   * @param {childIterator} callback Iterator receives each node and index.\n   *\n   * @return {false|undefined} Returns `false` if iteration was broke.\n   *\n   * @example\n   * root.walk(node => {\n   *   // Traverses all descendant nodes.\n   * })\n   */\n\n\n  Container.prototype.walk = function walk(callback) {\n    return this.each(function (child, i) {\n      var result = void 0;\n      try {\n        result = callback(child, i);\n      } catch (e) {\n        e.postcssNode = child;\n        if (e.stack && child.source && /\\n\\s{4}at /.test(e.stack)) {\n          var s = child.source;\n          e.stack = e.stack.replace(/\\n\\s{4}at /, '$&' + s.input.from + ':' + s.start.line + ':' + s.start.column + '$&');\n        }\n        throw e;\n      }\n      if (result !== false && child.walk) {\n        result = child.walk(callback);\n      }\n      return result;\n    });\n  };\n\n  /**\n   * Traverses the container’s descendant nodes, calling callback\n   * for each declaration node.\n   *\n   * If you pass a filter, iteration will only happen over declarations\n   * with matching properties.\n   *\n   * Like {@link Container#each}, this method is safe\n   * to use if you are mutating arrays during iteration.\n   *\n   * @param {string|RegExp} [prop]   String or regular expression\n   *                                 to filter declarations by property name.\n   * @param {childIterator} callback Iterator receives each node and index.\n   *\n   * @return {false|undefined} Returns `false` if iteration was broke.\n   *\n   * @example\n   * root.walkDecls(decl => {\n   *   checkPropertySupport(decl.prop)\n   * })\n   *\n   * root.walkDecls('border-radius', decl => {\n   *   decl.remove()\n   * })\n   *\n   * root.walkDecls(/^background/, decl => {\n   *   decl.value = takeFirstColorFromGradient(decl.value)\n   * })\n   */\n\n\n  Container.prototype.walkDecls = function walkDecls(prop, callback) {\n    if (!callback) {\n      callback = prop;\n      return this.walk(function (child, i) {\n        if (child.type === 'decl') {\n          return callback(child, i);\n        }\n      });\n    } else if (prop instanceof RegExp) {\n      return this.walk(function (child, i) {\n        if (child.type === 'decl' && prop.test(child.prop)) {\n          return callback(child, i);\n        }\n      });\n    } else {\n      return this.walk(function (child, i) {\n        if (child.type === 'decl' && child.prop === prop) {\n          return callback(child, i);\n        }\n      });\n    }\n  };\n\n  /**\n   * Traverses the container’s descendant nodes, calling callback\n   * for each rule node.\n   *\n   * If you pass a filter, iteration will only happen over rules\n   * with matching selectors.\n   *\n   * Like {@link Container#each}, this method is safe\n   * to use if you are mutating arrays during iteration.\n   *\n   * @param {string|RegExp} [selector] String or regular expression\n   *                                   to filter rules by selector.\n   * @param {childIterator} callback   Iterator receives each node and index.\n   *\n   * @return {false|undefined} returns `false` if iteration was broke.\n   *\n   * @example\n   * const selectors = []\n   * root.walkRules(rule => {\n   *   selectors.push(rule.selector)\n   * })\n   * console.log(`Your CSS uses ${ selectors.length } selectors`)\n   */\n\n\n  Container.prototype.walkRules = function walkRules(selector, callback) {\n    if (!callback) {\n      callback = selector;\n\n      return this.walk(function (child, i) {\n        if (child.type === 'rule') {\n          return callback(child, i);\n        }\n      });\n    } else if (selector instanceof RegExp) {\n      return this.walk(function (child, i) {\n        if (child.type === 'rule' && selector.test(child.selector)) {\n          return callback(child, i);\n        }\n      });\n    } else {\n      return this.walk(function (child, i) {\n        if (child.type === 'rule' && child.selector === selector) {\n          return callback(child, i);\n        }\n      });\n    }\n  };\n\n  /**\n   * Traverses the container’s descendant nodes, calling callback\n   * for each at-rule node.\n   *\n   * If you pass a filter, iteration will only happen over at-rules\n   * that have matching names.\n   *\n   * Like {@link Container#each}, this method is safe\n   * to use if you are mutating arrays during iteration.\n   *\n   * @param {string|RegExp} [name]   String or regular expression\n   *                                 to filter at-rules by name.\n   * @param {childIterator} callback Iterator receives each node and index.\n   *\n   * @return {false|undefined} Returns `false` if iteration was broke.\n   *\n   * @example\n   * root.walkAtRules(rule => {\n   *   if (isOld(rule.name)) rule.remove()\n   * })\n   *\n   * let first = false\n   * root.walkAtRules('charset', rule => {\n   *   if (!first) {\n   *     first = true\n   *   } else {\n   *     rule.remove()\n   *   }\n   * })\n   */\n\n\n  Container.prototype.walkAtRules = function walkAtRules(name, callback) {\n    if (!callback) {\n      callback = name;\n      return this.walk(function (child, i) {\n        if (child.type === 'atrule') {\n          return callback(child, i);\n        }\n      });\n    } else if (name instanceof RegExp) {\n      return this.walk(function (child, i) {\n        if (child.type === 'atrule' && name.test(child.name)) {\n          return callback(child, i);\n        }\n      });\n    } else {\n      return this.walk(function (child, i) {\n        if (child.type === 'atrule' && child.name === name) {\n          return callback(child, i);\n        }\n      });\n    }\n  };\n\n  /**\n   * Traverses the container’s descendant nodes, calling callback\n   * for each comment node.\n   *\n   * Like {@link Container#each}, this method is safe\n   * to use if you are mutating arrays during iteration.\n   *\n   * @param {childIterator} callback Iterator receives each node and index.\n   *\n   * @return {false|undefined} Returns `false` if iteration was broke.\n   *\n   * @example\n   * root.walkComments(comment => {\n   *   comment.remove()\n   * })\n   */\n\n\n  Container.prototype.walkComments = function walkComments(callback) {\n    return this.walk(function (child, i) {\n      if (child.type === 'comment') {\n        return callback(child, i);\n      }\n    });\n  };\n\n  /**\n   * Inserts new nodes to the end of the container.\n   *\n   * @param {...(Node|object|string|Node[])} children New nodes.\n   *\n   * @return {Node} This node for methods chain.\n   *\n   * @example\n   * const decl1 = postcss.decl({ prop: 'color', value: 'black' })\n   * const decl2 = postcss.decl({ prop: 'background-color', value: 'white' })\n   * rule.append(decl1, decl2)\n   *\n   * root.append({ name: 'charset', params: '\"UTF-8\"' })  // at-rule\n   * root.append({ selector: 'a' })                       // rule\n   * rule.append({ prop: 'color', value: 'black' })       // declaration\n   * rule.append({ text: 'Comment' })                     // comment\n   *\n   * root.append('a {}')\n   * root.first.append('color: black; z-index: 1')\n   */\n\n\n  Container.prototype.append = function append() {\n    for (var _len = arguments.length, children = Array(_len), _key = 0; _key < _len; _key++) {\n      children[_key] = arguments[_key];\n    }\n\n    for (var _iterator = children, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {\n      var _ref;\n\n      if (_isArray) {\n        if (_i >= _iterator.length) break;\n        _ref = _iterator[_i++];\n      } else {\n        _i = _iterator.next();\n        if (_i.done) break;\n        _ref = _i.value;\n      }\n\n      var child = _ref;\n\n      var nodes = this.normalize(child, this.last);\n      for (var _iterator2 = nodes, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {\n        var _ref2;\n\n        if (_isArray2) {\n          if (_i2 >= _iterator2.length) break;\n          _ref2 = _iterator2[_i2++];\n        } else {\n          _i2 = _iterator2.next();\n          if (_i2.done) break;\n          _ref2 = _i2.value;\n        }\n\n        var node = _ref2;\n        this.nodes.push(node);\n      }\n    }\n    return this;\n  };\n\n  /**\n   * Inserts new nodes to the start of the container.\n   *\n   * @param {...(Node|object|string|Node[])} children New nodes.\n   *\n   * @return {Node} This node for methods chain.\n   *\n   * @example\n   * const decl1 = postcss.decl({ prop: 'color', value: 'black' })\n   * const decl2 = postcss.decl({ prop: 'background-color', value: 'white' })\n   * rule.prepend(decl1, decl2)\n   *\n   * root.append({ name: 'charset', params: '\"UTF-8\"' })  // at-rule\n   * root.append({ selector: 'a' })                       // rule\n   * rule.append({ prop: 'color', value: 'black' })       // declaration\n   * rule.append({ text: 'Comment' })                     // comment\n   *\n   * root.append('a {}')\n   * root.first.append('color: black; z-index: 1')\n   */\n\n\n  Container.prototype.prepend = function prepend() {\n    for (var _len2 = arguments.length, children = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n      children[_key2] = arguments[_key2];\n    }\n\n    children = children.reverse();\n    for (var _iterator3 = children, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {\n      var _ref3;\n\n      if (_isArray3) {\n        if (_i3 >= _iterator3.length) break;\n        _ref3 = _iterator3[_i3++];\n      } else {\n        _i3 = _iterator3.next();\n        if (_i3.done) break;\n        _ref3 = _i3.value;\n      }\n\n      var child = _ref3;\n\n      var nodes = this.normalize(child, this.first, 'prepend').reverse();\n      for (var _iterator4 = nodes, _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) {\n        var _ref4;\n\n        if (_isArray4) {\n          if (_i4 >= _iterator4.length) break;\n          _ref4 = _iterator4[_i4++];\n        } else {\n          _i4 = _iterator4.next();\n          if (_i4.done) break;\n          _ref4 = _i4.value;\n        }\n\n        var node = _ref4;\n        this.nodes.unshift(node);\n      }for (var id in this.indexes) {\n        this.indexes[id] = this.indexes[id] + nodes.length;\n      }\n    }\n    return this;\n  };\n\n  Container.prototype.cleanRaws = function cleanRaws(keepBetween) {\n    _Node.prototype.cleanRaws.call(this, keepBetween);\n    if (this.nodes) {\n      for (var _iterator5 = this.nodes, _isArray5 = Array.isArray(_iterator5), _i5 = 0, _iterator5 = _isArray5 ? _iterator5 : _iterator5[Symbol.iterator]();;) {\n        var _ref5;\n\n        if (_isArray5) {\n          if (_i5 >= _iterator5.length) break;\n          _ref5 = _iterator5[_i5++];\n        } else {\n          _i5 = _iterator5.next();\n          if (_i5.done) break;\n          _ref5 = _i5.value;\n        }\n\n        var node = _ref5;\n        node.cleanRaws(keepBetween);\n      }\n    }\n  };\n\n  /**\n   * Insert new node before old node within the container.\n   *\n   * @param {Node|number} exist             Child or child’s index.\n   * @param {Node|object|string|Node[]} add New node.\n   *\n   * @return {Node} This node for methods chain.\n   *\n   * @example\n   * rule.insertBefore(decl, decl.clone({ prop: '-webkit-' + decl.prop }))\n   */\n\n\n  Container.prototype.insertBefore = function insertBefore(exist, add) {\n    exist = this.index(exist);\n\n    var type = exist === 0 ? 'prepend' : false;\n    var nodes = this.normalize(add, this.nodes[exist], type).reverse();\n    for (var _iterator6 = nodes, _isArray6 = Array.isArray(_iterator6), _i6 = 0, _iterator6 = _isArray6 ? _iterator6 : _iterator6[Symbol.iterator]();;) {\n      var _ref6;\n\n      if (_isArray6) {\n        if (_i6 >= _iterator6.length) break;\n        _ref6 = _iterator6[_i6++];\n      } else {\n        _i6 = _iterator6.next();\n        if (_i6.done) break;\n        _ref6 = _i6.value;\n      }\n\n      var node = _ref6;\n      this.nodes.splice(exist, 0, node);\n    }var index = void 0;\n    for (var id in this.indexes) {\n      index = this.indexes[id];\n      if (exist <= index) {\n        this.indexes[id] = index + nodes.length;\n      }\n    }\n\n    return this;\n  };\n\n  /**\n   * Insert new node after old node within the container.\n   *\n   * @param {Node|number} exist             Child or child’s index.\n   * @param {Node|object|string|Node[]} add New node.\n   *\n   * @return {Node} This node for methods chain.\n   */\n\n\n  Container.prototype.insertAfter = function insertAfter(exist, add) {\n    exist = this.index(exist);\n\n    var nodes = this.normalize(add, this.nodes[exist]).reverse();\n    for (var _iterator7 = nodes, _isArray7 = Array.isArray(_iterator7), _i7 = 0, _iterator7 = _isArray7 ? _iterator7 : _iterator7[Symbol.iterator]();;) {\n      var _ref7;\n\n      if (_isArray7) {\n        if (_i7 >= _iterator7.length) break;\n        _ref7 = _iterator7[_i7++];\n      } else {\n        _i7 = _iterator7.next();\n        if (_i7.done) break;\n        _ref7 = _i7.value;\n      }\n\n      var node = _ref7;\n      this.nodes.splice(exist + 1, 0, node);\n    }var index = void 0;\n    for (var id in this.indexes) {\n      index = this.indexes[id];\n      if (exist < index) {\n        this.indexes[id] = index + nodes.length;\n      }\n    }\n\n    return this;\n  };\n\n  /**\n   * Removes node from the container and cleans the parent properties\n   * from the node and its children.\n   *\n   * @param {Node|number} child Child or child’s index.\n   *\n   * @return {Node} This node for methods chain\n   *\n   * @example\n   * rule.nodes.length  //=> 5\n   * rule.removeChild(decl)\n   * rule.nodes.length  //=> 4\n   * decl.parent        //=> undefined\n   */\n\n\n  Container.prototype.removeChild = function removeChild(child) {\n    child = this.index(child);\n    this.nodes[child].parent = undefined;\n    this.nodes.splice(child, 1);\n\n    var index = void 0;\n    for (var id in this.indexes) {\n      index = this.indexes[id];\n      if (index >= child) {\n        this.indexes[id] = index - 1;\n      }\n    }\n\n    return this;\n  };\n\n  /**\n   * Removes all children from the container\n   * and cleans their parent properties.\n   *\n   * @return {Node} This node for methods chain.\n   *\n   * @example\n   * rule.removeAll()\n   * rule.nodes.length //=> 0\n   */\n\n\n  Container.prototype.removeAll = function removeAll() {\n    for (var _iterator8 = this.nodes, _isArray8 = Array.isArray(_iterator8), _i8 = 0, _iterator8 = _isArray8 ? _iterator8 : _iterator8[Symbol.iterator]();;) {\n      var _ref8;\n\n      if (_isArray8) {\n        if (_i8 >= _iterator8.length) break;\n        _ref8 = _iterator8[_i8++];\n      } else {\n        _i8 = _iterator8.next();\n        if (_i8.done) break;\n        _ref8 = _i8.value;\n      }\n\n      var node = _ref8;\n      node.parent = undefined;\n    }this.nodes = [];\n    return this;\n  };\n\n  /**\n   * Passes all declaration values within the container that match pattern\n   * through callback, replacing those values with the returned result\n   * of callback.\n   *\n   * This method is useful if you are using a custom unit or function\n   * and need to iterate through all values.\n   *\n   * @param {string|RegExp} pattern      Replace pattern.\n   * @param {object} opts                Options to speed up the search.\n   * @param {string|string[]} opts.props An array of property names.\n   * @param {string} opts.fast           String that’s used to narrow down\n   *                                     values and speed up the regexp search.\n   * @param {function|string} callback   String to replace pattern or callback\n   *                                     that returns a new value. The callback\n   *                                     will receive the same arguments\n   *                                     as those passed to a function parameter\n   *                                     of `String#replace`.\n   *\n   * @return {Node} This node for methods chain.\n   *\n   * @example\n   * root.replaceValues(/\\d+rem/, { fast: 'rem' }, string => {\n   *   return 15 * parseInt(string) + 'px'\n   * })\n   */\n\n\n  Container.prototype.replaceValues = function replaceValues(pattern, opts, callback) {\n    if (!callback) {\n      callback = opts;\n      opts = {};\n    }\n\n    this.walkDecls(function (decl) {\n      if (opts.props && opts.props.indexOf(decl.prop) === -1) return;\n      if (opts.fast && decl.value.indexOf(opts.fast) === -1) return;\n\n      decl.value = decl.value.replace(pattern, callback);\n    });\n\n    return this;\n  };\n\n  /**\n   * Returns `true` if callback returns `true`\n   * for all of the container’s children.\n   *\n   * @param {childCondition} condition Iterator returns true or false.\n   *\n   * @return {boolean} Is every child pass condition.\n   *\n   * @example\n   * const noPrefixes = rule.every(i => i.prop[0] !== '-')\n   */\n\n\n  Container.prototype.every = function every(condition) {\n    return this.nodes.every(condition);\n  };\n\n  /**\n   * Returns `true` if callback returns `true` for (at least) one\n   * of the container’s children.\n   *\n   * @param {childCondition} condition Iterator returns true or false.\n   *\n   * @return {boolean} Is some child pass condition.\n   *\n   * @example\n   * const hasPrefix = rule.some(i => i.prop[0] === '-')\n   */\n\n\n  Container.prototype.some = function some(condition) {\n    return this.nodes.some(condition);\n  };\n\n  /**\n   * Returns a `child`’s index within the {@link Container#nodes} array.\n   *\n   * @param {Node} child Child of the current container.\n   *\n   * @return {number} Child index.\n   *\n   * @example\n   * rule.index( rule.nodes[2] ) //=> 2\n   */\n\n\n  Container.prototype.index = function index(child) {\n    if (typeof child === 'number') {\n      return child;\n    } else {\n      return this.nodes.indexOf(child);\n    }\n  };\n\n  /**\n   * The container’s first child.\n   *\n   * @type {Node}\n   *\n   * @example\n   * rule.first === rules.nodes[0]\n   */\n\n\n  Container.prototype.normalize = function normalize(nodes, sample) {\n    var _this2 = this;\n\n    if (typeof nodes === 'string') {\n      var parse = require('./parse');\n      nodes = cleanSource(parse(nodes).nodes);\n    } else if (Array.isArray(nodes)) {\n      nodes = nodes.slice(0);\n      for (var _iterator9 = nodes, _isArray9 = Array.isArray(_iterator9), _i9 = 0, _iterator9 = _isArray9 ? _iterator9 : _iterator9[Symbol.iterator]();;) {\n        var _ref9;\n\n        if (_isArray9) {\n          if (_i9 >= _iterator9.length) break;\n          _ref9 = _iterator9[_i9++];\n        } else {\n          _i9 = _iterator9.next();\n          if (_i9.done) break;\n          _ref9 = _i9.value;\n        }\n\n        var i = _ref9;\n\n        if (i.parent) i.parent.removeChild(i, 'ignore');\n      }\n    } else if (nodes.type === 'root') {\n      nodes = nodes.nodes.slice(0);\n      for (var _iterator10 = nodes, _isArray10 = Array.isArray(_iterator10), _i11 = 0, _iterator10 = _isArray10 ? _iterator10 : _iterator10[Symbol.iterator]();;) {\n        var _ref10;\n\n        if (_isArray10) {\n          if (_i11 >= _iterator10.length) break;\n          _ref10 = _iterator10[_i11++];\n        } else {\n          _i11 = _iterator10.next();\n          if (_i11.done) break;\n          _ref10 = _i11.value;\n        }\n\n        var _i10 = _ref10;\n\n        if (_i10.parent) _i10.parent.removeChild(_i10, 'ignore');\n      }\n    } else if (nodes.type) {\n      nodes = [nodes];\n    } else if (nodes.prop) {\n      if (typeof nodes.value === 'undefined') {\n        throw new Error('Value field is missed in node creation');\n      } else if (typeof nodes.value !== 'string') {\n        nodes.value = String(nodes.value);\n      }\n      nodes = [new _declaration2.default(nodes)];\n    } else if (nodes.selector) {\n      var Rule = require('./rule');\n      nodes = [new Rule(nodes)];\n    } else if (nodes.name) {\n      var AtRule = require('./at-rule');\n      nodes = [new AtRule(nodes)];\n    } else if (nodes.text) {\n      nodes = [new _comment2.default(nodes)];\n    } else {\n      throw new Error('Unknown node type in node creation');\n    }\n\n    var processed = nodes.map(function (i) {\n      if (i.parent) i.parent.removeChild(i);\n      if (typeof i.raws.before === 'undefined') {\n        if (sample && typeof sample.raws.before !== 'undefined') {\n          i.raws.before = sample.raws.before.replace(/[^\\s]/g, '');\n        }\n      }\n      i.parent = _this2;\n      return i;\n    });\n\n    return processed;\n  };\n\n  /**\n   * @memberof Container#\n   * @member {Node[]} nodes An array containing the container’s children.\n   *\n   * @example\n   * const root = postcss.parse('a { color: black }')\n   * root.nodes.length           //=> 1\n   * root.nodes[0].selector      //=> 'a'\n   * root.nodes[0].nodes[0].prop //=> 'color'\n   */\n\n\n  _createClass(Container, [{\n    key: 'first',\n    get: function get() {\n      if (!this.nodes) return undefined;\n      return this.nodes[0];\n    }\n\n    /**\n     * The container’s last child.\n     *\n     * @type {Node}\n     *\n     * @example\n     * rule.last === rule.nodes[rule.nodes.length - 1]\n     */\n\n  }, {\n    key: 'last',\n    get: function get() {\n      if (!this.nodes) return undefined;\n      return this.nodes[this.nodes.length - 1];\n    }\n  }]);\n\n  return Container;\n}(_node2.default);\n\nexports.default = Container;\n\n/**\n * @callback childCondition\n * @param {Node} node    Container child.\n * @param {number} index Child index.\n * @param {Node[]} nodes All container children.\n * @return {boolean}\n */\n\n/**\n * @callback childIterator\n * @param {Node} node    Container child.\n * @param {number} index Child index.\n * @return {false|undefined} Returning `false` will break iteration.\n */\n\nmodule.exports = exports['default'];\n//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["container.es6"],"names":["cleanSource","nodes","map","i","source","Container","push","child","parent","each","callback","lastEach","indexes","id","undefined","index","result","length","walk","e","postcssNode","stack","test","s","replace","input","from","start","line","column","walkDecls","prop","type","RegExp","walkRules","selector","walkAtRules","name","walkComments","append","children","normalize","last","node","prepend","reverse","first","unshift","cleanRaws","keepBetween","insertBefore","exist","add","splice","insertAfter","removeChild","removeAll","replaceValues","pattern","opts","props","indexOf","decl","fast","value","every","condition","some","sample","parse","require","Array","isArray","slice","Error","String","Declaration","Rule","AtRule","text","Comment","processed","raws","before","Node"],"mappings":"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","file":"container.js","sourcesContent":["import Declaration from './declaration'\nimport Comment from './comment'\nimport Node from './node'\n\nfunction cleanSource (nodes) {\n  return nodes.map(i => {\n    if (i.nodes) i.nodes = cleanSource(i.nodes)\n    delete i.source\n    return i\n  })\n}\n\n/**\n * The {@link Root}, {@link AtRule}, and {@link Rule} container nodes\n * inherit some common methods to help work with their children.\n *\n * Note that all containers can store any content. If you write a rule inside\n * a rule, PostCSS will parse it.\n *\n * @extends Node\n * @abstract\n */\nclass Container extends Node {\n  push (child) {\n    child.parent = this\n    this.nodes.push(child)\n    return this\n  }\n\n  /**\n   * Iterates through the container’s immediate children,\n   * calling `callback` for each child.\n   *\n   * Returning `false` in the callback will break iteration.\n   *\n   * This method only iterates through the container’s immediate children.\n   * If you need to recursively iterate through all the container’s descendant\n   * nodes, use {@link Container#walk}.\n   *\n   * Unlike the for `{}`-cycle or `Array#forEach` this iterator is safe\n   * if you are mutating the array of child nodes during iteration.\n   * PostCSS will adjust the current index to match the mutations.\n   *\n   * @param {childIterator} callback Iterator receives each node and index.\n   *\n   * @return {false|undefined} Returns `false` if iteration was broke.\n   *\n   * @example\n   * const root = postcss.parse('a { color: black; z-index: 1 }')\n   * const rule = root.first\n   *\n   * for (const decl of rule.nodes) {\n   *   decl.cloneBefore({ prop: '-webkit-' + decl.prop })\n   *   // Cycle will be infinite, because cloneBefore moves the current node\n   *   // to the next index\n   * }\n   *\n   * rule.each(decl => {\n   *   decl.cloneBefore({ prop: '-webkit-' + decl.prop })\n   *   // Will be executed only for color and z-index\n   * })\n   */\n  each (callback) {\n    if (!this.lastEach) this.lastEach = 0\n    if (!this.indexes) this.indexes = { }\n\n    this.lastEach += 1\n    let id = this.lastEach\n    this.indexes[id] = 0\n\n    if (!this.nodes) return undefined\n\n    let index, result\n    while (this.indexes[id] < this.nodes.length) {\n      index = this.indexes[id]\n      result = callback(this.nodes[index], index)\n      if (result === false) break\n\n      this.indexes[id] += 1\n    }\n\n    delete this.indexes[id]\n\n    return result\n  }\n\n  /**\n   * Traverses the container’s descendant nodes, calling callback\n   * for each node.\n   *\n   * Like container.each(), this method is safe to use\n   * if you are mutating arrays during iteration.\n   *\n   * If you only need to iterate through the container’s immediate children,\n   * use {@link Container#each}.\n   *\n   * @param {childIterator} callback Iterator receives each node and index.\n   *\n   * @return {false|undefined} Returns `false` if iteration was broke.\n   *\n   * @example\n   * root.walk(node => {\n   *   // Traverses all descendant nodes.\n   * })\n   */\n  walk (callback) {\n    return this.each((child, i) => {\n      let result\n      try {\n        result = callback(child, i)\n      } catch (e) {\n        e.postcssNode = child\n        if (e.stack && child.source && /\\n\\s{4}at /.test(e.stack)) {\n          let s = child.source\n          e.stack = e.stack.replace(/\\n\\s{4}at /,\n            `$&${ s.input.from }:${ s.start.line }:${ s.start.column }$&`)\n        }\n        throw e\n      }\n      if (result !== false && child.walk) {\n        result = child.walk(callback)\n      }\n      return result\n    })\n  }\n\n  /**\n   * Traverses the container’s descendant nodes, calling callback\n   * for each declaration node.\n   *\n   * If you pass a filter, iteration will only happen over declarations\n   * with matching properties.\n   *\n   * Like {@link Container#each}, this method is safe\n   * to use if you are mutating arrays during iteration.\n   *\n   * @param {string|RegExp} [prop]   String or regular expression\n   *                                 to filter declarations by property name.\n   * @param {childIterator} callback Iterator receives each node and index.\n   *\n   * @return {false|undefined} Returns `false` if iteration was broke.\n   *\n   * @example\n   * root.walkDecls(decl => {\n   *   checkPropertySupport(decl.prop)\n   * })\n   *\n   * root.walkDecls('border-radius', decl => {\n   *   decl.remove()\n   * })\n   *\n   * root.walkDecls(/^background/, decl => {\n   *   decl.value = takeFirstColorFromGradient(decl.value)\n   * })\n   */\n  walkDecls (prop, callback) {\n    if (!callback) {\n      callback = prop\n      return this.walk((child, i) => {\n        if (child.type === 'decl') {\n          return callback(child, i)\n        }\n      })\n    } else if (prop instanceof RegExp) {\n      return this.walk((child, i) => {\n        if (child.type === 'decl' && prop.test(child.prop)) {\n          return callback(child, i)\n        }\n      })\n    } else {\n      return this.walk((child, i) => {\n        if (child.type === 'decl' && child.prop === prop) {\n          return callback(child, i)\n        }\n      })\n    }\n  }\n\n  /**\n   * Traverses the container’s descendant nodes, calling callback\n   * for each rule node.\n   *\n   * If you pass a filter, iteration will only happen over rules\n   * with matching selectors.\n   *\n   * Like {@link Container#each}, this method is safe\n   * to use if you are mutating arrays during iteration.\n   *\n   * @param {string|RegExp} [selector] String or regular expression\n   *                                   to filter rules by selector.\n   * @param {childIterator} callback   Iterator receives each node and index.\n   *\n   * @return {false|undefined} returns `false` if iteration was broke.\n   *\n   * @example\n   * const selectors = []\n   * root.walkRules(rule => {\n   *   selectors.push(rule.selector)\n   * })\n   * console.log(`Your CSS uses ${ selectors.length } selectors`)\n   */\n  walkRules (selector, callback) {\n    if (!callback) {\n      callback = selector\n\n      return this.walk((child, i) => {\n        if (child.type === 'rule') {\n          return callback(child, i)\n        }\n      })\n    } else if (selector instanceof RegExp) {\n      return this.walk((child, i) => {\n        if (child.type === 'rule' && selector.test(child.selector)) {\n          return callback(child, i)\n        }\n      })\n    } else {\n      return this.walk((child, i) => {\n        if (child.type === 'rule' && child.selector === selector) {\n          return callback(child, i)\n        }\n      })\n    }\n  }\n\n  /**\n   * Traverses the container’s descendant nodes, calling callback\n   * for each at-rule node.\n   *\n   * If you pass a filter, iteration will only happen over at-rules\n   * that have matching names.\n   *\n   * Like {@link Container#each}, this method is safe\n   * to use if you are mutating arrays during iteration.\n   *\n   * @param {string|RegExp} [name]   String or regular expression\n   *                                 to filter at-rules by name.\n   * @param {childIterator} callback Iterator receives each node and index.\n   *\n   * @return {false|undefined} Returns `false` if iteration was broke.\n   *\n   * @example\n   * root.walkAtRules(rule => {\n   *   if (isOld(rule.name)) rule.remove()\n   * })\n   *\n   * let first = false\n   * root.walkAtRules('charset', rule => {\n   *   if (!first) {\n   *     first = true\n   *   } else {\n   *     rule.remove()\n   *   }\n   * })\n   */\n  walkAtRules (name, callback) {\n    if (!callback) {\n      callback = name\n      return this.walk((child, i) => {\n        if (child.type === 'atrule') {\n          return callback(child, i)\n        }\n      })\n    } else if (name instanceof RegExp) {\n      return this.walk((child, i) => {\n        if (child.type === 'atrule' && name.test(child.name)) {\n          return callback(child, i)\n        }\n      })\n    } else {\n      return this.walk((child, i) => {\n        if (child.type === 'atrule' && child.name === name) {\n          return callback(child, i)\n        }\n      })\n    }\n  }\n\n  /**\n   * Traverses the container’s descendant nodes, calling callback\n   * for each comment node.\n   *\n   * Like {@link Container#each}, this method is safe\n   * to use if you are mutating arrays during iteration.\n   *\n   * @param {childIterator} callback Iterator receives each node and index.\n   *\n   * @return {false|undefined} Returns `false` if iteration was broke.\n   *\n   * @example\n   * root.walkComments(comment => {\n   *   comment.remove()\n   * })\n   */\n  walkComments (callback) {\n    return this.walk((child, i) => {\n      if (child.type === 'comment') {\n        return callback(child, i)\n      }\n    })\n  }\n\n  /**\n   * Inserts new nodes to the end of the container.\n   *\n   * @param {...(Node|object|string|Node[])} children New nodes.\n   *\n   * @return {Node} This node for methods chain.\n   *\n   * @example\n   * const decl1 = postcss.decl({ prop: 'color', value: 'black' })\n   * const decl2 = postcss.decl({ prop: 'background-color', value: 'white' })\n   * rule.append(decl1, decl2)\n   *\n   * root.append({ name: 'charset', params: '\"UTF-8\"' })  // at-rule\n   * root.append({ selector: 'a' })                       // rule\n   * rule.append({ prop: 'color', value: 'black' })       // declaration\n   * rule.append({ text: 'Comment' })                     // comment\n   *\n   * root.append('a {}')\n   * root.first.append('color: black; z-index: 1')\n   */\n  append (...children) {\n    for (let child of children) {\n      let nodes = this.normalize(child, this.last)\n      for (let node of nodes) this.nodes.push(node)\n    }\n    return this\n  }\n\n  /**\n   * Inserts new nodes to the start of the container.\n   *\n   * @param {...(Node|object|string|Node[])} children New nodes.\n   *\n   * @return {Node} This node for methods chain.\n   *\n   * @example\n   * const decl1 = postcss.decl({ prop: 'color', value: 'black' })\n   * const decl2 = postcss.decl({ prop: 'background-color', value: 'white' })\n   * rule.prepend(decl1, decl2)\n   *\n   * root.append({ name: 'charset', params: '\"UTF-8\"' })  // at-rule\n   * root.append({ selector: 'a' })                       // rule\n   * rule.append({ prop: 'color', value: 'black' })       // declaration\n   * rule.append({ text: 'Comment' })                     // comment\n   *\n   * root.append('a {}')\n   * root.first.append('color: black; z-index: 1')\n   */\n  prepend (...children) {\n    children = children.reverse()\n    for (let child of children) {\n      let nodes = this.normalize(child, this.first, 'prepend').reverse()\n      for (let node of nodes) this.nodes.unshift(node)\n      for (let id in this.indexes) {\n        this.indexes[id] = this.indexes[id] + nodes.length\n      }\n    }\n    return this\n  }\n\n  cleanRaws (keepBetween) {\n    super.cleanRaws(keepBetween)\n    if (this.nodes) {\n      for (let node of this.nodes) node.cleanRaws(keepBetween)\n    }\n  }\n\n  /**\n   * Insert new node before old node within the container.\n   *\n   * @param {Node|number} exist             Child or child’s index.\n   * @param {Node|object|string|Node[]} add New node.\n   *\n   * @return {Node} This node for methods chain.\n   *\n   * @example\n   * rule.insertBefore(decl, decl.clone({ prop: '-webkit-' + decl.prop }))\n   */\n  insertBefore (exist, add) {\n    exist = this.index(exist)\n\n    let type = exist === 0 ? 'prepend' : false\n    let nodes = this.normalize(add, this.nodes[exist], type).reverse()\n    for (let node of nodes) this.nodes.splice(exist, 0, node)\n\n    let index\n    for (let id in this.indexes) {\n      index = this.indexes[id]\n      if (exist <= index) {\n        this.indexes[id] = index + nodes.length\n      }\n    }\n\n    return this\n  }\n\n  /**\n   * Insert new node after old node within the container.\n   *\n   * @param {Node|number} exist             Child or child’s index.\n   * @param {Node|object|string|Node[]} add New node.\n   *\n   * @return {Node} This node for methods chain.\n   */\n  insertAfter (exist, add) {\n    exist = this.index(exist)\n\n    let nodes = this.normalize(add, this.nodes[exist]).reverse()\n    for (let node of nodes) this.nodes.splice(exist + 1, 0, node)\n\n    let index\n    for (let id in this.indexes) {\n      index = this.indexes[id]\n      if (exist < index) {\n        this.indexes[id] = index + nodes.length\n      }\n    }\n\n    return this\n  }\n\n  /**\n   * Removes node from the container and cleans the parent properties\n   * from the node and its children.\n   *\n   * @param {Node|number} child Child or child’s index.\n   *\n   * @return {Node} This node for methods chain\n   *\n   * @example\n   * rule.nodes.length  //=> 5\n   * rule.removeChild(decl)\n   * rule.nodes.length  //=> 4\n   * decl.parent        //=> undefined\n   */\n  removeChild (child) {\n    child = this.index(child)\n    this.nodes[child].parent = undefined\n    this.nodes.splice(child, 1)\n\n    let index\n    for (let id in this.indexes) {\n      index = this.indexes[id]\n      if (index >= child) {\n        this.indexes[id] = index - 1\n      }\n    }\n\n    return this\n  }\n\n  /**\n   * Removes all children from the container\n   * and cleans their parent properties.\n   *\n   * @return {Node} This node for methods chain.\n   *\n   * @example\n   * rule.removeAll()\n   * rule.nodes.length //=> 0\n   */\n  removeAll () {\n    for (let node of this.nodes) node.parent = undefined\n    this.nodes = []\n    return this\n  }\n\n  /**\n   * Passes all declaration values within the container that match pattern\n   * through callback, replacing those values with the returned result\n   * of callback.\n   *\n   * This method is useful if you are using a custom unit or function\n   * and need to iterate through all values.\n   *\n   * @param {string|RegExp} pattern      Replace pattern.\n   * @param {object} opts                Options to speed up the search.\n   * @param {string|string[]} opts.props An array of property names.\n   * @param {string} opts.fast           String that’s used to narrow down\n   *                                     values and speed up the regexp search.\n   * @param {function|string} callback   String to replace pattern or callback\n   *                                     that returns a new value. The callback\n   *                                     will receive the same arguments\n   *                                     as those passed to a function parameter\n   *                                     of `String#replace`.\n   *\n   * @return {Node} This node for methods chain.\n   *\n   * @example\n   * root.replaceValues(/\\d+rem/, { fast: 'rem' }, string => {\n   *   return 15 * parseInt(string) + 'px'\n   * })\n   */\n  replaceValues (pattern, opts, callback) {\n    if (!callback) {\n      callback = opts\n      opts = { }\n    }\n\n    this.walkDecls(decl => {\n      if (opts.props && opts.props.indexOf(decl.prop) === -1) return\n      if (opts.fast && decl.value.indexOf(opts.fast) === -1) return\n\n      decl.value = decl.value.replace(pattern, callback)\n    })\n\n    return this\n  }\n\n  /**\n   * Returns `true` if callback returns `true`\n   * for all of the container’s children.\n   *\n   * @param {childCondition} condition Iterator returns true or false.\n   *\n   * @return {boolean} Is every child pass condition.\n   *\n   * @example\n   * const noPrefixes = rule.every(i => i.prop[0] !== '-')\n   */\n  every (condition) {\n    return this.nodes.every(condition)\n  }\n\n  /**\n   * Returns `true` if callback returns `true` for (at least) one\n   * of the container’s children.\n   *\n   * @param {childCondition} condition Iterator returns true or false.\n   *\n   * @return {boolean} Is some child pass condition.\n   *\n   * @example\n   * const hasPrefix = rule.some(i => i.prop[0] === '-')\n   */\n  some (condition) {\n    return this.nodes.some(condition)\n  }\n\n  /**\n   * Returns a `child`’s index within the {@link Container#nodes} array.\n   *\n   * @param {Node} child Child of the current container.\n   *\n   * @return {number} Child index.\n   *\n   * @example\n   * rule.index( rule.nodes[2] ) //=> 2\n   */\n  index (child) {\n    if (typeof child === 'number') {\n      return child\n    } else {\n      return this.nodes.indexOf(child)\n    }\n  }\n\n  /**\n   * The container’s first child.\n   *\n   * @type {Node}\n   *\n   * @example\n   * rule.first === rules.nodes[0]\n   */\n  get first () {\n    if (!this.nodes) return undefined\n    return this.nodes[0]\n  }\n\n  /**\n   * The container’s last child.\n   *\n   * @type {Node}\n   *\n   * @example\n   * rule.last === rule.nodes[rule.nodes.length - 1]\n   */\n  get last () {\n    if (!this.nodes) return undefined\n    return this.nodes[this.nodes.length - 1]\n  }\n\n  normalize (nodes, sample) {\n    if (typeof nodes === 'string') {\n      let parse = require('./parse')\n      nodes = cleanSource(parse(nodes).nodes)\n    } else if (Array.isArray(nodes)) {\n      nodes = nodes.slice(0)\n      for (let i of nodes) {\n        if (i.parent) i.parent.removeChild(i, 'ignore')\n      }\n    } else if (nodes.type === 'root') {\n      nodes = nodes.nodes.slice(0)\n      for (let i of nodes) {\n        if (i.parent) i.parent.removeChild(i, 'ignore')\n      }\n    } else if (nodes.type) {\n      nodes = [nodes]\n    } else if (nodes.prop) {\n      if (typeof nodes.value === 'undefined') {\n        throw new Error('Value field is missed in node creation')\n      } else if (typeof nodes.value !== 'string') {\n        nodes.value = String(nodes.value)\n      }\n      nodes = [new Declaration(nodes)]\n    } else if (nodes.selector) {\n      let Rule = require('./rule')\n      nodes = [new Rule(nodes)]\n    } else if (nodes.name) {\n      let AtRule = require('./at-rule')\n      nodes = [new AtRule(nodes)]\n    } else if (nodes.text) {\n      nodes = [new Comment(nodes)]\n    } else {\n      throw new Error('Unknown node type in node creation')\n    }\n\n    let processed = nodes.map(i => {\n      if (i.parent) i.parent.removeChild(i)\n      if (typeof i.raws.before === 'undefined') {\n        if (sample && typeof sample.raws.before !== 'undefined') {\n          i.raws.before = sample.raws.before.replace(/[^\\s]/g, '')\n        }\n      }\n      i.parent = this\n      return i\n    })\n\n    return processed\n  }\n\n  /**\n   * @memberof Container#\n   * @member {Node[]} nodes An array containing the container’s children.\n   *\n   * @example\n   * const root = postcss.parse('a { color: black }')\n   * root.nodes.length           //=> 1\n   * root.nodes[0].selector      //=> 'a'\n   * root.nodes[0].nodes[0].prop //=> 'color'\n   */\n}\n\nexport default Container\n\n/**\n * @callback childCondition\n * @param {Node} node    Container child.\n * @param {number} index Child index.\n * @param {Node[]} nodes All container children.\n * @return {boolean}\n */\n\n/**\n * @callback childIterator\n * @param {Node} node    Container child.\n * @param {number} index Child index.\n * @return {false|undefined} Returning `false` will break iteration.\n */\n"]}\n","'use strict';\n\nexports.__esModule = true;\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _container = require('./container');\n\nvar _container2 = _interopRequireDefault(_container);\n\nvar _list = require('./list');\n\nvar _list2 = _interopRequireDefault(_list);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\n/**\n * Represents a CSS rule: a selector followed by a declaration block.\n *\n * @extends Container\n *\n * @example\n * const root = postcss.parse('a{}')\n * const rule = root.first\n * rule.type       //=> 'rule'\n * rule.toString() //=> 'a{}'\n */\nvar Rule = function (_Container) {\n  _inherits(Rule, _Container);\n\n  function Rule(defaults) {\n    _classCallCheck(this, Rule);\n\n    var _this = _possibleConstructorReturn(this, _Container.call(this, defaults));\n\n    _this.type = 'rule';\n    if (!_this.nodes) _this.nodes = [];\n    return _this;\n  }\n\n  /**\n   * An array containing the rule’s individual selectors.\n   * Groups of selectors are split at commas.\n   *\n   * @type {string[]}\n   *\n   * @example\n   * const root = postcss.parse('a, b { }')\n   * const rule = root.first\n   *\n   * rule.selector  //=> 'a, b'\n   * rule.selectors //=> ['a', 'b']\n   *\n   * rule.selectors = ['a', 'strong']\n   * rule.selector //=> 'a, strong'\n   */\n\n\n  _createClass(Rule, [{\n    key: 'selectors',\n    get: function get() {\n      return _list2.default.comma(this.selector);\n    },\n    set: function set(values) {\n      var match = this.selector ? this.selector.match(/,\\s*/) : null;\n      var sep = match ? match[0] : ',' + this.raw('between', 'beforeOpen');\n      this.selector = values.join(sep);\n    }\n\n    /**\n     * @memberof Rule#\n     * @member {string} selector The rule’s full selector represented\n     *                           as a string.\n     *\n     * @example\n     * const root = postcss.parse('a, b { }')\n     * const rule = root.first\n     * rule.selector //=> 'a, b'\n     */\n\n    /**\n     * @memberof Rule#\n     * @member {object} raws Information to generate byte-to-byte equal\n     *                       node string as it was in the origin input.\n     *\n     * Every parser saves its own properties,\n     * but the default CSS parser uses:\n     *\n     * * `before`: the space symbols before the node. It also stores `*`\n     *   and `_` symbols before the declaration (IE hack).\n     * * `after`: the space symbols after the last child of the node\n     *   to the end of the node.\n     * * `between`: the symbols between the property and value\n     *   for declarations, selector and `{` for rules, or last parameter\n     *   and `{` for at-rules.\n     * * `semicolon`: contains `true` if the last child has\n     *   an (optional) semicolon.\n     * * `ownSemicolon`: contains `true` if there is semicolon after rule.\n     *\n     * PostCSS cleans selectors from comments and extra spaces,\n     * but it stores origin content in raws properties.\n     * As such, if you don’t change a declaration’s value,\n     * PostCSS will use the raw value with comments.\n     *\n     * @example\n     * const root = postcss.parse('a {\\n  color:black\\n}')\n     * root.first.first.raws //=> { before: '', between: ' ', after: '\\n' }\n     */\n\n  }]);\n\n  return Rule;\n}(_container2.default);\n\nexports.default = Rule;\nmodule.exports = exports['default'];\n//# sourceMappingURL=data:application/json;charset=utf8;base64,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\n","'use strict';\n\nexports.__esModule = true;\n\nvar _supportsColor = require('supports-color');\n\nvar _supportsColor2 = _interopRequireDefault(_supportsColor);\n\nvar _chalk = require('chalk');\n\nvar _chalk2 = _interopRequireDefault(_chalk);\n\nvar _terminalHighlight = require('./terminal-highlight');\n\nvar _terminalHighlight2 = _interopRequireDefault(_terminalHighlight);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n/**\n * The CSS parser throws this error for broken CSS.\n *\n * Custom parsers can throw this error for broken custom syntax using\n * the {@link Node#error} method.\n *\n * PostCSS will use the input source map to detect the original error location.\n * If you wrote a Sass file, compiled it to CSS and then parsed it with PostCSS,\n * PostCSS will show the original position in the Sass file.\n *\n * If you need the position in the PostCSS input\n * (e.g., to debug the previous compiler), use `error.input.file`.\n *\n * @example\n * // Catching and checking syntax error\n * try {\n *   postcss.parse('a{')\n * } catch (error) {\n *   if (error.name === 'CssSyntaxError') {\n *     error //=> CssSyntaxError\n *   }\n * }\n *\n * @example\n * // Raising error from plugin\n * throw node.error('Unknown variable', { plugin: 'postcss-vars' })\n */\nvar CssSyntaxError = function () {\n  /**\n   * @param {string} message  Error message.\n   * @param {number} [line]   Source line of the error.\n   * @param {number} [column] Source column of the error.\n   * @param {string} [source] Source code of the broken file.\n   * @param {string} [file]   Absolute path to the broken file.\n   * @param {string} [plugin] PostCSS plugin name, if error came from plugin.\n   */\n  function CssSyntaxError(message, line, column, source, file, plugin) {\n    _classCallCheck(this, CssSyntaxError);\n\n    /**\n     * Always equal to `'CssSyntaxError'`. You should always check error type\n     * by `error.name === 'CssSyntaxError'`\n     * instead of `error instanceof CssSyntaxError`,\n     * because npm could have several PostCSS versions.\n     *\n     * @type {string}\n     *\n     * @example\n     * if (error.name === 'CssSyntaxError') {\n     *   error //=> CssSyntaxError\n     * }\n     */\n    this.name = 'CssSyntaxError';\n    /**\n     * Error message.\n     *\n     * @type {string}\n     *\n     * @example\n     * error.message //=> 'Unclosed block'\n     */\n    this.reason = message;\n\n    if (file) {\n      /**\n       * Absolute path to the broken file.\n       *\n       * @type {string}\n       *\n       * @example\n       * error.file       //=> 'a.sass'\n       * error.input.file //=> 'a.css'\n       */\n      this.file = file;\n    }\n    if (source) {\n      /**\n       * Source code of the broken file.\n       *\n       * @type {string}\n       *\n       * @example\n       * error.source       //=> 'a { b {} }'\n       * error.input.column //=> 'a b { }'\n       */\n      this.source = source;\n    }\n    if (plugin) {\n      /**\n       * Plugin name, if error came from plugin.\n       *\n       * @type {string}\n       *\n       * @example\n       * error.plugin //=> 'postcss-vars'\n       */\n      this.plugin = plugin;\n    }\n    if (typeof line !== 'undefined' && typeof column !== 'undefined') {\n      /**\n       * Source line of the error.\n       *\n       * @type {number}\n       *\n       * @example\n       * error.line       //=> 2\n       * error.input.line //=> 4\n       */\n      this.line = line;\n      /**\n       * Source column of the error.\n       *\n       * @type {number}\n       *\n       * @example\n       * error.column       //=> 1\n       * error.input.column //=> 4\n       */\n      this.column = column;\n    }\n\n    this.setMessage();\n\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, CssSyntaxError);\n    }\n  }\n\n  CssSyntaxError.prototype.setMessage = function setMessage() {\n    /**\n     * Full error text in the GNU error format\n     * with plugin, file, line and column.\n     *\n     * @type {string}\n     *\n     * @example\n     * error.message //=> 'a.css:1:1: Unclosed block'\n     */\n    this.message = this.plugin ? this.plugin + ': ' : '';\n    this.message += this.file ? this.file : '<css input>';\n    if (typeof this.line !== 'undefined') {\n      this.message += ':' + this.line + ':' + this.column;\n    }\n    this.message += ': ' + this.reason;\n  };\n\n  /**\n   * Returns a few lines of CSS source that caused the error.\n   *\n   * If the CSS has an input source map without `sourceContent`,\n   * this method will return an empty string.\n   *\n   * @param {boolean} [color] Whether arrow will be colored red by terminal\n   *                          color codes. By default, PostCSS will detect\n   *                          color support by `process.stdout.isTTY`\n   *                          and `process.env.NODE_DISABLE_COLORS`.\n   *\n   * @example\n   * error.showSourceCode() //=> \"  4 | }\n   *                        //      5 | a {\n   *                        //    > 6 |   bad\n   *                        //        |   ^\n   *                        //      7 | }\n   *                        //      8 | b {\"\n   *\n   * @return {string} Few lines of CSS source that caused the error.\n   */\n\n\n  CssSyntaxError.prototype.showSourceCode = function showSourceCode(color) {\n    var _this = this;\n\n    if (!this.source) return '';\n\n    var css = this.source;\n    if (_terminalHighlight2.default) {\n      if (typeof color === 'undefined') color = _supportsColor2.default.stdout;\n      if (color) css = (0, _terminalHighlight2.default)(css);\n    }\n\n    var lines = css.split(/\\r?\\n/);\n    var start = Math.max(this.line - 3, 0);\n    var end = Math.min(this.line + 2, lines.length);\n\n    var maxWidth = String(end).length;\n\n    function mark(text) {\n      if (color && _chalk2.default.red) {\n        return _chalk2.default.red.bold(text);\n      } else {\n        return text;\n      }\n    }\n    function aside(text) {\n      if (color && _chalk2.default.gray) {\n        return _chalk2.default.gray(text);\n      } else {\n        return text;\n      }\n    }\n\n    return lines.slice(start, end).map(function (line, index) {\n      var number = start + 1 + index;\n      var gutter = ' ' + (' ' + number).slice(-maxWidth) + ' | ';\n      if (number === _this.line) {\n        var spacing = aside(gutter.replace(/\\d/g, ' ')) + line.slice(0, _this.column - 1).replace(/[^\\t]/g, ' ');\n        return mark('>') + aside(gutter) + line + '\\n ' + spacing + mark('^');\n      } else {\n        return ' ' + aside(gutter) + line;\n      }\n    }).join('\\n');\n  };\n\n  /**\n   * Returns error position, message and source code of the broken part.\n   *\n   * @example\n   * error.toString() //=> \"CssSyntaxError: app.css:1:1: Unclosed block\n   *                  //    > 1 | a {\n   *                  //        | ^\"\n   *\n   * @return {string} Error position, message and source code.\n   */\n\n\n  CssSyntaxError.prototype.toString = function toString() {\n    var code = this.showSourceCode();\n    if (code) {\n      code = '\\n\\n' + code + '\\n';\n    }\n    return this.name + ': ' + this.message + code;\n  };\n\n  /**\n   * @memberof CssSyntaxError#\n   * @member {Input} input Input object with PostCSS internal information\n   *                       about input file. If input has source map\n   *                       from previous tool, PostCSS will use origin\n   *                       (for example, Sass) source. You can use this\n   *                       object to get PostCSS input source.\n   *\n   * @example\n   * error.input.file //=> 'a.css'\n   * error.file       //=> 'a.sass'\n   */\n\n\n  return CssSyntaxError;\n}();\n\nexports.default = CssSyntaxError;\nmodule.exports = exports['default'];\n//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["css-syntax-error.es6"],"names":["CssSyntaxError","message","line","column","source","file","plugin","name","reason","setMessage","Error","captureStackTrace","showSourceCode","color","css","terminalHighlight","supportsColor","stdout","lines","split","start","Math","max","end","min","length","maxWidth","String","mark","text","chalk","red","bold","aside","gray","slice","map","index","number","gutter","spacing","replace","join","toString","code"],"mappings":"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","file":"css-syntax-error.js","sourcesContent":["import supportsColor from 'supports-color'\nimport chalk from 'chalk'\n\nimport terminalHighlight from './terminal-highlight'\n\n/**\n * The CSS parser throws this error for broken CSS.\n *\n * Custom parsers can throw this error for broken custom syntax using\n * the {@link Node#error} method.\n *\n * PostCSS will use the input source map to detect the original error location.\n * If you wrote a Sass file, compiled it to CSS and then parsed it with PostCSS,\n * PostCSS will show the original position in the Sass file.\n *\n * If you need the position in the PostCSS input\n * (e.g., to debug the previous compiler), use `error.input.file`.\n *\n * @example\n * // Catching and checking syntax error\n * try {\n *   postcss.parse('a{')\n * } catch (error) {\n *   if (error.name === 'CssSyntaxError') {\n *     error //=> CssSyntaxError\n *   }\n * }\n *\n * @example\n * // Raising error from plugin\n * throw node.error('Unknown variable', { plugin: 'postcss-vars' })\n */\nclass CssSyntaxError {\n  /**\n   * @param {string} message  Error message.\n   * @param {number} [line]   Source line of the error.\n   * @param {number} [column] Source column of the error.\n   * @param {string} [source] Source code of the broken file.\n   * @param {string} [file]   Absolute path to the broken file.\n   * @param {string} [plugin] PostCSS plugin name, if error came from plugin.\n   */\n  constructor (message, line, column, source, file, plugin) {\n    /**\n     * Always equal to `'CssSyntaxError'`. You should always check error type\n     * by `error.name === 'CssSyntaxError'`\n     * instead of `error instanceof CssSyntaxError`,\n     * because npm could have several PostCSS versions.\n     *\n     * @type {string}\n     *\n     * @example\n     * if (error.name === 'CssSyntaxError') {\n     *   error //=> CssSyntaxError\n     * }\n     */\n    this.name = 'CssSyntaxError'\n    /**\n     * Error message.\n     *\n     * @type {string}\n     *\n     * @example\n     * error.message //=> 'Unclosed block'\n     */\n    this.reason = message\n\n    if (file) {\n      /**\n       * Absolute path to the broken file.\n       *\n       * @type {string}\n       *\n       * @example\n       * error.file       //=> 'a.sass'\n       * error.input.file //=> 'a.css'\n       */\n      this.file = file\n    }\n    if (source) {\n      /**\n       * Source code of the broken file.\n       *\n       * @type {string}\n       *\n       * @example\n       * error.source       //=> 'a { b {} }'\n       * error.input.column //=> 'a b { }'\n       */\n      this.source = source\n    }\n    if (plugin) {\n      /**\n       * Plugin name, if error came from plugin.\n       *\n       * @type {string}\n       *\n       * @example\n       * error.plugin //=> 'postcss-vars'\n       */\n      this.plugin = plugin\n    }\n    if (typeof line !== 'undefined' && typeof column !== 'undefined') {\n      /**\n       * Source line of the error.\n       *\n       * @type {number}\n       *\n       * @example\n       * error.line       //=> 2\n       * error.input.line //=> 4\n       */\n      this.line = line\n      /**\n       * Source column of the error.\n       *\n       * @type {number}\n       *\n       * @example\n       * error.column       //=> 1\n       * error.input.column //=> 4\n       */\n      this.column = column\n    }\n\n    this.setMessage()\n\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, CssSyntaxError)\n    }\n  }\n\n  setMessage () {\n    /**\n     * Full error text in the GNU error format\n     * with plugin, file, line and column.\n     *\n     * @type {string}\n     *\n     * @example\n     * error.message //=> 'a.css:1:1: Unclosed block'\n     */\n    this.message = this.plugin ? this.plugin + ': ' : ''\n    this.message += this.file ? this.file : '<css input>'\n    if (typeof this.line !== 'undefined') {\n      this.message += ':' + this.line + ':' + this.column\n    }\n    this.message += ': ' + this.reason\n  }\n\n  /**\n   * Returns a few lines of CSS source that caused the error.\n   *\n   * If the CSS has an input source map without `sourceContent`,\n   * this method will return an empty string.\n   *\n   * @param {boolean} [color] Whether arrow will be colored red by terminal\n   *                          color codes. By default, PostCSS will detect\n   *                          color support by `process.stdout.isTTY`\n   *                          and `process.env.NODE_DISABLE_COLORS`.\n   *\n   * @example\n   * error.showSourceCode() //=> \"  4 | }\n   *                        //      5 | a {\n   *                        //    > 6 |   bad\n   *                        //        |   ^\n   *                        //      7 | }\n   *                        //      8 | b {\"\n   *\n   * @return {string} Few lines of CSS source that caused the error.\n   */\n  showSourceCode (color) {\n    if (!this.source) return ''\n\n    let css = this.source\n    if (terminalHighlight) {\n      if (typeof color === 'undefined') color = supportsColor.stdout\n      if (color) css = terminalHighlight(css)\n    }\n\n    let lines = css.split(/\\r?\\n/)\n    let start = Math.max(this.line - 3, 0)\n    let end = Math.min(this.line + 2, lines.length)\n\n    let maxWidth = String(end).length\n\n    function mark (text) {\n      if (color && chalk.red) {\n        return chalk.red.bold(text)\n      } else {\n        return text\n      }\n    }\n    function aside (text) {\n      if (color && chalk.gray) {\n        return chalk.gray(text)\n      } else {\n        return text\n      }\n    }\n\n    return lines.slice(start, end).map((line, index) => {\n      let number = start + 1 + index\n      let gutter = ' ' + (' ' + number).slice(-maxWidth) + ' | '\n      if (number === this.line) {\n        let spacing = aside(gutter.replace(/\\d/g, ' ')) +\n          line.slice(0, this.column - 1).replace(/[^\\t]/g, ' ')\n        return mark('>') + aside(gutter) + line + '\\n ' + spacing + mark('^')\n      } else {\n        return ' ' + aside(gutter) + line\n      }\n    }).join('\\n')\n  }\n\n  /**\n   * Returns error position, message and source code of the broken part.\n   *\n   * @example\n   * error.toString() //=> \"CssSyntaxError: app.css:1:1: Unclosed block\n   *                  //    > 1 | a {\n   *                  //        | ^\"\n   *\n   * @return {string} Error position, message and source code.\n   */\n  toString () {\n    let code = this.showSourceCode()\n    if (code) {\n      code = '\\n\\n' + code + '\\n'\n    }\n    return this.name + ': ' + this.message + code\n  }\n\n  /**\n   * @memberof CssSyntaxError#\n   * @member {Input} input Input object with PostCSS internal information\n   *                       about input file. If input has source map\n   *                       from previous tool, PostCSS will use origin\n   *                       (for example, Sass) source. You can use this\n   *                       object to get PostCSS input source.\n   *\n   * @example\n   * error.input.file //=> 'a.css'\n   * error.file       //=> 'a.sass'\n   */\n}\n\nexport default CssSyntaxError\n"]}\n","'use strict';\n\nexports.__esModule = true;\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar DEFAULT_RAW = {\n  colon: ': ',\n  indent: '    ',\n  beforeDecl: '\\n',\n  beforeRule: '\\n',\n  beforeOpen: ' ',\n  beforeClose: '\\n',\n  beforeComment: '\\n',\n  after: '\\n',\n  emptyBody: '',\n  commentLeft: ' ',\n  commentRight: ' '\n};\n\nfunction capitalize(str) {\n  return str[0].toUpperCase() + str.slice(1);\n}\n\nvar Stringifier = function () {\n  function Stringifier(builder) {\n    _classCallCheck(this, Stringifier);\n\n    this.builder = builder;\n  }\n\n  Stringifier.prototype.stringify = function stringify(node, semicolon) {\n    this[node.type](node, semicolon);\n  };\n\n  Stringifier.prototype.root = function root(node) {\n    this.body(node);\n    if (node.raws.after) this.builder(node.raws.after);\n  };\n\n  Stringifier.prototype.comment = function comment(node) {\n    var left = this.raw(node, 'left', 'commentLeft');\n    var right = this.raw(node, 'right', 'commentRight');\n    this.builder('/*' + left + node.text + right + '*/', node);\n  };\n\n  Stringifier.prototype.decl = function decl(node, semicolon) {\n    var between = this.raw(node, 'between', 'colon');\n    var string = node.prop + between + this.rawValue(node, 'value');\n\n    if (node.important) {\n      string += node.raws.important || ' !important';\n    }\n\n    if (semicolon) string += ';';\n    this.builder(string, node);\n  };\n\n  Stringifier.prototype.rule = function rule(node) {\n    this.block(node, this.rawValue(node, 'selector'));\n    if (node.raws.ownSemicolon) {\n      this.builder(node.raws.ownSemicolon, node, 'end');\n    }\n  };\n\n  Stringifier.prototype.atrule = function atrule(node, semicolon) {\n    var name = '@' + node.name;\n    var params = node.params ? this.rawValue(node, 'params') : '';\n\n    if (typeof node.raws.afterName !== 'undefined') {\n      name += node.raws.afterName;\n    } else if (params) {\n      name += ' ';\n    }\n\n    if (node.nodes) {\n      this.block(node, name + params);\n    } else {\n      var end = (node.raws.between || '') + (semicolon ? ';' : '');\n      this.builder(name + params + end, node);\n    }\n  };\n\n  Stringifier.prototype.body = function body(node) {\n    var last = node.nodes.length - 1;\n    while (last > 0) {\n      if (node.nodes[last].type !== 'comment') break;\n      last -= 1;\n    }\n\n    var semicolon = this.raw(node, 'semicolon');\n    for (var i = 0; i < node.nodes.length; i++) {\n      var child = node.nodes[i];\n      var before = this.raw(child, 'before');\n      if (before) this.builder(before);\n      this.stringify(child, last !== i || semicolon);\n    }\n  };\n\n  Stringifier.prototype.block = function block(node, start) {\n    var between = this.raw(node, 'between', 'beforeOpen');\n    this.builder(start + between + '{', node, 'start');\n\n    var after = void 0;\n    if (node.nodes && node.nodes.length) {\n      this.body(node);\n      after = this.raw(node, 'after');\n    } else {\n      after = this.raw(node, 'after', 'emptyBody');\n    }\n\n    if (after) this.builder(after);\n    this.builder('}', node, 'end');\n  };\n\n  Stringifier.prototype.raw = function raw(node, own, detect) {\n    var value = void 0;\n    if (!detect) detect = own;\n\n    // Already had\n    if (own) {\n      value = node.raws[own];\n      if (typeof value !== 'undefined') return value;\n    }\n\n    var parent = node.parent;\n\n    // Hack for first rule in CSS\n    if (detect === 'before') {\n      if (!parent || parent.type === 'root' && parent.first === node) {\n        return '';\n      }\n    }\n\n    // Floating child without parent\n    if (!parent) return DEFAULT_RAW[detect];\n\n    // Detect style by other nodes\n    var root = node.root();\n    if (!root.rawCache) root.rawCache = {};\n    if (typeof root.rawCache[detect] !== 'undefined') {\n      return root.rawCache[detect];\n    }\n\n    if (detect === 'before' || detect === 'after') {\n      return this.beforeAfter(node, detect);\n    } else {\n      var method = 'raw' + capitalize(detect);\n      if (this[method]) {\n        value = this[method](root, node);\n      } else {\n        root.walk(function (i) {\n          value = i.raws[own];\n          if (typeof value !== 'undefined') return false;\n        });\n      }\n    }\n\n    if (typeof value === 'undefined') value = DEFAULT_RAW[detect];\n\n    root.rawCache[detect] = value;\n    return value;\n  };\n\n  Stringifier.prototype.rawSemicolon = function rawSemicolon(root) {\n    var value = void 0;\n    root.walk(function (i) {\n      if (i.nodes && i.nodes.length && i.last.type === 'decl') {\n        value = i.raws.semicolon;\n        if (typeof value !== 'undefined') return false;\n      }\n    });\n    return value;\n  };\n\n  Stringifier.prototype.rawEmptyBody = function rawEmptyBody(root) {\n    var value = void 0;\n    root.walk(function (i) {\n      if (i.nodes && i.nodes.length === 0) {\n        value = i.raws.after;\n        if (typeof value !== 'undefined') return false;\n      }\n    });\n    return value;\n  };\n\n  Stringifier.prototype.rawIndent = function rawIndent(root) {\n    if (root.raws.indent) return root.raws.indent;\n    var value = void 0;\n    root.walk(function (i) {\n      var p = i.parent;\n      if (p && p !== root && p.parent && p.parent === root) {\n        if (typeof i.raws.before !== 'undefined') {\n          var parts = i.raws.before.split('\\n');\n          value = parts[parts.length - 1];\n          value = value.replace(/[^\\s]/g, '');\n          return false;\n        }\n      }\n    });\n    return value;\n  };\n\n  Stringifier.prototype.rawBeforeComment = function rawBeforeComment(root, node) {\n    var value = void 0;\n    root.walkComments(function (i) {\n      if (typeof i.raws.before !== 'undefined') {\n        value = i.raws.before;\n        if (value.indexOf('\\n') !== -1) {\n          value = value.replace(/[^\\n]+$/, '');\n        }\n        return false;\n      }\n    });\n    if (typeof value === 'undefined') {\n      value = this.raw(node, null, 'beforeDecl');\n    } else if (value) {\n      value = value.replace(/[^\\s]/g, '');\n    }\n    return value;\n  };\n\n  Stringifier.prototype.rawBeforeDecl = function rawBeforeDecl(root, node) {\n    var value = void 0;\n    root.walkDecls(function (i) {\n      if (typeof i.raws.before !== 'undefined') {\n        value = i.raws.before;\n        if (value.indexOf('\\n') !== -1) {\n          value = value.replace(/[^\\n]+$/, '');\n        }\n        return false;\n      }\n    });\n    if (typeof value === 'undefined') {\n      value = this.raw(node, null, 'beforeRule');\n    } else if (value) {\n      value = value.replace(/[^\\s]/g, '');\n    }\n    return value;\n  };\n\n  Stringifier.prototype.rawBeforeRule = function rawBeforeRule(root) {\n    var value = void 0;\n    root.walk(function (i) {\n      if (i.nodes && (i.parent !== root || root.first !== i)) {\n        if (typeof i.raws.before !== 'undefined') {\n          value = i.raws.before;\n          if (value.indexOf('\\n') !== -1) {\n            value = value.replace(/[^\\n]+$/, '');\n          }\n          return false;\n        }\n      }\n    });\n    if (value) value = value.replace(/[^\\s]/g, '');\n    return value;\n  };\n\n  Stringifier.prototype.rawBeforeClose = function rawBeforeClose(root) {\n    var value = void 0;\n    root.walk(function (i) {\n      if (i.nodes && i.nodes.length > 0) {\n        if (typeof i.raws.after !== 'undefined') {\n          value = i.raws.after;\n          if (value.indexOf('\\n') !== -1) {\n            value = value.replace(/[^\\n]+$/, '');\n          }\n          return false;\n        }\n      }\n    });\n    if (value) value = value.replace(/[^\\s]/g, '');\n    return value;\n  };\n\n  Stringifier.prototype.rawBeforeOpen = function rawBeforeOpen(root) {\n    var value = void 0;\n    root.walk(function (i) {\n      if (i.type !== 'decl') {\n        value = i.raws.between;\n        if (typeof value !== 'undefined') return false;\n      }\n    });\n    return value;\n  };\n\n  Stringifier.prototype.rawColon = function rawColon(root) {\n    var value = void 0;\n    root.walkDecls(function (i) {\n      if (typeof i.raws.between !== 'undefined') {\n        value = i.raws.between.replace(/[^\\s:]/g, '');\n        return false;\n      }\n    });\n    return value;\n  };\n\n  Stringifier.prototype.beforeAfter = function beforeAfter(node, detect) {\n    var value = void 0;\n    if (node.type === 'decl') {\n      value = this.raw(node, null, 'beforeDecl');\n    } else if (node.type === 'comment') {\n      value = this.raw(node, null, 'beforeComment');\n    } else if (detect === 'before') {\n      value = this.raw(node, null, 'beforeRule');\n    } else {\n      value = this.raw(node, null, 'beforeClose');\n    }\n\n    var buf = node.parent;\n    var depth = 0;\n    while (buf && buf.type !== 'root') {\n      depth += 1;\n      buf = buf.parent;\n    }\n\n    if (value.indexOf('\\n') !== -1) {\n      var indent = this.raw(node, null, 'indent');\n      if (indent.length) {\n        for (var step = 0; step < depth; step++) {\n          value += indent;\n        }\n      }\n    }\n\n    return value;\n  };\n\n  Stringifier.prototype.rawValue = function rawValue(node, prop) {\n    var value = node[prop];\n    var raw = node.raws[prop];\n    if (raw && raw.value === value) {\n      return raw.raw;\n    } else {\n      return value;\n    }\n  };\n\n  return Stringifier;\n}();\n\nexports.default = Stringifier;\nmodule.exports = exports['default'];\n//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["stringifier.es6"],"names":["DEFAULT_RAW","colon","indent","beforeDecl","beforeRule","beforeOpen","beforeClose","beforeComment","after","emptyBody","commentLeft","commentRight","capitalize","str","toUpperCase","slice","Stringifier","builder","stringify","node","semicolon","type","root","body","raws","comment","left","raw","right","text","decl","between","string","prop","rawValue","important","rule","block","ownSemicolon","atrule","name","params","afterName","nodes","end","last","length","i","child","before","start","own","detect","value","parent","first","rawCache","beforeAfter","method","walk","rawSemicolon","rawEmptyBody","rawIndent","p","parts","split","replace","rawBeforeComment","walkComments","indexOf","rawBeforeDecl","walkDecls","rawBeforeRule","rawBeforeClose","rawBeforeOpen","rawColon","buf","depth","step"],"mappings":"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","file":"stringifier.js","sourcesContent":["const DEFAULT_RAW = {\n  colon: ': ',\n  indent: '    ',\n  beforeDecl: '\\n',\n  beforeRule: '\\n',\n  beforeOpen: ' ',\n  beforeClose: '\\n',\n  beforeComment: '\\n',\n  after: '\\n',\n  emptyBody: '',\n  commentLeft: ' ',\n  commentRight: ' '\n}\n\nfunction capitalize (str) {\n  return str[0].toUpperCase() + str.slice(1)\n}\n\nclass Stringifier {\n  constructor (builder) {\n    this.builder = builder\n  }\n\n  stringify (node, semicolon) {\n    this[node.type](node, semicolon)\n  }\n\n  root (node) {\n    this.body(node)\n    if (node.raws.after) this.builder(node.raws.after)\n  }\n\n  comment (node) {\n    let left = this.raw(node, 'left', 'commentLeft')\n    let right = this.raw(node, 'right', 'commentRight')\n    this.builder('/*' + left + node.text + right + '*/', node)\n  }\n\n  decl (node, semicolon) {\n    let between = this.raw(node, 'between', 'colon')\n    let string = node.prop + between + this.rawValue(node, 'value')\n\n    if (node.important) {\n      string += node.raws.important || ' !important'\n    }\n\n    if (semicolon) string += ';'\n    this.builder(string, node)\n  }\n\n  rule (node) {\n    this.block(node, this.rawValue(node, 'selector'))\n    if (node.raws.ownSemicolon) {\n      this.builder(node.raws.ownSemicolon, node, 'end')\n    }\n  }\n\n  atrule (node, semicolon) {\n    let name = '@' + node.name\n    let params = node.params ? this.rawValue(node, 'params') : ''\n\n    if (typeof node.raws.afterName !== 'undefined') {\n      name += node.raws.afterName\n    } else if (params) {\n      name += ' '\n    }\n\n    if (node.nodes) {\n      this.block(node, name + params)\n    } else {\n      let end = (node.raws.between || '') + (semicolon ? ';' : '')\n      this.builder(name + params + end, node)\n    }\n  }\n\n  body (node) {\n    let last = node.nodes.length - 1\n    while (last > 0) {\n      if (node.nodes[last].type !== 'comment') break\n      last -= 1\n    }\n\n    let semicolon = this.raw(node, 'semicolon')\n    for (let i = 0; i < node.nodes.length; i++) {\n      let child = node.nodes[i]\n      let before = this.raw(child, 'before')\n      if (before) this.builder(before)\n      this.stringify(child, last !== i || semicolon)\n    }\n  }\n\n  block (node, start) {\n    let between = this.raw(node, 'between', 'beforeOpen')\n    this.builder(start + between + '{', node, 'start')\n\n    let after\n    if (node.nodes && node.nodes.length) {\n      this.body(node)\n      after = this.raw(node, 'after')\n    } else {\n      after = this.raw(node, 'after', 'emptyBody')\n    }\n\n    if (after) this.builder(after)\n    this.builder('}', node, 'end')\n  }\n\n  raw (node, own, detect) {\n    let value\n    if (!detect) detect = own\n\n    // Already had\n    if (own) {\n      value = node.raws[own]\n      if (typeof value !== 'undefined') return value\n    }\n\n    let parent = node.parent\n\n    // Hack for first rule in CSS\n    if (detect === 'before') {\n      if (!parent || (parent.type === 'root' && parent.first === node)) {\n        return ''\n      }\n    }\n\n    // Floating child without parent\n    if (!parent) return DEFAULT_RAW[detect]\n\n    // Detect style by other nodes\n    let root = node.root()\n    if (!root.rawCache) root.rawCache = { }\n    if (typeof root.rawCache[detect] !== 'undefined') {\n      return root.rawCache[detect]\n    }\n\n    if (detect === 'before' || detect === 'after') {\n      return this.beforeAfter(node, detect)\n    } else {\n      let method = 'raw' + capitalize(detect)\n      if (this[method]) {\n        value = this[method](root, node)\n      } else {\n        root.walk(i => {\n          value = i.raws[own]\n          if (typeof value !== 'undefined') return false\n        })\n      }\n    }\n\n    if (typeof value === 'undefined') value = DEFAULT_RAW[detect]\n\n    root.rawCache[detect] = value\n    return value\n  }\n\n  rawSemicolon (root) {\n    let value\n    root.walk(i => {\n      if (i.nodes && i.nodes.length && i.last.type === 'decl') {\n        value = i.raws.semicolon\n        if (typeof value !== 'undefined') return false\n      }\n    })\n    return value\n  }\n\n  rawEmptyBody (root) {\n    let value\n    root.walk(i => {\n      if (i.nodes && i.nodes.length === 0) {\n        value = i.raws.after\n        if (typeof value !== 'undefined') return false\n      }\n    })\n    return value\n  }\n\n  rawIndent (root) {\n    if (root.raws.indent) return root.raws.indent\n    let value\n    root.walk(i => {\n      let p = i.parent\n      if (p && p !== root && p.parent && p.parent === root) {\n        if (typeof i.raws.before !== 'undefined') {\n          let parts = i.raws.before.split('\\n')\n          value = parts[parts.length - 1]\n          value = value.replace(/[^\\s]/g, '')\n          return false\n        }\n      }\n    })\n    return value\n  }\n\n  rawBeforeComment (root, node) {\n    let value\n    root.walkComments(i => {\n      if (typeof i.raws.before !== 'undefined') {\n        value = i.raws.before\n        if (value.indexOf('\\n') !== -1) {\n          value = value.replace(/[^\\n]+$/, '')\n        }\n        return false\n      }\n    })\n    if (typeof value === 'undefined') {\n      value = this.raw(node, null, 'beforeDecl')\n    } else if (value) {\n      value = value.replace(/[^\\s]/g, '')\n    }\n    return value\n  }\n\n  rawBeforeDecl (root, node) {\n    let value\n    root.walkDecls(i => {\n      if (typeof i.raws.before !== 'undefined') {\n        value = i.raws.before\n        if (value.indexOf('\\n') !== -1) {\n          value = value.replace(/[^\\n]+$/, '')\n        }\n        return false\n      }\n    })\n    if (typeof value === 'undefined') {\n      value = this.raw(node, null, 'beforeRule')\n    } else if (value) {\n      value = value.replace(/[^\\s]/g, '')\n    }\n    return value\n  }\n\n  rawBeforeRule (root) {\n    let value\n    root.walk(i => {\n      if (i.nodes && (i.parent !== root || root.first !== i)) {\n        if (typeof i.raws.before !== 'undefined') {\n          value = i.raws.before\n          if (value.indexOf('\\n') !== -1) {\n            value = value.replace(/[^\\n]+$/, '')\n          }\n          return false\n        }\n      }\n    })\n    if (value) value = value.replace(/[^\\s]/g, '')\n    return value\n  }\n\n  rawBeforeClose (root) {\n    let value\n    root.walk(i => {\n      if (i.nodes && i.nodes.length > 0) {\n        if (typeof i.raws.after !== 'undefined') {\n          value = i.raws.after\n          if (value.indexOf('\\n') !== -1) {\n            value = value.replace(/[^\\n]+$/, '')\n          }\n          return false\n        }\n      }\n    })\n    if (value) value = value.replace(/[^\\s]/g, '')\n    return value\n  }\n\n  rawBeforeOpen (root) {\n    let value\n    root.walk(i => {\n      if (i.type !== 'decl') {\n        value = i.raws.between\n        if (typeof value !== 'undefined') return false\n      }\n    })\n    return value\n  }\n\n  rawColon (root) {\n    let value\n    root.walkDecls(i => {\n      if (typeof i.raws.between !== 'undefined') {\n        value = i.raws.between.replace(/[^\\s:]/g, '')\n        return false\n      }\n    })\n    return value\n  }\n\n  beforeAfter (node, detect) {\n    let value\n    if (node.type === 'decl') {\n      value = this.raw(node, null, 'beforeDecl')\n    } else if (node.type === 'comment') {\n      value = this.raw(node, null, 'beforeComment')\n    } else if (detect === 'before') {\n      value = this.raw(node, null, 'beforeRule')\n    } else {\n      value = this.raw(node, null, 'beforeClose')\n    }\n\n    let buf = node.parent\n    let depth = 0\n    while (buf && buf.type !== 'root') {\n      depth += 1\n      buf = buf.parent\n    }\n\n    if (value.indexOf('\\n') !== -1) {\n      let indent = this.raw(node, null, 'indent')\n      if (indent.length) {\n        for (let step = 0; step < depth; step++) value += indent\n      }\n    }\n\n    return value\n  }\n\n  rawValue (node, prop) {\n    let value = node[prop]\n    let raw = node.raws[prop]\n    if (raw && raw.value === value) {\n      return raw.raw\n    } else {\n      return value\n    }\n  }\n}\n\nexport default Stringifier\n"]}\n","'use strict';\n\nexports.__esModule = true;\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nvar _lazyResult = require('./lazy-result');\n\nvar _lazyResult2 = _interopRequireDefault(_lazyResult);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n/**\n * Contains plugins to process CSS. Create one `Processor` instance,\n * initialize its plugins, and then use that instance on numerous CSS files.\n *\n * @example\n * const processor = postcss([autoprefixer, precss])\n * processor.process(css1).then(result => console.log(result.css))\n * processor.process(css2).then(result => console.log(result.css))\n */\nvar Processor = function () {\n  /**\n   * @param {Array.<Plugin|pluginFunction>|Processor} plugins PostCSS plugins.\n   *        See {@link Processor#use} for plugin format.\n   */\n  function Processor() {\n    var plugins = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];\n\n    _classCallCheck(this, Processor);\n\n    /**\n     * Current PostCSS version.\n     *\n     * @type {string}\n     *\n     * @example\n     * if (result.processor.version.split('.')[0] !== '6') {\n     *   throw new Error('This plugin works only with PostCSS 6')\n     * }\n     */\n    this.version = '7.0.2';\n    /**\n     * Plugins added to this processor.\n     *\n     * @type {pluginFunction[]}\n     *\n     * @example\n     * const processor = postcss([autoprefixer, precss])\n     * processor.plugins.length //=> 2\n     */\n    this.plugins = this.normalize(plugins);\n  }\n\n  /**\n   * Adds a plugin to be used as a CSS processor.\n   *\n   * PostCSS plugin can be in 4 formats:\n   * * A plugin created by {@link postcss.plugin} method.\n   * * A function. PostCSS will pass the function a @{link Root}\n   *   as the first argument and current {@link Result} instance\n   *   as the second.\n   * * An object with a `postcss` method. PostCSS will use that method\n   *   as described in #2.\n   * * Another {@link Processor} instance. PostCSS will copy plugins\n   *   from that instance into this one.\n   *\n   * Plugins can also be added by passing them as arguments when creating\n   * a `postcss` instance (see [`postcss(plugins)`]).\n   *\n   * Asynchronous plugins should return a `Promise` instance.\n   *\n   * @param {Plugin|pluginFunction|Processor} plugin PostCSS plugin\n   *                                                 or {@link Processor}\n   *                                                 with plugins.\n   *\n   * @example\n   * const processor = postcss()\n   *   .use(autoprefixer)\n   *   .use(precss)\n   *\n   * @return {Processes} Current processor to make methods chain.\n   */\n\n\n  Processor.prototype.use = function use(plugin) {\n    this.plugins = this.plugins.concat(this.normalize([plugin]));\n    return this;\n  };\n\n  /**\n   * Parses source CSS and returns a {@link LazyResult} Promise proxy.\n   * Because some plugins can be asynchronous it doesn’t make\n   * any transformations. Transformations will be applied\n   * in the {@link LazyResult} methods.\n   *\n   * @param {string|toString|Result} css String with input CSS or any object\n   *                                     with a `toString()` method,\n   *                                     like a Buffer. Optionally, send\n   *                                     a {@link Result} instance\n   *                                     and the processor will take\n   *                                     the {@link Root} from it.\n   * @param {processOptions} [opts]      Options.\n   *\n   * @return {LazyResult} Promise proxy.\n   *\n   * @example\n   * processor.process(css, { from: 'a.css', to: 'a.out.css' })\n   *   .then(result => {\n   *      console.log(result.css)\n   *   })\n   */\n\n\n  Processor.prototype.process = function (_process) {\n    function process(_x) {\n      return _process.apply(this, arguments);\n    }\n\n    process.toString = function () {\n      return _process.toString();\n    };\n\n    return process;\n  }(function (css) {\n    var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    if (this.plugins.length === 0 && opts.parser === opts.stringifier) {\n      if (process.env.NODE_ENV !== 'production') {\n        if (typeof console !== 'undefined' && console.warn) {\n          console.warn('You did not set any plugins, parser, or stringifier. ' + 'Right now PostCSS do nothing. Pick plugins for your case ' + 'on https://www.postcss.parts/ and use them in postcss.config.js.');\n        }\n      }\n    }\n    return new _lazyResult2.default(this, css, opts);\n  });\n\n  Processor.prototype.normalize = function normalize(plugins) {\n    var normalized = [];\n    for (var _iterator = plugins, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {\n      var _ref;\n\n      if (_isArray) {\n        if (_i >= _iterator.length) break;\n        _ref = _iterator[_i++];\n      } else {\n        _i = _iterator.next();\n        if (_i.done) break;\n        _ref = _i.value;\n      }\n\n      var i = _ref;\n\n      if (i.postcss) i = i.postcss;\n\n      if ((typeof i === 'undefined' ? 'undefined' : _typeof(i)) === 'object' && Array.isArray(i.plugins)) {\n        normalized = normalized.concat(i.plugins);\n      } else if (typeof i === 'function') {\n        normalized.push(i);\n      } else if ((typeof i === 'undefined' ? 'undefined' : _typeof(i)) === 'object' && (i.parse || i.stringify)) {\n        if (process.env.NODE_ENV !== 'production') {\n          throw new Error('PostCSS syntaxes cannot be used as plugins. Instead, please use ' + 'one of the syntax/parser/stringifier options as outlined ' + 'in your PostCSS runner documentation.');\n        }\n      } else {\n        throw new Error(i + ' is not a PostCSS plugin');\n      }\n    }\n    return normalized;\n  };\n\n  return Processor;\n}();\n\nexports.default = Processor;\n\n/**\n * @callback builder\n * @param {string} part          Part of generated CSS connected to this node.\n * @param {Node}   node          AST node.\n * @param {\"start\"|\"end\"} [type] Node’s part type.\n */\n\n/**\n * @callback parser\n *\n * @param {string|toString} css   String with input CSS or any object\n *                                with toString() method, like a Buffer.\n * @param {processOptions} [opts] Options with only `from` and `map` keys.\n *\n * @return {Root} PostCSS AST\n */\n\n/**\n * @callback stringifier\n *\n * @param {Node} node       Start node for stringifing. Usually {@link Root}.\n * @param {builder} builder Function to concatenate CSS from node’s parts\n *                          or generate string and source map.\n *\n * @return {void}\n */\n\n/**\n * @typedef {object} syntax\n * @property {parser} parse          Function to generate AST by string.\n * @property {stringifier} stringify Function to generate string by AST.\n */\n\n/**\n * @typedef {object} toString\n * @property {function} toString\n */\n\n/**\n * @callback pluginFunction\n * @param {Root} root     Parsed input CSS.\n * @param {Result} result Result to set warnings or check other plugins.\n */\n\n/**\n * @typedef {object} Plugin\n * @property {function} postcss PostCSS plugin function.\n */\n\n/**\n * @typedef {object} processOptions\n * @property {string} from             The path of the CSS source file.\n *                                     You should always set `from`,\n *                                     because it is used in source map\n *                                     generation and syntax error messages.\n * @property {string} to               The path where you’ll put the output\n *                                     CSS file. You should always set `to`\n *                                     to generate correct source maps.\n * @property {parser} parser           Function to generate AST by string.\n * @property {stringifier} stringifier Class to generate string by AST.\n * @property {syntax} syntax           Object with `parse` and `stringify`.\n * @property {object} map              Source map options.\n * @property {boolean} map.inline                    Does source map should\n *                                                   be embedded in the output\n *                                                   CSS as a base64-encoded\n *                                                   comment.\n * @property {string|object|false|function} map.prev Source map content\n *                                                   from a previous\n *                                                   processing step\n *                                                   (for example, Sass).\n *                                                   PostCSS will try to find\n *                                                   previous map automatically,\n *                                                   so you could disable it by\n *                                                   `false` value.\n * @property {boolean} map.sourcesContent            Does PostCSS should set\n *                                                   the origin content to map.\n * @property {string|false} map.annotation           Does PostCSS should set\n *                                                   annotation comment to map.\n * @property {string} map.from                       Override `from` in map’s\n *                                                   sources`.\n */\n\nmodule.exports = exports['default'];\n//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["processor.es6"],"names":["Processor","plugins","version","normalize","use","plugin","concat","process","css","opts","length","parser","stringifier","env","NODE_ENV","console","warn","LazyResult","normalized","i","postcss","Array","isArray","push","parse","stringify","Error"],"mappings":";;;;;;AAAA;;;;;;;;AAEA;;;;;;;;;IASMA,S;AACJ;;;;AAIA,uBAA2B;AAAA,QAAdC,OAAc,uEAAJ,EAAI;;AAAA;;AACzB;;;;;;;;;;AAUA,SAAKC,OAAL,GAAe,OAAf;AACA;;;;;;;;;AASA,SAAKD,OAAL,GAAe,KAAKE,SAAL,CAAeF,OAAf,CAAf;AACD;;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBA6BAG,G,gBAAKC,M,EAAQ;AACX,SAAKJ,OAAL,GAAe,KAAKA,OAAL,CAAaK,MAAb,CAAoB,KAAKH,SAAL,CAAe,CAACE,MAAD,CAAf,CAApB,CAAf;AACA,WAAO,IAAP;AACD,G;;AAED;;;;;;;;;;;;;;;;;;;;;;;;sBAsBAE,O;;;;;;;;;;cAASC,G,EAAiB;AAAA,QAAZC,IAAY,uEAAL,EAAK;;AACxB,QAAI,KAAKR,OAAL,CAAaS,MAAb,KAAwB,CAAxB,IAA6BD,KAAKE,MAAL,KAAgBF,KAAKG,WAAtD,EAAmE;AACjE,UAAIL,QAAQM,GAAR,CAAYC,QAAZ,KAAyB,YAA7B,EAA2C;AACzC,YAAI,OAAOC,OAAP,KAAmB,WAAnB,IAAkCA,QAAQC,IAA9C,EAAoD;AAClDD,kBAAQC,IAAR,CACE,0DACA,2DADA,GAEA,kEAHF;AAKD;AACF;AACF;AACD,WAAO,IAAIC,oBAAJ,CAAe,IAAf,EAAqBT,GAArB,EAA0BC,IAA1B,CAAP;AACD,G;;sBAEDN,S,sBAAWF,O,EAAS;AAClB,QAAIiB,aAAa,EAAjB;AACA,yBAAcjB,OAAd,kHAAuB;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;AAAA,UAAdkB,CAAc;;AACrB,UAAIA,EAAEC,OAAN,EAAeD,IAAIA,EAAEC,OAAN;;AAEf,UAAI,QAAOD,CAAP,yCAAOA,CAAP,OAAa,QAAb,IAAyBE,MAAMC,OAAN,CAAcH,EAAElB,OAAhB,CAA7B,EAAuD;AACrDiB,qBAAaA,WAAWZ,MAAX,CAAkBa,EAAElB,OAApB,CAAb;AACD,OAFD,MAEO,IAAI,OAAOkB,CAAP,KAAa,UAAjB,EAA6B;AAClCD,mBAAWK,IAAX,CAAgBJ,CAAhB;AACD,OAFM,MAEA,IAAI,QAAOA,CAAP,yCAAOA,CAAP,OAAa,QAAb,KAA0BA,EAAEK,KAAF,IAAWL,EAAEM,SAAvC,CAAJ,EAAuD;AAC5D,YAAIlB,QAAQM,GAAR,CAAYC,QAAZ,KAAyB,YAA7B,EAA2C;AACzC,gBAAM,IAAIY,KAAJ,CACJ,qEACA,2DADA,GAEA,uCAHI,CAAN;AAKD;AACF,OARM,MAQA;AACL,cAAM,IAAIA,KAAJ,CAAUP,IAAI,0BAAd,CAAN;AACD;AACF;AACD,WAAOD,UAAP;AACD,G;;;;;kBAGYlB,S;;AAEf;;;;;;;AAOA;;;;;;;;;;AAUA;;;;;;;;;;AAUA;;;;;;AAMA;;;;;AAKA;;;;;;AAMA;;;;;AAKA","file":"processor.js","sourcesContent":["import LazyResult from './lazy-result'\n\n/**\n * Contains plugins to process CSS. Create one `Processor` instance,\n * initialize its plugins, and then use that instance on numerous CSS files.\n *\n * @example\n * const processor = postcss([autoprefixer, precss])\n * processor.process(css1).then(result => console.log(result.css))\n * processor.process(css2).then(result => console.log(result.css))\n */\nclass Processor {\n  /**\n   * @param {Array.<Plugin|pluginFunction>|Processor} plugins PostCSS plugins.\n   *        See {@link Processor#use} for plugin format.\n   */\n  constructor (plugins = []) {\n    /**\n     * Current PostCSS version.\n     *\n     * @type {string}\n     *\n     * @example\n     * if (result.processor.version.split('.')[0] !== '6') {\n     *   throw new Error('This plugin works only with PostCSS 6')\n     * }\n     */\n    this.version = '7.0.2'\n    /**\n     * Plugins added to this processor.\n     *\n     * @type {pluginFunction[]}\n     *\n     * @example\n     * const processor = postcss([autoprefixer, precss])\n     * processor.plugins.length //=> 2\n     */\n    this.plugins = this.normalize(plugins)\n  }\n\n  /**\n   * Adds a plugin to be used as a CSS processor.\n   *\n   * PostCSS plugin can be in 4 formats:\n   * * A plugin created by {@link postcss.plugin} method.\n   * * A function. PostCSS will pass the function a @{link Root}\n   *   as the first argument and current {@link Result} instance\n   *   as the second.\n   * * An object with a `postcss` method. PostCSS will use that method\n   *   as described in #2.\n   * * Another {@link Processor} instance. PostCSS will copy plugins\n   *   from that instance into this one.\n   *\n   * Plugins can also be added by passing them as arguments when creating\n   * a `postcss` instance (see [`postcss(plugins)`]).\n   *\n   * Asynchronous plugins should return a `Promise` instance.\n   *\n   * @param {Plugin|pluginFunction|Processor} plugin PostCSS plugin\n   *                                                 or {@link Processor}\n   *                                                 with plugins.\n   *\n   * @example\n   * const processor = postcss()\n   *   .use(autoprefixer)\n   *   .use(precss)\n   *\n   * @return {Processes} Current processor to make methods chain.\n   */\n  use (plugin) {\n    this.plugins = this.plugins.concat(this.normalize([plugin]))\n    return this\n  }\n\n  /**\n   * Parses source CSS and returns a {@link LazyResult} Promise proxy.\n   * Because some plugins can be asynchronous it doesn’t make\n   * any transformations. Transformations will be applied\n   * in the {@link LazyResult} methods.\n   *\n   * @param {string|toString|Result} css String with input CSS or any object\n   *                                     with a `toString()` method,\n   *                                     like a Buffer. Optionally, send\n   *                                     a {@link Result} instance\n   *                                     and the processor will take\n   *                                     the {@link Root} from it.\n   * @param {processOptions} [opts]      Options.\n   *\n   * @return {LazyResult} Promise proxy.\n   *\n   * @example\n   * processor.process(css, { from: 'a.css', to: 'a.out.css' })\n   *   .then(result => {\n   *      console.log(result.css)\n   *   })\n   */\n  process (css, opts = { }) {\n    if (this.plugins.length === 0 && opts.parser === opts.stringifier) {\n      if (process.env.NODE_ENV !== 'production') {\n        if (typeof console !== 'undefined' && console.warn) {\n          console.warn(\n            'You did not set any plugins, parser, or stringifier. ' +\n            'Right now PostCSS do nothing. Pick plugins for your case ' +\n            'on https://www.postcss.parts/ and use them in postcss.config.js.'\n          )\n        }\n      }\n    }\n    return new LazyResult(this, css, opts)\n  }\n\n  normalize (plugins) {\n    let normalized = []\n    for (let i of plugins) {\n      if (i.postcss) i = i.postcss\n\n      if (typeof i === 'object' && Array.isArray(i.plugins)) {\n        normalized = normalized.concat(i.plugins)\n      } else if (typeof i === 'function') {\n        normalized.push(i)\n      } else if (typeof i === 'object' && (i.parse || i.stringify)) {\n        if (process.env.NODE_ENV !== 'production') {\n          throw new Error(\n            'PostCSS syntaxes cannot be used as plugins. Instead, please use ' +\n            'one of the syntax/parser/stringifier options as outlined ' +\n            'in your PostCSS runner documentation.'\n          )\n        }\n      } else {\n        throw new Error(i + ' is not a PostCSS plugin')\n      }\n    }\n    return normalized\n  }\n}\n\nexport default Processor\n\n/**\n * @callback builder\n * @param {string} part          Part of generated CSS connected to this node.\n * @param {Node}   node          AST node.\n * @param {\"start\"|\"end\"} [type] Node’s part type.\n */\n\n/**\n * @callback parser\n *\n * @param {string|toString} css   String with input CSS or any object\n *                                with toString() method, like a Buffer.\n * @param {processOptions} [opts] Options with only `from` and `map` keys.\n *\n * @return {Root} PostCSS AST\n */\n\n/**\n * @callback stringifier\n *\n * @param {Node} node       Start node for stringifing. Usually {@link Root}.\n * @param {builder} builder Function to concatenate CSS from node’s parts\n *                          or generate string and source map.\n *\n * @return {void}\n */\n\n/**\n * @typedef {object} syntax\n * @property {parser} parse          Function to generate AST by string.\n * @property {stringifier} stringify Function to generate string by AST.\n */\n\n/**\n * @typedef {object} toString\n * @property {function} toString\n */\n\n/**\n * @callback pluginFunction\n * @param {Root} root     Parsed input CSS.\n * @param {Result} result Result to set warnings or check other plugins.\n */\n\n/**\n * @typedef {object} Plugin\n * @property {function} postcss PostCSS plugin function.\n */\n\n/**\n * @typedef {object} processOptions\n * @property {string} from             The path of the CSS source file.\n *                                     You should always set `from`,\n *                                     because it is used in source map\n *                                     generation and syntax error messages.\n * @property {string} to               The path where you’ll put the output\n *                                     CSS file. You should always set `to`\n *                                     to generate correct source maps.\n * @property {parser} parser           Function to generate AST by string.\n * @property {stringifier} stringifier Class to generate string by AST.\n * @property {syntax} syntax           Object with `parse` and `stringify`.\n * @property {object} map              Source map options.\n * @property {boolean} map.inline                    Does source map should\n *                                                   be embedded in the output\n *                                                   CSS as a base64-encoded\n *                                                   comment.\n * @property {string|object|false|function} map.prev Source map content\n *                                                   from a previous\n *                                                   processing step\n *                                                   (for example, Sass).\n *                                                   PostCSS will try to find\n *                                                   previous map automatically,\n *                                                   so you could disable it by\n *                                                   `false` value.\n * @property {boolean} map.sourcesContent            Does PostCSS should set\n *                                                   the origin content to map.\n * @property {string|false} map.annotation           Does PostCSS should set\n *                                                   annotation comment to map.\n * @property {string} map.from                       Override `from` in map’s\n *                                                   sources`.\n */\n"]}\n","'use strict';\n\nexports.__esModule = true;\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nvar _mapGenerator = require('./map-generator');\n\nvar _mapGenerator2 = _interopRequireDefault(_mapGenerator);\n\nvar _stringify2 = require('./stringify');\n\nvar _stringify3 = _interopRequireDefault(_stringify2);\n\nvar _warnOnce = require('./warn-once');\n\nvar _warnOnce2 = _interopRequireDefault(_warnOnce);\n\nvar _result = require('./result');\n\nvar _result2 = _interopRequireDefault(_result);\n\nvar _parse = require('./parse');\n\nvar _parse2 = _interopRequireDefault(_parse);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction isPromise(obj) {\n  return (typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) === 'object' && typeof obj.then === 'function';\n}\n\n/**\n * A Promise proxy for the result of PostCSS transformations.\n *\n * A `LazyResult` instance is returned by {@link Processor#process}.\n *\n * @example\n * const lazy = postcss([cssnext]).process(css)\n */\n\nvar LazyResult = function () {\n  function LazyResult(processor, css, opts) {\n    _classCallCheck(this, LazyResult);\n\n    this.stringified = false;\n    this.processed = false;\n\n    var root = void 0;\n    if ((typeof css === 'undefined' ? 'undefined' : _typeof(css)) === 'object' && css !== null && css.type === 'root') {\n      root = css;\n    } else if (css instanceof LazyResult || css instanceof _result2.default) {\n      root = css.root;\n      if (css.map) {\n        if (typeof opts.map === 'undefined') opts.map = {};\n        if (!opts.map.inline) opts.map.inline = false;\n        opts.map.prev = css.map;\n      }\n    } else {\n      var parser = _parse2.default;\n      if (opts.syntax) parser = opts.syntax.parse;\n      if (opts.parser) parser = opts.parser;\n      if (parser.parse) parser = parser.parse;\n\n      try {\n        root = parser(css, opts);\n      } catch (error) {\n        this.error = error;\n      }\n    }\n\n    this.result = new _result2.default(processor, root, opts);\n  }\n\n  /**\n   * Returns a {@link Processor} instance, which will be used\n   * for CSS transformations.\n   *\n   * @type {Processor}\n   */\n\n\n  /**\n   * Processes input CSS through synchronous plugins\n   * and calls {@link Result#warnings()}.\n   *\n   * @return {Warning[]} Warnings from plugins.\n   */\n  LazyResult.prototype.warnings = function warnings() {\n    return this.sync().warnings();\n  };\n\n  /**\n   * Alias for the {@link LazyResult#css} property.\n   *\n   * @example\n   * lazy + '' === lazy.css\n   *\n   * @return {string} Output CSS.\n   */\n\n\n  LazyResult.prototype.toString = function toString() {\n    return this.css;\n  };\n\n  /**\n   * Processes input CSS through synchronous and asynchronous plugins\n   * and calls `onFulfilled` with a Result instance. If a plugin throws\n   * an error, the `onRejected` callback will be executed.\n   *\n   * It implements standard Promise API.\n   *\n   * @param {onFulfilled} onFulfilled Callback will be executed\n   *                                  when all plugins will finish work.\n   * @param {onRejected}  onRejected  Callback will be executed on any error.\n   *\n   * @return {Promise} Promise API to make queue.\n   *\n   * @example\n   * postcss([cssnext]).process(css, { from: cssPath }).then(result => {\n   *   console.log(result.css)\n   * })\n   */\n\n\n  LazyResult.prototype.then = function then(onFulfilled, onRejected) {\n    if (process.env.NODE_ENV !== 'production') {\n      if (!('from' in this.opts)) {\n        (0, _warnOnce2.default)('Without `from` option PostCSS could generate wrong source map ' + 'and will not find Browserslist config. Set it to CSS file path ' + 'or to `undefined` to prevent this warning.');\n      }\n    }\n    return this.async().then(onFulfilled, onRejected);\n  };\n\n  /**\n   * Processes input CSS through synchronous and asynchronous plugins\n   * and calls onRejected for each error thrown in any plugin.\n   *\n   * It implements standard Promise API.\n   *\n   * @param {onRejected} onRejected Callback will be executed on any error.\n   *\n   * @return {Promise} Promise API to make queue.\n   *\n   * @example\n   * postcss([cssnext]).process(css).then(result => {\n   *   console.log(result.css)\n   * }).catch(error => {\n   *   console.error(error)\n   * })\n   */\n\n\n  LazyResult.prototype.catch = function _catch(onRejected) {\n    return this.async().catch(onRejected);\n  };\n  /**\n   * Processes input CSS through synchronous and asynchronous plugins\n   * and calls onFinally on any error or when all plugins will finish work.\n   *\n   * It implements standard Promise API.\n   *\n   * @param {onFinally} onFinally Callback will be executed on any error or\n   *                              when all plugins will finish work.\n   *\n   * @return {Promise} Promise API to make queue.\n   *\n   * @example\n   * postcss([cssnext]).process(css).finally(() => {\n   *   console.log('processing ended')\n   * })\n   */\n\n\n  LazyResult.prototype.finally = function _finally(onFinally) {\n    return this.async().then(onFinally, onFinally);\n  };\n\n  LazyResult.prototype.handleError = function handleError(error, plugin) {\n    try {\n      this.error = error;\n      if (error.name === 'CssSyntaxError' && !error.plugin) {\n        error.plugin = plugin.postcssPlugin;\n        error.setMessage();\n      } else if (plugin.postcssVersion) {\n        if (process.env.NODE_ENV !== 'production') {\n          var pluginName = plugin.postcssPlugin;\n          var pluginVer = plugin.postcssVersion;\n          var runtimeVer = this.result.processor.version;\n          var a = pluginVer.split('.');\n          var b = runtimeVer.split('.');\n\n          if (a[0] !== b[0] || parseInt(a[1]) > parseInt(b[1])) {\n            console.error('Unknown error from PostCSS plugin. Your current PostCSS ' + 'version is ' + runtimeVer + ', but ' + pluginName + ' uses ' + pluginVer + '. Perhaps this is the source of the error below.');\n          }\n        }\n      }\n    } catch (err) {\n      if (console && console.error) console.error(err);\n    }\n  };\n\n  LazyResult.prototype.asyncTick = function asyncTick(resolve, reject) {\n    var _this = this;\n\n    if (this.plugin >= this.processor.plugins.length) {\n      this.processed = true;\n      return resolve();\n    }\n\n    try {\n      var plugin = this.processor.plugins[this.plugin];\n      var promise = this.run(plugin);\n      this.plugin += 1;\n\n      if (isPromise(promise)) {\n        promise.then(function () {\n          _this.asyncTick(resolve, reject);\n        }).catch(function (error) {\n          _this.handleError(error, plugin);\n          _this.processed = true;\n          reject(error);\n        });\n      } else {\n        this.asyncTick(resolve, reject);\n      }\n    } catch (error) {\n      this.processed = true;\n      reject(error);\n    }\n  };\n\n  LazyResult.prototype.async = function async() {\n    var _this2 = this;\n\n    if (this.processed) {\n      return new Promise(function (resolve, reject) {\n        if (_this2.error) {\n          reject(_this2.error);\n        } else {\n          resolve(_this2.stringify());\n        }\n      });\n    }\n    if (this.processing) {\n      return this.processing;\n    }\n\n    this.processing = new Promise(function (resolve, reject) {\n      if (_this2.error) return reject(_this2.error);\n      _this2.plugin = 0;\n      _this2.asyncTick(resolve, reject);\n    }).then(function () {\n      _this2.processed = true;\n      return _this2.stringify();\n    });\n\n    return this.processing;\n  };\n\n  LazyResult.prototype.sync = function sync() {\n    if (this.processed) return this.result;\n    this.processed = true;\n\n    if (this.processing) {\n      throw new Error('Use process(css).then(cb) to work with async plugins');\n    }\n\n    if (this.error) throw this.error;\n\n    for (var _iterator = this.result.processor.plugins, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {\n      var _ref;\n\n      if (_isArray) {\n        if (_i >= _iterator.length) break;\n        _ref = _iterator[_i++];\n      } else {\n        _i = _iterator.next();\n        if (_i.done) break;\n        _ref = _i.value;\n      }\n\n      var plugin = _ref;\n\n      var promise = this.run(plugin);\n      if (isPromise(promise)) {\n        throw new Error('Use process(css).then(cb) to work with async plugins');\n      }\n    }\n\n    return this.result;\n  };\n\n  LazyResult.prototype.run = function run(plugin) {\n    this.result.lastPlugin = plugin;\n\n    try {\n      return plugin(this.result.root, this.result);\n    } catch (error) {\n      this.handleError(error, plugin);\n      throw error;\n    }\n  };\n\n  LazyResult.prototype.stringify = function stringify() {\n    if (this.stringified) return this.result;\n    this.stringified = true;\n\n    this.sync();\n\n    var opts = this.result.opts;\n    var str = _stringify3.default;\n    if (opts.syntax) str = opts.syntax.stringify;\n    if (opts.stringifier) str = opts.stringifier;\n    if (str.stringify) str = str.stringify;\n\n    var map = new _mapGenerator2.default(str, this.result.root, this.result.opts);\n    var data = map.generate();\n    this.result.css = data[0];\n    this.result.map = data[1];\n\n    return this.result;\n  };\n\n  _createClass(LazyResult, [{\n    key: 'processor',\n    get: function get() {\n      return this.result.processor;\n    }\n\n    /**\n     * Options from the {@link Processor#process} call.\n     *\n     * @type {processOptions}\n     */\n\n  }, {\n    key: 'opts',\n    get: function get() {\n      return this.result.opts;\n    }\n\n    /**\n     * Processes input CSS through synchronous plugins, converts `Root`\n     * to a CSS string and returns {@link Result#css}.\n     *\n     * This property will only work with synchronous plugins.\n     * If the processor contains any asynchronous plugins\n     * it will throw an error. This is why this method is only\n     * for debug purpose, you should always use {@link LazyResult#then}.\n     *\n     * @type {string}\n     * @see Result#css\n     */\n\n  }, {\n    key: 'css',\n    get: function get() {\n      return this.stringify().css;\n    }\n\n    /**\n     * An alias for the `css` property. Use it with syntaxes\n     * that generate non-CSS output.\n     *\n     * This property will only work with synchronous plugins.\n     * If the processor contains any asynchronous plugins\n     * it will throw an error. This is why this method is only\n     * for debug purpose, you should always use {@link LazyResult#then}.\n     *\n     * @type {string}\n     * @see Result#content\n     */\n\n  }, {\n    key: 'content',\n    get: function get() {\n      return this.stringify().content;\n    }\n\n    /**\n     * Processes input CSS through synchronous plugins\n     * and returns {@link Result#map}.\n     *\n     * This property will only work with synchronous plugins.\n     * If the processor contains any asynchronous plugins\n     * it will throw an error. This is why this method is only\n     * for debug purpose, you should always use {@link LazyResult#then}.\n     *\n     * @type {SourceMapGenerator}\n     * @see Result#map\n     */\n\n  }, {\n    key: 'map',\n    get: function get() {\n      return this.stringify().map;\n    }\n\n    /**\n     * Processes input CSS through synchronous plugins\n     * and returns {@link Result#root}.\n     *\n     * This property will only work with synchronous plugins. If the processor\n     * contains any asynchronous plugins it will throw an error.\n     *\n     * This is why this method is only for debug purpose,\n     * you should always use {@link LazyResult#then}.\n     *\n     * @type {Root}\n     * @see Result#root\n     */\n\n  }, {\n    key: 'root',\n    get: function get() {\n      return this.sync().root;\n    }\n\n    /**\n     * Processes input CSS through synchronous plugins\n     * and returns {@link Result#messages}.\n     *\n     * This property will only work with synchronous plugins. If the processor\n     * contains any asynchronous plugins it will throw an error.\n     *\n     * This is why this method is only for debug purpose,\n     * you should always use {@link LazyResult#then}.\n     *\n     * @type {Message[]}\n     * @see Result#messages\n     */\n\n  }, {\n    key: 'messages',\n    get: function get() {\n      return this.sync().messages;\n    }\n  }]);\n\n  return LazyResult;\n}();\n\nexports.default = LazyResult;\n\n/**\n * @callback onFulfilled\n * @param {Result} result\n */\n\n/**\n * @callback onRejected\n * @param {Error} error\n */\n\nmodule.exports = exports['default'];\n//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lazy-result.es6"],"names":["isPromise","obj","then","LazyResult","processor","css","opts","stringified","processed","root","type","Result","map","inline","prev","parser","parse","syntax","error","result","warnings","sync","toString","onFulfilled","onRejected","process","env","NODE_ENV","async","catch","finally","onFinally","handleError","plugin","name","postcssPlugin","setMessage","postcssVersion","pluginName","pluginVer","runtimeVer","version","a","split","b","parseInt","console","err","asyncTick","resolve","reject","plugins","length","promise","run","Promise","stringify","processing","Error","lastPlugin","str","stringifier","MapGenerator","data","generate","content","messages"],"mappings":";;;;;;;;AAAA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;;;;;AAEA,SAASA,SAAT,CAAoBC,GAApB,EAAyB;AACvB,SAAO,QAAOA,GAAP,yCAAOA,GAAP,OAAe,QAAf,IAA2B,OAAOA,IAAIC,IAAX,KAAoB,UAAtD;AACD;;AAED;;;;;;;;;IAQMC,U;AACJ,sBAAaC,SAAb,EAAwBC,GAAxB,EAA6BC,IAA7B,EAAmC;AAAA;;AACjC,SAAKC,WAAL,GAAmB,KAAnB;AACA,SAAKC,SAAL,GAAiB,KAAjB;;AAEA,QAAIC,aAAJ;AACA,QAAI,QAAOJ,GAAP,yCAAOA,GAAP,OAAe,QAAf,IAA2BA,QAAQ,IAAnC,IAA2CA,IAAIK,IAAJ,KAAa,MAA5D,EAAoE;AAClED,aAAOJ,GAAP;AACD,KAFD,MAEO,IAAIA,eAAeF,UAAf,IAA6BE,eAAeM,gBAAhD,EAAwD;AAC7DF,aAAOJ,IAAII,IAAX;AACA,UAAIJ,IAAIO,GAAR,EAAa;AACX,YAAI,OAAON,KAAKM,GAAZ,KAAoB,WAAxB,EAAqCN,KAAKM,GAAL,GAAW,EAAX;AACrC,YAAI,CAACN,KAAKM,GAAL,CAASC,MAAd,EAAsBP,KAAKM,GAAL,CAASC,MAAT,GAAkB,KAAlB;AACtBP,aAAKM,GAAL,CAASE,IAAT,GAAgBT,IAAIO,GAApB;AACD;AACF,KAPM,MAOA;AACL,UAAIG,SAASC,eAAb;AACA,UAAIV,KAAKW,MAAT,EAAiBF,SAAST,KAAKW,MAAL,CAAYD,KAArB;AACjB,UAAIV,KAAKS,MAAT,EAAiBA,SAAST,KAAKS,MAAd;AACjB,UAAIA,OAAOC,KAAX,EAAkBD,SAASA,OAAOC,KAAhB;;AAElB,UAAI;AACFP,eAAOM,OAAOV,GAAP,EAAYC,IAAZ,CAAP;AACD,OAFD,CAEE,OAAOY,KAAP,EAAc;AACd,aAAKA,KAAL,GAAaA,KAAb;AACD;AACF;;AAED,SAAKC,MAAL,GAAc,IAAIR,gBAAJ,CAAWP,SAAX,EAAsBK,IAAtB,EAA4BH,IAA5B,CAAd;AACD;;AAED;;;;;;;;AAqGA;;;;;;uBAMAc,Q,uBAAY;AACV,WAAO,KAAKC,IAAL,GAAYD,QAAZ,EAAP;AACD,G;;AAED;;;;;;;;;;uBAQAE,Q,uBAAY;AACV,WAAO,KAAKjB,GAAZ;AACD,G;;AAED;;;;;;;;;;;;;;;;;;;;uBAkBAH,I,iBAAMqB,W,EAAaC,U,EAAY;AAC7B,QAAIC,QAAQC,GAAR,CAAYC,QAAZ,KAAyB,YAA7B,EAA2C;AACzC,UAAI,EAAE,UAAU,KAAKrB,IAAjB,CAAJ,EAA4B;AAC1B,gCACE,mEACA,iEADA,GAEA,4CAHF;AAKD;AACF;AACD,WAAO,KAAKsB,KAAL,GAAa1B,IAAb,CAAkBqB,WAAlB,EAA+BC,UAA/B,CAAP;AACD,G;;AAED;;;;;;;;;;;;;;;;;;;uBAiBAK,K,mBAAOL,U,EAAY;AACjB,WAAO,KAAKI,KAAL,GAAaC,KAAb,CAAmBL,UAAnB,CAAP;AACD,G;AACD;;;;;;;;;;;;;;;;;;uBAgBAM,O,qBAASC,S,EAAW;AAClB,WAAO,KAAKH,KAAL,GAAa1B,IAAb,CAAkB6B,SAAlB,EAA6BA,SAA7B,CAAP;AACD,G;;uBAEDC,W,wBAAad,K,EAAOe,M,EAAQ;AAC1B,QAAI;AACF,WAAKf,KAAL,GAAaA,KAAb;AACA,UAAIA,MAAMgB,IAAN,KAAe,gBAAf,IAAmC,CAAChB,MAAMe,MAA9C,EAAsD;AACpDf,cAAMe,MAAN,GAAeA,OAAOE,aAAtB;AACAjB,cAAMkB,UAAN;AACD,OAHD,MAGO,IAAIH,OAAOI,cAAX,EAA2B;AAChC,YAAIZ,QAAQC,GAAR,CAAYC,QAAZ,KAAyB,YAA7B,EAA2C;AACzC,cAAIW,aAAaL,OAAOE,aAAxB;AACA,cAAII,YAAYN,OAAOI,cAAvB;AACA,cAAIG,aAAa,KAAKrB,MAAL,CAAYf,SAAZ,CAAsBqC,OAAvC;AACA,cAAIC,IAAIH,UAAUI,KAAV,CAAgB,GAAhB,CAAR;AACA,cAAIC,IAAIJ,WAAWG,KAAX,CAAiB,GAAjB,CAAR;;AAEA,cAAID,EAAE,CAAF,MAASE,EAAE,CAAF,CAAT,IAAiBC,SAASH,EAAE,CAAF,CAAT,IAAiBG,SAASD,EAAE,CAAF,CAAT,CAAtC,EAAsD;AACpDE,oBAAQ5B,KAAR,CACE,6DACA,aADA,GACgBsB,UADhB,GAC6B,QAD7B,GACwCF,UADxC,GACqD,QADrD,GAEAC,SAFA,GAEY,kDAHd;AAKD;AACF;AACF;AACF,KAtBD,CAsBE,OAAOQ,GAAP,EAAY;AACZ,UAAID,WAAWA,QAAQ5B,KAAvB,EAA8B4B,QAAQ5B,KAAR,CAAc6B,GAAd;AAC/B;AACF,G;;uBAEDC,S,sBAAWC,O,EAASC,M,EAAQ;AAAA;;AAC1B,QAAI,KAAKjB,MAAL,IAAe,KAAK7B,SAAL,CAAe+C,OAAf,CAAuBC,MAA1C,EAAkD;AAChD,WAAK5C,SAAL,GAAiB,IAAjB;AACA,aAAOyC,SAAP;AACD;;AAED,QAAI;AACF,UAAIhB,SAAS,KAAK7B,SAAL,CAAe+C,OAAf,CAAuB,KAAKlB,MAA5B,CAAb;AACA,UAAIoB,UAAU,KAAKC,GAAL,CAASrB,MAAT,CAAd;AACA,WAAKA,MAAL,IAAe,CAAf;;AAEA,UAAIjC,UAAUqD,OAAV,CAAJ,EAAwB;AACtBA,gBAAQnD,IAAR,CAAa,YAAM;AACjB,gBAAK8C,SAAL,CAAeC,OAAf,EAAwBC,MAAxB;AACD,SAFD,EAEGrB,KAFH,CAES,iBAAS;AAChB,gBAAKG,WAAL,CAAiBd,KAAjB,EAAwBe,MAAxB;AACA,gBAAKzB,SAAL,GAAiB,IAAjB;AACA0C,iBAAOhC,KAAP;AACD,SAND;AAOD,OARD,MAQO;AACL,aAAK8B,SAAL,CAAeC,OAAf,EAAwBC,MAAxB;AACD;AACF,KAhBD,CAgBE,OAAOhC,KAAP,EAAc;AACd,WAAKV,SAAL,GAAiB,IAAjB;AACA0C,aAAOhC,KAAP;AACD;AACF,G;;uBAEDU,K,oBAAS;AAAA;;AACP,QAAI,KAAKpB,SAAT,EAAoB;AAClB,aAAO,IAAI+C,OAAJ,CAAY,UAACN,OAAD,EAAUC,MAAV,EAAqB;AACtC,YAAI,OAAKhC,KAAT,EAAgB;AACdgC,iBAAO,OAAKhC,KAAZ;AACD,SAFD,MAEO;AACL+B,kBAAQ,OAAKO,SAAL,EAAR;AACD;AACF,OANM,CAAP;AAOD;AACD,QAAI,KAAKC,UAAT,EAAqB;AACnB,aAAO,KAAKA,UAAZ;AACD;;AAED,SAAKA,UAAL,GAAkB,IAAIF,OAAJ,CAAY,UAACN,OAAD,EAAUC,MAAV,EAAqB;AACjD,UAAI,OAAKhC,KAAT,EAAgB,OAAOgC,OAAO,OAAKhC,KAAZ,CAAP;AAChB,aAAKe,MAAL,GAAc,CAAd;AACA,aAAKe,SAAL,CAAeC,OAAf,EAAwBC,MAAxB;AACD,KAJiB,EAIfhD,IAJe,CAIV,YAAM;AACZ,aAAKM,SAAL,GAAiB,IAAjB;AACA,aAAO,OAAKgD,SAAL,EAAP;AACD,KAPiB,CAAlB;;AASA,WAAO,KAAKC,UAAZ;AACD,G;;uBAEDpC,I,mBAAQ;AACN,QAAI,KAAKb,SAAT,EAAoB,OAAO,KAAKW,MAAZ;AACpB,SAAKX,SAAL,GAAiB,IAAjB;;AAEA,QAAI,KAAKiD,UAAT,EAAqB;AACnB,YAAM,IAAIC,KAAJ,CACJ,sDADI,CAAN;AAED;;AAED,QAAI,KAAKxC,KAAT,EAAgB,MAAM,KAAKA,KAAX;;AAEhB,yBAAmB,KAAKC,MAAL,CAAYf,SAAZ,CAAsB+C,OAAzC,kHAAkD;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;AAAA,UAAzClB,MAAyC;;AAChD,UAAIoB,UAAU,KAAKC,GAAL,CAASrB,MAAT,CAAd;AACA,UAAIjC,UAAUqD,OAAV,CAAJ,EAAwB;AACtB,cAAM,IAAIK,KAAJ,CACJ,sDADI,CAAN;AAED;AACF;;AAED,WAAO,KAAKvC,MAAZ;AACD,G;;uBAEDmC,G,gBAAKrB,M,EAAQ;AACX,SAAKd,MAAL,CAAYwC,UAAZ,GAAyB1B,MAAzB;;AAEA,QAAI;AACF,aAAOA,OAAO,KAAKd,MAAL,CAAYV,IAAnB,EAAyB,KAAKU,MAA9B,CAAP;AACD,KAFD,CAEE,OAAOD,KAAP,EAAc;AACd,WAAKc,WAAL,CAAiBd,KAAjB,EAAwBe,MAAxB;AACA,YAAMf,KAAN;AACD;AACF,G;;uBAEDsC,S,wBAAa;AACX,QAAI,KAAKjD,WAAT,EAAsB,OAAO,KAAKY,MAAZ;AACtB,SAAKZ,WAAL,GAAmB,IAAnB;;AAEA,SAAKc,IAAL;;AAEA,QAAIf,OAAO,KAAKa,MAAL,CAAYb,IAAvB;AACA,QAAIsD,MAAMJ,mBAAV;AACA,QAAIlD,KAAKW,MAAT,EAAiB2C,MAAMtD,KAAKW,MAAL,CAAYuC,SAAlB;AACjB,QAAIlD,KAAKuD,WAAT,EAAsBD,MAAMtD,KAAKuD,WAAX;AACtB,QAAID,IAAIJ,SAAR,EAAmBI,MAAMA,IAAIJ,SAAV;;AAEnB,QAAI5C,MAAM,IAAIkD,sBAAJ,CAAiBF,GAAjB,EAAsB,KAAKzC,MAAL,CAAYV,IAAlC,EAAwC,KAAKU,MAAL,CAAYb,IAApD,CAAV;AACA,QAAIyD,OAAOnD,IAAIoD,QAAJ,EAAX;AACA,SAAK7C,MAAL,CAAYd,GAAZ,GAAkB0D,KAAK,CAAL,CAAlB;AACA,SAAK5C,MAAL,CAAYP,GAAZ,GAAkBmD,KAAK,CAAL,CAAlB;;AAEA,WAAO,KAAK5C,MAAZ;AACD,G;;;;wBAjUgB;AACf,aAAO,KAAKA,MAAL,CAAYf,SAAnB;AACD;;AAED;;;;;;;;wBAKY;AACV,aAAO,KAAKe,MAAL,CAAYb,IAAnB;AACD;;AAED;;;;;;;;;;;;;;;wBAYW;AACT,aAAO,KAAKkD,SAAL,GAAiBnD,GAAxB;AACD;;AAED;;;;;;;;;;;;;;;wBAYe;AACb,aAAO,KAAKmD,SAAL,GAAiBS,OAAxB;AACD;;AAED;;;;;;;;;;;;;;;wBAYW;AACT,aAAO,KAAKT,SAAL,GAAiB5C,GAAxB;AACD;;AAED;;;;;;;;;;;;;;;;wBAaY;AACV,aAAO,KAAKS,IAAL,GAAYZ,IAAnB;AACD;;AAED;;;;;;;;;;;;;;;;wBAagB;AACd,aAAO,KAAKY,IAAL,GAAY6C,QAAnB;AACD;;;;;;kBAuOY/D,U;;AAEf;;;;;AAKA","file":"lazy-result.js","sourcesContent":["import MapGenerator from './map-generator'\nimport stringify from './stringify'\nimport warnOnce from './warn-once'\nimport Result from './result'\nimport parse from './parse'\n\nfunction isPromise (obj) {\n  return typeof obj === 'object' && typeof obj.then === 'function'\n}\n\n/**\n * A Promise proxy for the result of PostCSS transformations.\n *\n * A `LazyResult` instance is returned by {@link Processor#process}.\n *\n * @example\n * const lazy = postcss([cssnext]).process(css)\n */\nclass LazyResult {\n  constructor (processor, css, opts) {\n    this.stringified = false\n    this.processed = false\n\n    let root\n    if (typeof css === 'object' && css !== null && css.type === 'root') {\n      root = css\n    } else if (css instanceof LazyResult || css instanceof Result) {\n      root = css.root\n      if (css.map) {\n        if (typeof opts.map === 'undefined') opts.map = { }\n        if (!opts.map.inline) opts.map.inline = false\n        opts.map.prev = css.map\n      }\n    } else {\n      let parser = parse\n      if (opts.syntax) parser = opts.syntax.parse\n      if (opts.parser) parser = opts.parser\n      if (parser.parse) parser = parser.parse\n\n      try {\n        root = parser(css, opts)\n      } catch (error) {\n        this.error = error\n      }\n    }\n\n    this.result = new Result(processor, root, opts)\n  }\n\n  /**\n   * Returns a {@link Processor} instance, which will be used\n   * for CSS transformations.\n   *\n   * @type {Processor}\n   */\n  get processor () {\n    return this.result.processor\n  }\n\n  /**\n   * Options from the {@link Processor#process} call.\n   *\n   * @type {processOptions}\n   */\n  get opts () {\n    return this.result.opts\n  }\n\n  /**\n   * Processes input CSS through synchronous plugins, converts `Root`\n   * to a CSS string and returns {@link Result#css}.\n   *\n   * This property will only work with synchronous plugins.\n   * If the processor contains any asynchronous plugins\n   * it will throw an error. This is why this method is only\n   * for debug purpose, you should always use {@link LazyResult#then}.\n   *\n   * @type {string}\n   * @see Result#css\n   */\n  get css () {\n    return this.stringify().css\n  }\n\n  /**\n   * An alias for the `css` property. Use it with syntaxes\n   * that generate non-CSS output.\n   *\n   * This property will only work with synchronous plugins.\n   * If the processor contains any asynchronous plugins\n   * it will throw an error. This is why this method is only\n   * for debug purpose, you should always use {@link LazyResult#then}.\n   *\n   * @type {string}\n   * @see Result#content\n   */\n  get content () {\n    return this.stringify().content\n  }\n\n  /**\n   * Processes input CSS through synchronous plugins\n   * and returns {@link Result#map}.\n   *\n   * This property will only work with synchronous plugins.\n   * If the processor contains any asynchronous plugins\n   * it will throw an error. This is why this method is only\n   * for debug purpose, you should always use {@link LazyResult#then}.\n   *\n   * @type {SourceMapGenerator}\n   * @see Result#map\n   */\n  get map () {\n    return this.stringify().map\n  }\n\n  /**\n   * Processes input CSS through synchronous plugins\n   * and returns {@link Result#root}.\n   *\n   * This property will only work with synchronous plugins. If the processor\n   * contains any asynchronous plugins it will throw an error.\n   *\n   * This is why this method is only for debug purpose,\n   * you should always use {@link LazyResult#then}.\n   *\n   * @type {Root}\n   * @see Result#root\n   */\n  get root () {\n    return this.sync().root\n  }\n\n  /**\n   * Processes input CSS through synchronous plugins\n   * and returns {@link Result#messages}.\n   *\n   * This property will only work with synchronous plugins. If the processor\n   * contains any asynchronous plugins it will throw an error.\n   *\n   * This is why this method is only for debug purpose,\n   * you should always use {@link LazyResult#then}.\n   *\n   * @type {Message[]}\n   * @see Result#messages\n   */\n  get messages () {\n    return this.sync().messages\n  }\n\n  /**\n   * Processes input CSS through synchronous plugins\n   * and calls {@link Result#warnings()}.\n   *\n   * @return {Warning[]} Warnings from plugins.\n   */\n  warnings () {\n    return this.sync().warnings()\n  }\n\n  /**\n   * Alias for the {@link LazyResult#css} property.\n   *\n   * @example\n   * lazy + '' === lazy.css\n   *\n   * @return {string} Output CSS.\n   */\n  toString () {\n    return this.css\n  }\n\n  /**\n   * Processes input CSS through synchronous and asynchronous plugins\n   * and calls `onFulfilled` with a Result instance. If a plugin throws\n   * an error, the `onRejected` callback will be executed.\n   *\n   * It implements standard Promise API.\n   *\n   * @param {onFulfilled} onFulfilled Callback will be executed\n   *                                  when all plugins will finish work.\n   * @param {onRejected}  onRejected  Callback will be executed on any error.\n   *\n   * @return {Promise} Promise API to make queue.\n   *\n   * @example\n   * postcss([cssnext]).process(css, { from: cssPath }).then(result => {\n   *   console.log(result.css)\n   * })\n   */\n  then (onFulfilled, onRejected) {\n    if (process.env.NODE_ENV !== 'production') {\n      if (!('from' in this.opts)) {\n        warnOnce(\n          'Without `from` option PostCSS could generate wrong source map ' +\n          'and will not find Browserslist config. Set it to CSS file path ' +\n          'or to `undefined` to prevent this warning.'\n        )\n      }\n    }\n    return this.async().then(onFulfilled, onRejected)\n  }\n\n  /**\n   * Processes input CSS through synchronous and asynchronous plugins\n   * and calls onRejected for each error thrown in any plugin.\n   *\n   * It implements standard Promise API.\n   *\n   * @param {onRejected} onRejected Callback will be executed on any error.\n   *\n   * @return {Promise} Promise API to make queue.\n   *\n   * @example\n   * postcss([cssnext]).process(css).then(result => {\n   *   console.log(result.css)\n   * }).catch(error => {\n   *   console.error(error)\n   * })\n   */\n  catch (onRejected) {\n    return this.async().catch(onRejected)\n  }\n  /**\n   * Processes input CSS through synchronous and asynchronous plugins\n   * and calls onFinally on any error or when all plugins will finish work.\n   *\n   * It implements standard Promise API.\n   *\n   * @param {onFinally} onFinally Callback will be executed on any error or\n   *                              when all plugins will finish work.\n   *\n   * @return {Promise} Promise API to make queue.\n   *\n   * @example\n   * postcss([cssnext]).process(css).finally(() => {\n   *   console.log('processing ended')\n   * })\n   */\n  finally (onFinally) {\n    return this.async().then(onFinally, onFinally)\n  }\n\n  handleError (error, plugin) {\n    try {\n      this.error = error\n      if (error.name === 'CssSyntaxError' && !error.plugin) {\n        error.plugin = plugin.postcssPlugin\n        error.setMessage()\n      } else if (plugin.postcssVersion) {\n        if (process.env.NODE_ENV !== 'production') {\n          let pluginName = plugin.postcssPlugin\n          let pluginVer = plugin.postcssVersion\n          let runtimeVer = this.result.processor.version\n          let a = pluginVer.split('.')\n          let b = runtimeVer.split('.')\n\n          if (a[0] !== b[0] || parseInt(a[1]) > parseInt(b[1])) {\n            console.error(\n              'Unknown error from PostCSS plugin. Your current PostCSS ' +\n              'version is ' + runtimeVer + ', but ' + pluginName + ' uses ' +\n              pluginVer + '. Perhaps this is the source of the error below.'\n            )\n          }\n        }\n      }\n    } catch (err) {\n      if (console && console.error) console.error(err)\n    }\n  }\n\n  asyncTick (resolve, reject) {\n    if (this.plugin >= this.processor.plugins.length) {\n      this.processed = true\n      return resolve()\n    }\n\n    try {\n      let plugin = this.processor.plugins[this.plugin]\n      let promise = this.run(plugin)\n      this.plugin += 1\n\n      if (isPromise(promise)) {\n        promise.then(() => {\n          this.asyncTick(resolve, reject)\n        }).catch(error => {\n          this.handleError(error, plugin)\n          this.processed = true\n          reject(error)\n        })\n      } else {\n        this.asyncTick(resolve, reject)\n      }\n    } catch (error) {\n      this.processed = true\n      reject(error)\n    }\n  }\n\n  async () {\n    if (this.processed) {\n      return new Promise((resolve, reject) => {\n        if (this.error) {\n          reject(this.error)\n        } else {\n          resolve(this.stringify())\n        }\n      })\n    }\n    if (this.processing) {\n      return this.processing\n    }\n\n    this.processing = new Promise((resolve, reject) => {\n      if (this.error) return reject(this.error)\n      this.plugin = 0\n      this.asyncTick(resolve, reject)\n    }).then(() => {\n      this.processed = true\n      return this.stringify()\n    })\n\n    return this.processing\n  }\n\n  sync () {\n    if (this.processed) return this.result\n    this.processed = true\n\n    if (this.processing) {\n      throw new Error(\n        'Use process(css).then(cb) to work with async plugins')\n    }\n\n    if (this.error) throw this.error\n\n    for (let plugin of this.result.processor.plugins) {\n      let promise = this.run(plugin)\n      if (isPromise(promise)) {\n        throw new Error(\n          'Use process(css).then(cb) to work with async plugins')\n      }\n    }\n\n    return this.result\n  }\n\n  run (plugin) {\n    this.result.lastPlugin = plugin\n\n    try {\n      return plugin(this.result.root, this.result)\n    } catch (error) {\n      this.handleError(error, plugin)\n      throw error\n    }\n  }\n\n  stringify () {\n    if (this.stringified) return this.result\n    this.stringified = true\n\n    this.sync()\n\n    let opts = this.result.opts\n    let str = stringify\n    if (opts.syntax) str = opts.syntax.stringify\n    if (opts.stringifier) str = opts.stringifier\n    if (str.stringify) str = str.stringify\n\n    let map = new MapGenerator(str, this.result.root, this.result.opts)\n    let data = map.generate()\n    this.result.css = data[0]\n    this.result.map = data[1]\n\n    return this.result\n  }\n}\n\nexport default LazyResult\n\n/**\n * @callback onFulfilled\n * @param {Result} result\n */\n\n/**\n * @callback onRejected\n * @param {Error} error\n */\n"]}\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\nvar isArray = require('isarray')\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n *     incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\n  ? global.TYPED_ARRAY_SUPPORT\n  : typedArraySupport()\n\n/*\n * Export kMaxLength after typed array support is determined.\n */\nexports.kMaxLength = kMaxLength()\n\nfunction typedArraySupport () {\n  try {\n    var arr = new Uint8Array(1)\n    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}\n    return arr.foo() === 42 && // typed array instances can be augmented\n        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`\n  } catch (e) {\n    return false\n  }\n}\n\nfunction kMaxLength () {\n  return Buffer.TYPED_ARRAY_SUPPORT\n    ? 0x7fffffff\n    : 0x3fffffff\n}\n\nfunction createBuffer (that, length) {\n  if (kMaxLength() < length) {\n    throw new RangeError('Invalid typed array length')\n  }\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = new Uint8Array(length)\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    if (that === null) {\n      that = new Buffer(length)\n    }\n    that.length = length\n  }\n\n  return that\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n    return new Buffer(arg, encodingOrOffset, length)\n  }\n\n  // Common case.\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new Error(\n        'If encoding is specified then the first argument must be a string'\n      )\n    }\n    return allocUnsafe(this, arg)\n  }\n  return from(this, arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\n// TODO: Legacy, not needed anymore. Remove in next major version.\nBuffer._augment = function (arr) {\n  arr.__proto__ = Buffer.prototype\n  return arr\n}\n\nfunction from (that, value, encodingOrOffset, length) {\n  if (typeof value === 'number') {\n    throw new TypeError('\"value\" argument must not be a number')\n  }\n\n  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n    return fromArrayBuffer(that, value, encodingOrOffset, length)\n  }\n\n  if (typeof value === 'string') {\n    return fromString(that, value, encodingOrOffset)\n  }\n\n  return fromObject(that, value)\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n  return from(null, value, encodingOrOffset, length)\n}\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n  Buffer.prototype.__proto__ = Uint8Array.prototype\n  Buffer.__proto__ = Uint8Array\n  if (typeof Symbol !== 'undefined' && Symbol.species &&\n      Buffer[Symbol.species] === Buffer) {\n    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n    Object.defineProperty(Buffer, Symbol.species, {\n      value: null,\n      configurable: true\n    })\n  }\n}\n\nfunction assertSize (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be a number')\n  } else if (size < 0) {\n    throw new RangeError('\"size\" argument must not be negative')\n  }\n}\n\nfunction alloc (that, size, fill, encoding) {\n  assertSize(size)\n  if (size <= 0) {\n    return createBuffer(that, size)\n  }\n  if (fill !== undefined) {\n    // Only pay attention to encoding if it's a string. This\n    // prevents accidentally sending in a number that would\n    // be interpretted as a start offset.\n    return typeof encoding === 'string'\n      ? createBuffer(that, size).fill(fill, encoding)\n      : createBuffer(that, size).fill(fill)\n  }\n  return createBuffer(that, size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n  return alloc(null, size, fill, encoding)\n}\n\nfunction allocUnsafe (that, size) {\n  assertSize(size)\n  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n    for (var i = 0; i < size; ++i) {\n      that[i] = 0\n    }\n  }\n  return that\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n  return allocUnsafe(null, size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n  return allocUnsafe(null, size)\n}\n\nfunction fromString (that, string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8'\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('\"encoding\" must be a valid string encoding')\n  }\n\n  var length = byteLength(string, encoding) | 0\n  that = createBuffer(that, length)\n\n  var actual = that.write(string, encoding)\n\n  if (actual !== length) {\n    // Writing a hex string, for example, that contains invalid characters will\n    // cause everything after the first invalid character to be ignored. (e.g.\n    // 'abxxcd' will be treated as 'ab')\n    that = that.slice(0, actual)\n  }\n\n  return that\n}\n\nfunction fromArrayLike (that, array) {\n  var length = array.length < 0 ? 0 : checked(array.length) | 0\n  that = createBuffer(that, length)\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\nfunction fromArrayBuffer (that, array, byteOffset, length) {\n  array.byteLength // this throws if `array` is not a valid ArrayBuffer\n\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\\'offset\\' is out of bounds')\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\\'length\\' is out of bounds')\n  }\n\n  if (byteOffset === undefined && length === undefined) {\n    array = new Uint8Array(array)\n  } else if (length === undefined) {\n    array = new Uint8Array(array, byteOffset)\n  } else {\n    array = new Uint8Array(array, byteOffset, length)\n  }\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = array\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    that = fromArrayLike(that, array)\n  }\n  return that\n}\n\nfunction fromObject (that, obj) {\n  if (Buffer.isBuffer(obj)) {\n    var len = checked(obj.length) | 0\n    that = createBuffer(that, len)\n\n    if (that.length === 0) {\n      return that\n    }\n\n    obj.copy(that, 0, 0, len)\n    return that\n  }\n\n  if (obj) {\n    if ((typeof ArrayBuffer !== 'undefined' &&\n        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {\n      if (typeof obj.length !== 'number' || isnan(obj.length)) {\n        return createBuffer(that, 0)\n      }\n      return fromArrayLike(that, obj)\n    }\n\n    if (obj.type === 'Buffer' && isArray(obj.data)) {\n      return fromArrayLike(that, obj.data)\n    }\n  }\n\n  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < kMaxLength()` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= kMaxLength()) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + kMaxLength().toString(16) + ' bytes')\n  }\n  return length | 0\n}\n\nfunction SlowBuffer (length) {\n  if (+length != length) { // eslint-disable-line eqeqeq\n    length = 0\n  }\n  return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n  return !!(b != null && b._isBuffer)\n}\n\nBuffer.compare = function compare (a, b) {\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError('Arguments must be Buffers')\n  }\n\n  if (a === b) return 0\n\n  var x = a.length\n  var y = b.length\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i]\n      y = b[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'latin1':\n    case 'binary':\n    case 'base64':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.concat = function concat (list, length) {\n  if (!isArray(list)) {\n    throw new TypeError('\"list\" argument must be an Array of Buffers')\n  }\n\n  if (list.length === 0) {\n    return Buffer.alloc(0)\n  }\n\n  var i\n  if (length === undefined) {\n    length = 0\n    for (i = 0; i < list.length; ++i) {\n      length += list[i].length\n    }\n  }\n\n  var buffer = Buffer.allocUnsafe(length)\n  var pos = 0\n  for (i = 0; i < list.length; ++i) {\n    var buf = list[i]\n    if (!Buffer.isBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers')\n    }\n    buf.copy(buffer, pos)\n    pos += buf.length\n  }\n  return buffer\n}\n\nfunction byteLength (string, encoding) {\n  if (Buffer.isBuffer(string)) {\n    return string.length\n  }\n  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&\n      (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n    return string.byteLength\n  }\n  if (typeof string !== 'string') {\n    string = '' + string\n  }\n\n  var len = string.length\n  if (len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return len\n      case 'utf8':\n      case 'utf-8':\n      case undefined:\n        return utf8ToBytes(string).length\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2\n      case 'hex':\n        return len >>> 1\n      case 'base64':\n        return base64ToBytes(string).length\n      default:\n        if (loweredCase) return utf8ToBytes(string).length // assume utf8\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n  var loweredCase = false\n\n  // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n  // property of a typed array.\n\n  // This behaves neither like String nor Uint8Array in that we set start/end\n  // to their upper/lower bounds if the value passed is out of range.\n  // undefined is handled specially as per ECMA-262 6th Edition,\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n  if (start === undefined || start < 0) {\n    start = 0\n  }\n  // Return early if start > this.length. Done here to prevent potential uint32\n  // coercion fail below.\n  if (start > this.length) {\n    return ''\n  }\n\n  if (end === undefined || end > this.length) {\n    end = this.length\n  }\n\n  if (end <= 0) {\n    return ''\n  }\n\n  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n  end >>>= 0\n  start >>>= 0\n\n  if (end <= start) {\n    return ''\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end)\n\n      case 'ascii':\n        return asciiSlice(this, start, end)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Slice(this, start, end)\n\n      case 'base64':\n        return base64Slice(this, start, end)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = (encoding + '').toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\n// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n// Buffer instances.\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n  var i = b[n]\n  b[n] = b[m]\n  b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n  var len = this.length\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\n  }\n  for (var i = 0; i < len; i += 2) {\n    swap(this, i, i + 1)\n  }\n  return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n  var len = this.length\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\n  }\n  for (var i = 0; i < len; i += 4) {\n    swap(this, i, i + 3)\n    swap(this, i + 1, i + 2)\n  }\n  return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n  var len = this.length\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\n  }\n  for (var i = 0; i < len; i += 8) {\n    swap(this, i, i + 7)\n    swap(this, i + 1, i + 6)\n    swap(this, i + 2, i + 5)\n    swap(this, i + 3, i + 4)\n  }\n  return this\n}\n\nBuffer.prototype.toString = function toString () {\n  var length = this.length | 0\n  if (length === 0) return ''\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\n  return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.equals = function equals (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return true\n  return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n  var str = ''\n  var max = exports.INSPECT_MAX_BYTES\n  if (this.length > 0) {\n    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')\n    if (this.length > max) str += ' ... '\n  }\n  return '<Buffer ' + str + '>'\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n  if (!Buffer.isBuffer(target)) {\n    throw new TypeError('Argument must be a Buffer')\n  }\n\n  if (start === undefined) {\n    start = 0\n  }\n  if (end === undefined) {\n    end = target ? target.length : 0\n  }\n  if (thisStart === undefined) {\n    thisStart = 0\n  }\n  if (thisEnd === undefined) {\n    thisEnd = this.length\n  }\n\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n    throw new RangeError('out of range index')\n  }\n\n  if (thisStart >= thisEnd && start >= end) {\n    return 0\n  }\n  if (thisStart >= thisEnd) {\n    return -1\n  }\n  if (start >= end) {\n    return 1\n  }\n\n  start >>>= 0\n  end >>>= 0\n  thisStart >>>= 0\n  thisEnd >>>= 0\n\n  if (this === target) return 0\n\n  var x = thisEnd - thisStart\n  var y = end - start\n  var len = Math.min(x, y)\n\n  var thisCopy = this.slice(thisStart, thisEnd)\n  var targetCopy = target.slice(start, end)\n\n  for (var i = 0; i < len; ++i) {\n    if (thisCopy[i] !== targetCopy[i]) {\n      x = thisCopy[i]\n      y = targetCopy[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n  // Empty buffer means no match\n  if (buffer.length === 0) return -1\n\n  // Normalize byteOffset\n  if (typeof byteOffset === 'string') {\n    encoding = byteOffset\n    byteOffset = 0\n  } else if (byteOffset > 0x7fffffff) {\n    byteOffset = 0x7fffffff\n  } else if (byteOffset < -0x80000000) {\n    byteOffset = -0x80000000\n  }\n  byteOffset = +byteOffset  // Coerce to Number.\n  if (isNaN(byteOffset)) {\n    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n    byteOffset = dir ? 0 : (buffer.length - 1)\n  }\n\n  // Normalize byteOffset: negative offsets start from the end of the buffer\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n  if (byteOffset >= buffer.length) {\n    if (dir) return -1\n    else byteOffset = buffer.length - 1\n  } else if (byteOffset < 0) {\n    if (dir) byteOffset = 0\n    else return -1\n  }\n\n  // Normalize val\n  if (typeof val === 'string') {\n    val = Buffer.from(val, encoding)\n  }\n\n  // Finally, search either indexOf (if dir is true) or lastIndexOf\n  if (Buffer.isBuffer(val)) {\n    // Special case: looking for empty string/buffer always fails\n    if (val.length === 0) {\n      return -1\n    }\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n  } else if (typeof val === 'number') {\n    val = val & 0xFF // Search for a byte value [0-255]\n    if (Buffer.TYPED_ARRAY_SUPPORT &&\n        typeof Uint8Array.prototype.indexOf === 'function') {\n      if (dir) {\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n      } else {\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n      }\n    }\n    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)\n  }\n\n  throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n  var indexSize = 1\n  var arrLength = arr.length\n  var valLength = val.length\n\n  if (encoding !== undefined) {\n    encoding = String(encoding).toLowerCase()\n    if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n        encoding === 'utf16le' || encoding === 'utf-16le') {\n      if (arr.length < 2 || val.length < 2) {\n        return -1\n      }\n      indexSize = 2\n      arrLength /= 2\n      valLength /= 2\n      byteOffset /= 2\n    }\n  }\n\n  function read (buf, i) {\n    if (indexSize === 1) {\n      return buf[i]\n    } else {\n      return buf.readUInt16BE(i * indexSize)\n    }\n  }\n\n  var i\n  if (dir) {\n    var foundIndex = -1\n    for (i = byteOffset; i < arrLength; i++) {\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n        if (foundIndex === -1) foundIndex = i\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n      } else {\n        if (foundIndex !== -1) i -= i - foundIndex\n        foundIndex = -1\n      }\n    }\n  } else {\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n    for (i = byteOffset; i >= 0; i--) {\n      var found = true\n      for (var j = 0; j < valLength; j++) {\n        if (read(arr, i + j) !== read(val, j)) {\n          found = false\n          break\n        }\n      }\n      if (found) return i\n    }\n  }\n\n  return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n  return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  var remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  // must be an even number of digits\n  var strLen = string.length\n  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  for (var i = 0; i < length; ++i) {\n    var parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (isNaN(parsed)) return i\n    buf[offset + i] = parsed\n  }\n  return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction latin1Write (buf, string, offset, length) {\n  return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8'\n    length = this.length\n    offset = 0\n  // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset\n    length = this.length\n    offset = 0\n  // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset | 0\n    if (isFinite(length)) {\n      length = length | 0\n      if (encoding === undefined) encoding = 'utf8'\n    } else {\n      encoding = length\n      length = undefined\n    }\n  // legacy write(string, encoding, offset, length) - remove in v0.13\n  } else {\n    throw new Error(\n      'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n    )\n  }\n\n  var remaining = this.length - offset\n  if (length === undefined || length > remaining) length = remaining\n\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n    throw new RangeError('Attempt to write outside buffer bounds')\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length)\n\n      case 'ascii':\n        return asciiWrite(this, string, offset, length)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Write(this, string, offset, length)\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\nfunction base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction utf8Slice (buf, start, end) {\n  end = Math.min(buf.length, end)\n  var res = []\n\n  var i = start\n  while (i < end) {\n    var firstByte = buf[i]\n    var codePoint = null\n    var bytesPerSequence = (firstByte > 0xEF) ? 4\n      : (firstByte > 0xDF) ? 3\n      : (firstByte > 0xBF) ? 2\n      : 1\n\n    if (i + bytesPerSequence <= end) {\n      var secondByte, thirdByte, fourthByte, tempCodePoint\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte\n          }\n          break\n        case 2:\n          secondByte = buf[i + 1]\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 3:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 4:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          fourthByte = buf[i + 3]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint\n            }\n          }\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD\n      bytesPerSequence = 1\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n      codePoint = 0xDC00 | codePoint & 0x3FF\n    }\n\n    res.push(codePoint)\n    i += bytesPerSequence\n  }\n\n  return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  var len = codePoints.length\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n  }\n\n  // Decode in chunks to avoid \"call stack size exceeded\".\n  var res = ''\n  var i = 0\n  while (i < len) {\n    res += String.fromCharCode.apply(\n      String,\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n    )\n  }\n  return res\n}\n\nfunction asciiSlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  var len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  var out = ''\n  for (var i = start; i < end; ++i) {\n    out += toHex(buf[i])\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  var bytes = buf.slice(start, end)\n  var res = ''\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n  }\n  return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n  var len = this.length\n  start = ~~start\n  end = end === undefined ? len : ~~end\n\n  if (start < 0) {\n    start += len\n    if (start < 0) start = 0\n  } else if (start > len) {\n    start = len\n  }\n\n  if (end < 0) {\n    end += len\n    if (end < 0) end = 0\n  } else if (end > len) {\n    end = len\n  }\n\n  if (end < start) end = start\n\n  var newBuf\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    newBuf = this.subarray(start, end)\n    newBuf.__proto__ = Buffer.prototype\n  } else {\n    var sliceLen = end - start\n    newBuf = new Buffer(sliceLen, undefined)\n    for (var i = 0; i < sliceLen; ++i) {\n      newBuf[i] = this[i + start]\n    }\n  }\n\n  return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length)\n  }\n\n  var val = this[offset + --byteLength]\n  var mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return ((this[offset]) |\n      (this[offset + 1] << 8) |\n      (this[offset + 2] << 16)) +\n      (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] * 0x1000000) +\n    ((this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var i = byteLength\n  var mul = 1\n  var val = this[offset + --i]\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  if (!(this[offset] & 0x80)) return (this[offset])\n  return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset]) |\n    (this[offset + 1] << 8) |\n    (this[offset + 2] << 16) |\n    (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] << 24) |\n    (this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n  if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var mul = 1\n  var i = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n      (littleEndian ? i : 1 - i) * 8\n  }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffffffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n  }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset + 3] = (value >>> 24)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 1] = (value >>> 8)\n    this[offset] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = 0\n  var mul = 1\n  var sub = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  var sub = 0\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  if (value < 0) value = 0xff + value + 1\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 3] = (value >>> 24)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (value < 0) value = 0xffffffff + value + 1\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n  if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n  return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n  return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (targetStart >= target.length) targetStart = target.length\n  if (!targetStart) targetStart = 0\n  if (end > 0 && end < start) end = start\n\n  // Copy 0 bytes; we're done\n  if (end === start) return 0\n  if (target.length === 0 || this.length === 0) return 0\n\n  // Fatal error conditions\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds')\n  }\n  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length) end = this.length\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start\n  }\n\n  var len = end - start\n  var i\n\n  if (this === target && start < targetStart && targetStart < end) {\n    // descending copy from end\n    for (i = len - 1; i >= 0; --i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n    // ascending copy from start\n    for (i = 0; i < len; ++i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else {\n    Uint8Array.prototype.set.call(\n      target,\n      this.subarray(start, start + len),\n      targetStart\n    )\n  }\n\n  return len\n}\n\n// Usage:\n//    buffer.fill(number[, offset[, end]])\n//    buffer.fill(buffer[, offset[, end]])\n//    buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n  // Handle string cases:\n  if (typeof val === 'string') {\n    if (typeof start === 'string') {\n      encoding = start\n      start = 0\n      end = this.length\n    } else if (typeof end === 'string') {\n      encoding = end\n      end = this.length\n    }\n    if (val.length === 1) {\n      var code = val.charCodeAt(0)\n      if (code < 256) {\n        val = code\n      }\n    }\n    if (encoding !== undefined && typeof encoding !== 'string') {\n      throw new TypeError('encoding must be a string')\n    }\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n      throw new TypeError('Unknown encoding: ' + encoding)\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255\n  }\n\n  // Invalid ranges are not set to a default, so can range check early.\n  if (start < 0 || this.length < start || this.length < end) {\n    throw new RangeError('Out of range index')\n  }\n\n  if (end <= start) {\n    return this\n  }\n\n  start = start >>> 0\n  end = end === undefined ? this.length : end >>> 0\n\n  if (!val) val = 0\n\n  var i\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val\n    }\n  } else {\n    var bytes = Buffer.isBuffer(val)\n      ? val\n      : utf8ToBytes(new Buffer(val, encoding).toString())\n    var len = bytes.length\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n  // Node converts strings with length < 2 to ''\n  if (str.length < 2) return ''\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n  while (str.length % 4 !== 0) {\n    str = str + '='\n  }\n  return str\n}\n\nfunction stringtrim (str) {\n  if (str.trim) return str.trim()\n  return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nfunction toHex (n) {\n  if (n < 16) return '0' + n.toString(16)\n  return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n  units = units || Infinity\n  var codePoint\n  var length = string.length\n  var leadSurrogate = null\n  var bytes = []\n\n  for (var i = 0; i < length; ++i) {\n    codePoint = string.charCodeAt(i)\n\n    // is surrogate component\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        }\n\n        // valid lead\n        leadSurrogate = codePoint\n\n        continue\n      }\n\n      // 2 leads in a row\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n        leadSurrogate = codePoint\n        continue\n      }\n\n      // valid surrogate pair\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n    }\n\n    leadSurrogate = null\n\n    // encode utf8\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break\n      bytes.push(codePoint)\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break\n      bytes.push(\n        codePoint >> 0x6 | 0xC0,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break\n      bytes.push(\n        codePoint >> 0xC | 0xE0,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break\n      bytes.push(\n        codePoint >> 0x12 | 0xF0,\n        codePoint >> 0xC & 0x3F | 0x80,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else {\n      throw new Error('Invalid code point')\n    }\n  }\n\n  return bytes\n}\n\nfunction asciiToBytes (str) {\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n  var c, hi, lo\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    if ((units -= 2) < 0) break\n\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  for (var i = 0; i < length; ++i) {\n    if ((i + offset >= dst.length) || (i >= src.length)) break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n\nfunction isnan (val) {\n  return val !== val // eslint-disable-line no-self-compare\n}\n","/*\n * Copyright 2009-2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE.txt or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\nexports.SourceMapGenerator = require('./lib/source-map-generator').SourceMapGenerator;\nexports.SourceMapConsumer = require('./lib/source-map-consumer').SourceMapConsumer;\nexports.SourceNode = require('./lib/source-node').SourceNode;\n","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar base64VLQ = require('./base64-vlq');\nvar util = require('./util');\nvar ArraySet = require('./array-set').ArraySet;\nvar MappingList = require('./mapping-list').MappingList;\n\n/**\n * An instance of the SourceMapGenerator represents a source map which is\n * being built incrementally. You may pass an object with the following\n * properties:\n *\n *   - file: The filename of the generated source.\n *   - sourceRoot: A root for all relative URLs in this source map.\n */\nfunction SourceMapGenerator(aArgs) {\n  if (!aArgs) {\n    aArgs = {};\n  }\n  this._file = util.getArg(aArgs, 'file', null);\n  this._sourceRoot = util.getArg(aArgs, 'sourceRoot', null);\n  this._skipValidation = util.getArg(aArgs, 'skipValidation', false);\n  this._sources = new ArraySet();\n  this._names = new ArraySet();\n  this._mappings = new MappingList();\n  this._sourcesContents = null;\n}\n\nSourceMapGenerator.prototype._version = 3;\n\n/**\n * Creates a new SourceMapGenerator based on a SourceMapConsumer\n *\n * @param aSourceMapConsumer The SourceMap.\n */\nSourceMapGenerator.fromSourceMap =\n  function SourceMapGenerator_fromSourceMap(aSourceMapConsumer) {\n    var sourceRoot = aSourceMapConsumer.sourceRoot;\n    var generator = new SourceMapGenerator({\n      file: aSourceMapConsumer.file,\n      sourceRoot: sourceRoot\n    });\n    aSourceMapConsumer.eachMapping(function (mapping) {\n      var newMapping = {\n        generated: {\n          line: mapping.generatedLine,\n          column: mapping.generatedColumn\n        }\n      };\n\n      if (mapping.source != null) {\n        newMapping.source = mapping.source;\n        if (sourceRoot != null) {\n          newMapping.source = util.relative(sourceRoot, newMapping.source);\n        }\n\n        newMapping.original = {\n          line: mapping.originalLine,\n          column: mapping.originalColumn\n        };\n\n        if (mapping.name != null) {\n          newMapping.name = mapping.name;\n        }\n      }\n\n      generator.addMapping(newMapping);\n    });\n    aSourceMapConsumer.sources.forEach(function (sourceFile) {\n      var sourceRelative = sourceFile;\n      if (sourceRoot !== null) {\n        sourceRelative = util.relative(sourceRoot, sourceFile);\n      }\n\n      if (!generator._sources.has(sourceRelative)) {\n        generator._sources.add(sourceRelative);\n      }\n\n      var content = aSourceMapConsumer.sourceContentFor(sourceFile);\n      if (content != null) {\n        generator.setSourceContent(sourceFile, content);\n      }\n    });\n    return generator;\n  };\n\n/**\n * Add a single mapping from original source line and column to the generated\n * source's line and column for this source map being created. The mapping\n * object should have the following properties:\n *\n *   - generated: An object with the generated line and column positions.\n *   - original: An object with the original line and column positions.\n *   - source: The original source file (relative to the sourceRoot).\n *   - name: An optional original token name for this mapping.\n */\nSourceMapGenerator.prototype.addMapping =\n  function SourceMapGenerator_addMapping(aArgs) {\n    var generated = util.getArg(aArgs, 'generated');\n    var original = util.getArg(aArgs, 'original', null);\n    var source = util.getArg(aArgs, 'source', null);\n    var name = util.getArg(aArgs, 'name', null);\n\n    if (!this._skipValidation) {\n      this._validateMapping(generated, original, source, name);\n    }\n\n    if (source != null) {\n      source = String(source);\n      if (!this._sources.has(source)) {\n        this._sources.add(source);\n      }\n    }\n\n    if (name != null) {\n      name = String(name);\n      if (!this._names.has(name)) {\n        this._names.add(name);\n      }\n    }\n\n    this._mappings.add({\n      generatedLine: generated.line,\n      generatedColumn: generated.column,\n      originalLine: original != null && original.line,\n      originalColumn: original != null && original.column,\n      source: source,\n      name: name\n    });\n  };\n\n/**\n * Set the source content for a source file.\n */\nSourceMapGenerator.prototype.setSourceContent =\n  function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {\n    var source = aSourceFile;\n    if (this._sourceRoot != null) {\n      source = util.relative(this._sourceRoot, source);\n    }\n\n    if (aSourceContent != null) {\n      // Add the source content to the _sourcesContents map.\n      // Create a new _sourcesContents map if the property is null.\n      if (!this._sourcesContents) {\n        this._sourcesContents = Object.create(null);\n      }\n      this._sourcesContents[util.toSetString(source)] = aSourceContent;\n    } else if (this._sourcesContents) {\n      // Remove the source file from the _sourcesContents map.\n      // If the _sourcesContents map is empty, set the property to null.\n      delete this._sourcesContents[util.toSetString(source)];\n      if (Object.keys(this._sourcesContents).length === 0) {\n        this._sourcesContents = null;\n      }\n    }\n  };\n\n/**\n * Applies the mappings of a sub-source-map for a specific source file to the\n * source map being generated. Each mapping to the supplied source file is\n * rewritten using the supplied source map. Note: The resolution for the\n * resulting mappings is the minimium of this map and the supplied map.\n *\n * @param aSourceMapConsumer The source map to be applied.\n * @param aSourceFile Optional. The filename of the source file.\n *        If omitted, SourceMapConsumer's file property will be used.\n * @param aSourceMapPath Optional. The dirname of the path to the source map\n *        to be applied. If relative, it is relative to the SourceMapConsumer.\n *        This parameter is needed when the two source maps aren't in the same\n *        directory, and the source map to be applied contains relative source\n *        paths. If so, those relative source paths need to be rewritten\n *        relative to the SourceMapGenerator.\n */\nSourceMapGenerator.prototype.applySourceMap =\n  function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {\n    var sourceFile = aSourceFile;\n    // If aSourceFile is omitted, we will use the file property of the SourceMap\n    if (aSourceFile == null) {\n      if (aSourceMapConsumer.file == null) {\n        throw new Error(\n          'SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, ' +\n          'or the source map\\'s \"file\" property. Both were omitted.'\n        );\n      }\n      sourceFile = aSourceMapConsumer.file;\n    }\n    var sourceRoot = this._sourceRoot;\n    // Make \"sourceFile\" relative if an absolute Url is passed.\n    if (sourceRoot != null) {\n      sourceFile = util.relative(sourceRoot, sourceFile);\n    }\n    // Applying the SourceMap can add and remove items from the sources and\n    // the names array.\n    var newSources = new ArraySet();\n    var newNames = new ArraySet();\n\n    // Find mappings for the \"sourceFile\"\n    this._mappings.unsortedForEach(function (mapping) {\n      if (mapping.source === sourceFile && mapping.originalLine != null) {\n        // Check if it can be mapped by the source map, then update the mapping.\n        var original = aSourceMapConsumer.originalPositionFor({\n          line: mapping.originalLine,\n          column: mapping.originalColumn\n        });\n        if (original.source != null) {\n          // Copy mapping\n          mapping.source = original.source;\n          if (aSourceMapPath != null) {\n            mapping.source = util.join(aSourceMapPath, mapping.source)\n          }\n          if (sourceRoot != null) {\n            mapping.source = util.relative(sourceRoot, mapping.source);\n          }\n          mapping.originalLine = original.line;\n          mapping.originalColumn = original.column;\n          if (original.name != null) {\n            mapping.name = original.name;\n          }\n        }\n      }\n\n      var source = mapping.source;\n      if (source != null && !newSources.has(source)) {\n        newSources.add(source);\n      }\n\n      var name = mapping.name;\n      if (name != null && !newNames.has(name)) {\n        newNames.add(name);\n      }\n\n    }, this);\n    this._sources = newSources;\n    this._names = newNames;\n\n    // Copy sourcesContents of applied map.\n    aSourceMapConsumer.sources.forEach(function (sourceFile) {\n      var content = aSourceMapConsumer.sourceContentFor(sourceFile);\n      if (content != null) {\n        if (aSourceMapPath != null) {\n          sourceFile = util.join(aSourceMapPath, sourceFile);\n        }\n        if (sourceRoot != null) {\n          sourceFile = util.relative(sourceRoot, sourceFile);\n        }\n        this.setSourceContent(sourceFile, content);\n      }\n    }, this);\n  };\n\n/**\n * A mapping can have one of the three levels of data:\n *\n *   1. Just the generated position.\n *   2. The Generated position, original position, and original source.\n *   3. Generated and original position, original source, as well as a name\n *      token.\n *\n * To maintain consistency, we validate that any new mapping being added falls\n * in to one of these categories.\n */\nSourceMapGenerator.prototype._validateMapping =\n  function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource,\n                                              aName) {\n    // 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 very\n    // specific error message to try to guide them the right way.\n    // For example: https://github.com/Polymer/polymer-bundler/pull/519\n    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    }\n\n    if (aGenerated && 'line' in aGenerated && 'column' in aGenerated\n        && aGenerated.line > 0 && aGenerated.column >= 0\n        && !aOriginal && !aSource && !aName) {\n      // Case 1.\n      return;\n    }\n    else if (aGenerated && 'line' in aGenerated && 'column' in aGenerated\n             && aOriginal && 'line' in aOriginal && 'column' in aOriginal\n             && aGenerated.line > 0 && aGenerated.column >= 0\n             && aOriginal.line > 0 && aOriginal.column >= 0\n             && aSource) {\n      // Cases 2 and 3.\n      return;\n    }\n    else {\n      throw new Error('Invalid mapping: ' + JSON.stringify({\n        generated: aGenerated,\n        source: aSource,\n        original: aOriginal,\n        name: aName\n      }));\n    }\n  };\n\n/**\n * Serialize the accumulated mappings in to the stream of base 64 VLQs\n * specified by the source map format.\n */\nSourceMapGenerator.prototype._serializeMappings =\n  function SourceMapGenerator_serializeMappings() {\n    var previousGeneratedColumn = 0;\n    var previousGeneratedLine = 1;\n    var previousOriginalColumn = 0;\n    var previousOriginalLine = 0;\n    var previousName = 0;\n    var previousSource = 0;\n    var result = '';\n    var next;\n    var mapping;\n    var nameIdx;\n    var sourceIdx;\n\n    var mappings = this._mappings.toArray();\n    for (var i = 0, len = mappings.length; i < len; i++) {\n      mapping = mappings[i];\n      next = ''\n\n      if (mapping.generatedLine !== previousGeneratedLine) {\n        previousGeneratedColumn = 0;\n        while (mapping.generatedLine !== previousGeneratedLine) {\n          next += ';';\n          previousGeneratedLine++;\n        }\n      }\n      else {\n        if (i > 0) {\n          if (!util.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) {\n            continue;\n          }\n          next += ',';\n        }\n      }\n\n      next += base64VLQ.encode(mapping.generatedColumn\n                                 - previousGeneratedColumn);\n      previousGeneratedColumn = mapping.generatedColumn;\n\n      if (mapping.source != null) {\n        sourceIdx = this._sources.indexOf(mapping.source);\n        next += base64VLQ.encode(sourceIdx - previousSource);\n        previousSource = sourceIdx;\n\n        // lines are stored 0-based in SourceMap spec version 3\n        next += base64VLQ.encode(mapping.originalLine - 1\n                                   - previousOriginalLine);\n        previousOriginalLine = mapping.originalLine - 1;\n\n        next += base64VLQ.encode(mapping.originalColumn\n                                   - previousOriginalColumn);\n        previousOriginalColumn = mapping.originalColumn;\n\n        if (mapping.name != null) {\n          nameIdx = this._names.indexOf(mapping.name);\n          next += base64VLQ.encode(nameIdx - previousName);\n          previousName = nameIdx;\n        }\n      }\n\n      result += next;\n    }\n\n    return result;\n  };\n\nSourceMapGenerator.prototype._generateSourcesContent =\n  function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {\n    return aSources.map(function (source) {\n      if (!this._sourcesContents) {\n        return null;\n      }\n      if (aSourceRoot != null) {\n        source = util.relative(aSourceRoot, source);\n      }\n      var key = util.toSetString(source);\n      return Object.prototype.hasOwnProperty.call(this._sourcesContents, key)\n        ? this._sourcesContents[key]\n        : null;\n    }, this);\n  };\n\n/**\n * Externalize the source map.\n */\nSourceMapGenerator.prototype.toJSON =\n  function SourceMapGenerator_toJSON() {\n    var map = {\n      version: this._version,\n      sources: this._sources.toArray(),\n      names: this._names.toArray(),\n      mappings: this._serializeMappings()\n    };\n    if (this._file != null) {\n      map.file = this._file;\n    }\n    if (this._sourceRoot != null) {\n      map.sourceRoot = this._sourceRoot;\n    }\n    if (this._sourcesContents) {\n      map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);\n    }\n\n    return map;\n  };\n\n/**\n * Render the source map being generated to a string.\n */\nSourceMapGenerator.prototype.toString =\n  function SourceMapGenerator_toString() {\n    return JSON.stringify(this.toJSON());\n  };\n\nexports.SourceMapGenerator = SourceMapGenerator;\n","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n *\n * Based on the Base 64 VLQ implementation in Closure Compiler:\n * https://code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/debugging/sourcemap/Base64VLQ.java\n *\n * Copyright 2011 The Closure Compiler Authors. All rights reserved.\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are\n * met:\n *\n *  * Redistributions of source code must retain the above copyright\n *    notice, this list of conditions and the following disclaimer.\n *  * Redistributions in binary form must reproduce the above\n *    copyright notice, this list of conditions and the following\n *    disclaimer in the documentation and/or other materials provided\n *    with the distribution.\n *  * Neither the name of Google Inc. nor the names of its\n *    contributors may be used to endorse or promote products derived\n *    from this software without specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n * \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n\nvar base64 = require('./base64');\n\n// A single base 64 digit can contain 6 bits of data. For the base 64 variable\n// length quantities we use in the source map spec, the first bit is the sign,\n// the next four bits are the actual value, and the 6th bit is the\n// continuation bit. The continuation bit tells us whether there are more\n// digits in this value following this digit.\n//\n//   Continuation\n//   |    Sign\n//   |    |\n//   V    V\n//   101011\n\nvar VLQ_BASE_SHIFT = 5;\n\n// binary: 100000\nvar VLQ_BASE = 1 << VLQ_BASE_SHIFT;\n\n// binary: 011111\nvar VLQ_BASE_MASK = VLQ_BASE - 1;\n\n// binary: 100000\nvar VLQ_CONTINUATION_BIT = VLQ_BASE;\n\n/**\n * Converts from a two-complement value to a value where the sign bit is\n * placed in the least significant bit.  For example, as decimals:\n *   1 becomes 2 (10 binary), -1 becomes 3 (11 binary)\n *   2 becomes 4 (100 binary), -2 becomes 5 (101 binary)\n */\nfunction toVLQSigned(aValue) {\n  return aValue < 0\n    ? ((-aValue) << 1) + 1\n    : (aValue << 1) + 0;\n}\n\n/**\n * Converts to a two-complement value from a value where the sign bit is\n * placed in the least significant bit.  For example, as decimals:\n *   2 (10 binary) becomes 1, 3 (11 binary) becomes -1\n *   4 (100 binary) becomes 2, 5 (101 binary) becomes -2\n */\nfunction fromVLQSigned(aValue) {\n  var isNegative = (aValue & 1) === 1;\n  var shifted = aValue >> 1;\n  return isNegative\n    ? -shifted\n    : shifted;\n}\n\n/**\n * Returns the base 64 VLQ encoded value.\n */\nexports.encode = function base64VLQ_encode(aValue) {\n  var encoded = \"\";\n  var digit;\n\n  var vlq = toVLQSigned(aValue);\n\n  do {\n    digit = vlq & VLQ_BASE_MASK;\n    vlq >>>= VLQ_BASE_SHIFT;\n    if (vlq > 0) {\n      // There are still more digits in this value, so we must make sure the\n      // continuation bit is marked.\n      digit |= VLQ_CONTINUATION_BIT;\n    }\n    encoded += base64.encode(digit);\n  } while (vlq > 0);\n\n  return encoded;\n};\n\n/**\n * Decodes the next base 64 VLQ value from the given string and returns the\n * value and the rest of the string via the out parameter.\n */\nexports.decode = function base64VLQ_decode(aStr, aIndex, aOutParam) {\n  var strLen = aStr.length;\n  var result = 0;\n  var shift = 0;\n  var continuation, digit;\n\n  do {\n    if (aIndex >= strLen) {\n      throw new Error(\"Expected more digits in base 64 VLQ value.\");\n    }\n\n    digit = base64.decode(aStr.charCodeAt(aIndex++));\n    if (digit === -1) {\n      throw new Error(\"Invalid base64 digit: \" + aStr.charAt(aIndex - 1));\n    }\n\n    continuation = !!(digit & VLQ_CONTINUATION_BIT);\n    digit &= VLQ_BASE_MASK;\n    result = result + (digit << shift);\n    shift += VLQ_BASE_SHIFT;\n  } while (continuation);\n\n  aOutParam.value = fromVLQSigned(result);\n  aOutParam.rest = aIndex;\n};\n","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar util = require('./util');\nvar has = Object.prototype.hasOwnProperty;\nvar hasNativeMap = typeof Map !== \"undefined\";\n\n/**\n * A data structure which is a combination of an array and a set. Adding a new\n * member is O(1), testing for membership is O(1), and finding the index of an\n * element is O(1). Removing elements from the set is not supported. Only\n * strings are supported for membership.\n */\nfunction ArraySet() {\n  this._array = [];\n  this._set = hasNativeMap ? new Map() : Object.create(null);\n}\n\n/**\n * Static method for creating ArraySet instances from an existing array.\n */\nArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {\n  var set = new ArraySet();\n  for (var i = 0, len = aArray.length; i < len; i++) {\n    set.add(aArray[i], aAllowDuplicates);\n  }\n  return set;\n};\n\n/**\n * Return how many unique items are in this ArraySet. If duplicates have been\n * added, than those do not count towards the size.\n *\n * @returns Number\n */\nArraySet.prototype.size = function ArraySet_size() {\n  return hasNativeMap ? this._set.size : Object.getOwnPropertyNames(this._set).length;\n};\n\n/**\n * Add the given string to this set.\n *\n * @param String aStr\n */\nArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {\n  var sStr = 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[sStr] = idx;\n    }\n  }\n};\n\n/**\n * Is the given string a member of this set?\n *\n * @param String aStr\n */\nArraySet.prototype.has = function ArraySet_has(aStr) {\n  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};\n\n/**\n * What is the index of the given string in the array?\n *\n * @param String aStr\n */\nArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {\n  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[sStr];\n    }\n  }\n\n  throw new Error('\"' + aStr + '\" is not in the set.');\n};\n\n/**\n * What is the element at the given index?\n *\n * @param Number aIdx\n */\nArraySet.prototype.at = function ArraySet_at(aIdx) {\n  if (aIdx >= 0 && aIdx < this._array.length) {\n    return this._array[aIdx];\n  }\n  throw new Error('No element indexed by ' + aIdx);\n};\n\n/**\n * Returns the array representation of this set (which has the proper indices\n * indicated by indexOf). Note that this is a copy of the internal array used\n * for storing the members so that no one can mess with internal state.\n */\nArraySet.prototype.toArray = function ArraySet_toArray() {\n  return this._array.slice();\n};\n\nexports.ArraySet = ArraySet;\n","'use strict';\n\nexports.__esModule = true;\n/**\n * Contains helpers for safely splitting lists of CSS values,\n * preserving parentheses and quotes.\n *\n * @example\n * const list = postcss.list\n *\n * @namespace list\n */\nvar list = {\n  split: function split(string, separators, last) {\n    var array = [];\n    var current = '';\n    var split = false;\n\n    var func = 0;\n    var quote = false;\n    var escape = false;\n\n    for (var i = 0; i < string.length; i++) {\n      var letter = string[i];\n\n      if (quote) {\n        if (escape) {\n          escape = false;\n        } else if (letter === '\\\\') {\n          escape = true;\n        } else if (letter === quote) {\n          quote = false;\n        }\n      } else if (letter === '\"' || letter === '\\'') {\n        quote = letter;\n      } else if (letter === '(') {\n        func += 1;\n      } else if (letter === ')') {\n        if (func > 0) func -= 1;\n      } else if (func === 0) {\n        if (separators.indexOf(letter) !== -1) split = true;\n      }\n\n      if (split) {\n        if (current !== '') array.push(current.trim());\n        current = '';\n        split = false;\n      } else {\n        current += letter;\n      }\n    }\n\n    if (last || current !== '') array.push(current.trim());\n    return array;\n  },\n\n\n  /**\n   * Safely splits space-separated values (such as those for `background`,\n   * `border-radius`, and other shorthand properties).\n   *\n   * @param {string} string Space-separated values.\n   *\n   * @return {string[]} Split values.\n   *\n   * @example\n   * postcss.list.space('1px calc(10% + 1px)') //=> ['1px', 'calc(10% + 1px)']\n   */\n  space: function space(string) {\n    var spaces = [' ', '\\n', '\\t'];\n    return list.split(string, spaces);\n  },\n\n\n  /**\n   * Safely splits comma-separated values (such as those for `transition-*`\n   * and `background` properties).\n   *\n   * @param {string} string Comma-separated values.\n   *\n   * @return {string[]} Split values.\n   *\n   * @example\n   * postcss.list.comma('black, linear-gradient(white, black)')\n   * //=> ['black', 'linear-gradient(white, black)']\n   */\n  comma: function comma(string) {\n    return list.split(string, [','], true);\n  }\n};\n\nexports.default = list;\nmodule.exports = exports['default'];\n//# sourceMappingURL=data:application/json;charset=utf8;base64,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\n","'use strict';\n\nexports.__esModule = true;\n\nvar _container = require('./container');\n\nvar _container2 = _interopRequireDefault(_container);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\n/**\n * Represents a CSS file and contains all its parsed nodes.\n *\n * @extends Container\n *\n * @example\n * const root = postcss.parse('a{color:black} b{z-index:2}')\n * root.type         //=> 'root'\n * root.nodes.length //=> 2\n */\nvar Root = function (_Container) {\n  _inherits(Root, _Container);\n\n  function Root(defaults) {\n    _classCallCheck(this, Root);\n\n    var _this = _possibleConstructorReturn(this, _Container.call(this, defaults));\n\n    _this.type = 'root';\n    if (!_this.nodes) _this.nodes = [];\n    return _this;\n  }\n\n  Root.prototype.removeChild = function removeChild(child, ignore) {\n    var index = this.index(child);\n\n    if (!ignore && index === 0 && this.nodes.length > 1) {\n      this.nodes[1].raws.before = this.nodes[index].raws.before;\n    }\n\n    return _Container.prototype.removeChild.call(this, child);\n  };\n\n  Root.prototype.normalize = function normalize(child, sample, type) {\n    var nodes = _Container.prototype.normalize.call(this, child);\n\n    if (sample) {\n      if (type === 'prepend') {\n        if (this.nodes.length > 1) {\n          sample.raws.before = this.nodes[1].raws.before;\n        } else {\n          delete sample.raws.before;\n        }\n      } else if (this.first !== sample) {\n        for (var _iterator = nodes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {\n          var _ref;\n\n          if (_isArray) {\n            if (_i >= _iterator.length) break;\n            _ref = _iterator[_i++];\n          } else {\n            _i = _iterator.next();\n            if (_i.done) break;\n            _ref = _i.value;\n          }\n\n          var node = _ref;\n\n          node.raws.before = sample.raws.before;\n        }\n      }\n    }\n\n    return nodes;\n  };\n\n  /**\n   * Returns a {@link Result} instance representing the root’s CSS.\n   *\n   * @param {processOptions} [opts] Options with only `to` and `map` keys.\n   *\n   * @return {Result} Result with current root’s CSS.\n   *\n   * @example\n   * const root1 = postcss.parse(css1, { from: 'a.css' })\n   * const root2 = postcss.parse(css2, { from: 'b.css' })\n   * root1.append(root2)\n   * const result = root1.toResult({ to: 'all.css', map: true })\n   */\n\n\n  Root.prototype.toResult = function toResult() {\n    var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n\n    var LazyResult = require('./lazy-result');\n    var Processor = require('./processor');\n\n    var lazy = new LazyResult(new Processor(), this, opts);\n    return lazy.stringify();\n  };\n\n  /**\n   * @memberof Root#\n   * @member {object} raws Information to generate byte-to-byte equal\n   *                       node string as it was in the origin input.\n   *\n   * Every parser saves its own properties,\n   * but the default CSS parser uses:\n   *\n   * * `after`: the space symbols after the last child to the end of file.\n   * * `semicolon`: is the last child has an (optional) semicolon.\n   *\n   * @example\n   * postcss.parse('a {}\\n').raws //=> { after: '\\n' }\n   * postcss.parse('a {}').raws   //=> { after: '' }\n   */\n\n\n  return Root;\n}(_container2.default);\n\nexports.default = Root;\nmodule.exports = exports['default'];\n//# sourceMappingURL=data:application/json;charset=utf8;base64,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\n","import parser from './parser';\n\nexport default (editor, opts = {}) => {\n  const options = { ...{\n    // default options\n  },  ...opts };\n\n  editor.setCustomParserCss(parser);\n};\n","import postcss from 'postcss';\n\n/**\n * Log stuff\n * @param  {Editor} editor\n * @param  {*} msg\n */\nexport const log = (editor, msg) =>\n  editor && editor.log(msg, { ns: 'parser-poscss' });\n\n/**\n * Create rule from node\n * @param  {Object} node\n * @return {Object}\n */\nexport const createRule = node => {\n  const declarations = node.nodes || [];\n  const style = {};\n\n  declarations.forEach(({ prop, value, important }) => {\n    style[prop] = value + (important ? ' !important' : '');\n  });\n\n  return {\n    selectors: node.selector || '',\n    style,\n  }\n};\n\n/**\n * Create at rule from node\n * @param  {Object} node\n * @param  {Array<Object>} result\n * @return {Object}\n */\nexport const createAtRule = (node, result) => {\n  const { name, params } = node;\n  const isNested = ['media', 'keyframes'].indexOf(name) >= 0;\n\n  if (isNested) {\n    node.nodes.forEach(node => {\n      result.push({\n        ...createRule(node),\n        atRule: name,\n        params,\n      })\n    });\n  } else {\n    result.push({\n      ...createRule(node),\n      atRule: name,\n    })\n  }\n};\n\nexport default (css, editor) => {\n  const result = [];\n  log(editor, ['Input CSS', css]);\n\n  const ast = postcss.parse(css);\n  log(editor, ['PostCSS AST', ast]);\n\n  ast.nodes.forEach(node => {\n    const { type } = node;\n\n    switch (type) {\n      case 'rule':\n        result.push(createRule(node));\n        break;\n      case 'atrule':\n        createAtRule(node, result);\n        break;\n    }\n  });\n\n  log(editor, ['Output', result]);\n\n  return result;\n}\n","'use strict';\n\nexports.__esModule = true;\n\nvar _declaration = require('./declaration');\n\nvar _declaration2 = _interopRequireDefault(_declaration);\n\nvar _processor = require('./processor');\n\nvar _processor2 = _interopRequireDefault(_processor);\n\nvar _stringify = require('./stringify');\n\nvar _stringify2 = _interopRequireDefault(_stringify);\n\nvar _comment = require('./comment');\n\nvar _comment2 = _interopRequireDefault(_comment);\n\nvar _atRule = require('./at-rule');\n\nvar _atRule2 = _interopRequireDefault(_atRule);\n\nvar _vendor = require('./vendor');\n\nvar _vendor2 = _interopRequireDefault(_vendor);\n\nvar _parse = require('./parse');\n\nvar _parse2 = _interopRequireDefault(_parse);\n\nvar _list = require('./list');\n\nvar _list2 = _interopRequireDefault(_list);\n\nvar _rule = require('./rule');\n\nvar _rule2 = _interopRequireDefault(_rule);\n\nvar _root = require('./root');\n\nvar _root2 = _interopRequireDefault(_root);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/**\n * Create a new {@link Processor} instance that will apply `plugins`\n * as CSS processors.\n *\n * @param {Array.<Plugin|pluginFunction>|Processor} plugins PostCSS plugins.\n *        See {@link Processor#use} for plugin format.\n *\n * @return {Processor} Processor to process multiple CSS.\n *\n * @example\n * import postcss from 'postcss'\n *\n * postcss(plugins).process(css, { from, to }).then(result => {\n *   console.log(result.css)\n * })\n *\n * @namespace postcss\n */\nfunction postcss() {\n  for (var _len = arguments.length, plugins = Array(_len), _key = 0; _key < _len; _key++) {\n    plugins[_key] = arguments[_key];\n  }\n\n  if (plugins.length === 1 && Array.isArray(plugins[0])) {\n    plugins = plugins[0];\n  }\n  return new _processor2.default(plugins);\n}\n\n/**\n * Creates a PostCSS plugin with a standard API.\n *\n * The newly-wrapped function will provide both the name and PostCSS\n * version of the plugin.\n *\n * ```js\n * const processor = postcss([replace])\n * processor.plugins[0].postcssPlugin  //=> 'postcss-replace'\n * processor.plugins[0].postcssVersion //=> '6.0.0'\n * ```\n *\n * The plugin function receives 2 arguments: {@link Root}\n * and {@link Result} instance. The function should mutate the provided\n * `Root` node. Alternatively, you can create a new `Root` node\n * and override the `result.root` property.\n *\n * ```js\n * const cleaner = postcss.plugin('postcss-cleaner', () => {\n *   return (root, result) => {\n *     result.root = postcss.root()\n *   }\n * })\n * ```\n *\n * As a convenience, plugins also expose a `process` method so that you can use\n * them as standalone tools.\n *\n * ```js\n * cleaner.process(css, processOpts, pluginOpts)\n * // This is equivalent to:\n * postcss([ cleaner(pluginOpts) ]).process(css, processOpts)\n * ```\n *\n * Asynchronous plugins should return a `Promise` instance.\n *\n * ```js\n * postcss.plugin('postcss-import', () => {\n *   return (root, result) => {\n *     return new Promise( (resolve, reject) => {\n *       fs.readFile('base.css', (base) => {\n *         root.prepend(base)\n *         resolve()\n *       })\n *     })\n *   }\n * })\n * ```\n *\n * Add warnings using the {@link Node#warn} method.\n * Send data to other plugins using the {@link Result#messages} array.\n *\n * ```js\n * postcss.plugin('postcss-caniuse-test', () => {\n *   return (root, result) => {\n *     root.walkDecls(decl => {\n *       if (!caniuse.support(decl.prop)) {\n *         decl.warn(result, 'Some browsers do not support ' + decl.prop)\n *       }\n *     })\n *   }\n * })\n * ```\n *\n * @param {string} name          PostCSS plugin name. Same as in `name`\n *                               property in `package.json`. It will be saved\n *                               in `plugin.postcssPlugin` property.\n * @param {function} initializer Will receive plugin options\n *                               and should return {@link pluginFunction}\n *\n * @return {Plugin} PostCSS plugin.\n */\npostcss.plugin = function plugin(name, initializer) {\n  function creator() {\n    var transformer = initializer.apply(undefined, arguments);\n    transformer.postcssPlugin = name;\n    transformer.postcssVersion = new _processor2.default().version;\n    return transformer;\n  }\n\n  var cache = void 0;\n  Object.defineProperty(creator, 'postcss', {\n    get: function get() {\n      if (!cache) cache = creator();\n      return cache;\n    }\n  });\n\n  creator.process = function (css, processOpts, pluginOpts) {\n    return postcss([creator(pluginOpts)]).process(css, processOpts);\n  };\n\n  return creator;\n};\n\n/**\n * Default function to convert a node tree into a CSS string.\n *\n * @param {Node} node       Start node for stringifing. Usually {@link Root}.\n * @param {builder} builder Function to concatenate CSS from node’s parts\n *                          or generate string and source map.\n *\n * @return {void}\n *\n * @function\n */\npostcss.stringify = _stringify2.default;\n\n/**\n * Parses source css and returns a new {@link Root} node,\n * which contains the source CSS nodes.\n *\n * @param {string|toString} css   String with input CSS or any object\n *                                with toString() method, like a Buffer\n * @param {processOptions} [opts] Options with only `from` and `map` keys.\n *\n * @return {Root} PostCSS AST.\n *\n * @example\n * // Simple CSS concatenation with source map support\n * const root1 = postcss.parse(css1, { from: file1 })\n * const root2 = postcss.parse(css2, { from: file2 })\n * root1.append(root2).toResult().css\n *\n * @function\n */\npostcss.parse = _parse2.default;\n\n/**\n * Contains the {@link vendor} module.\n *\n * @type {vendor}\n *\n * @example\n * postcss.vendor.unprefixed('-moz-tab') //=> ['tab']\n */\npostcss.vendor = _vendor2.default;\n\n/**\n * Contains the {@link list} module.\n *\n * @member {list}\n *\n * @example\n * postcss.list.space('5px calc(10% + 5px)') //=> ['5px', 'calc(10% + 5px)']\n */\npostcss.list = _list2.default;\n\n/**\n * Creates a new {@link Comment} node.\n *\n * @param {object} [defaults] Properties for the new node.\n *\n * @return {Comment} New comment node\n *\n * @example\n * postcss.comment({ text: 'test' })\n */\npostcss.comment = function (defaults) {\n  return new _comment2.default(defaults);\n};\n\n/**\n * Creates a new {@link AtRule} node.\n *\n * @param {object} [defaults] Properties for the new node.\n *\n * @return {AtRule} new at-rule node\n *\n * @example\n * postcss.atRule({ name: 'charset' }).toString() //=> \"@charset\"\n */\npostcss.atRule = function (defaults) {\n  return new _atRule2.default(defaults);\n};\n\n/**\n * Creates a new {@link Declaration} node.\n *\n * @param {object} [defaults] Properties for the new node.\n *\n * @return {Declaration} new declaration node\n *\n * @example\n * postcss.decl({ prop: 'color', value: 'red' }).toString() //=> \"color: red\"\n */\npostcss.decl = function (defaults) {\n  return new _declaration2.default(defaults);\n};\n\n/**\n * Creates a new {@link Rule} node.\n *\n * @param {object} [defaults] Properties for the new node.\n *\n * @return {Rule} new rule node\n *\n * @example\n * postcss.rule({ selector: 'a' }).toString() //=> \"a {\\n}\"\n */\npostcss.rule = function (defaults) {\n  return new _rule2.default(defaults);\n};\n\n/**\n * Creates a new {@link Root} node.\n *\n * @param {object} [defaults] Properties for the new node.\n *\n * @return {Root} new root node.\n *\n * @example\n * postcss.root({ after: '\\n' }).toString() //=> \"\\n\"\n */\npostcss.root = function (defaults) {\n  return new _root2.default(defaults);\n};\n\nexports.default = postcss;\nmodule.exports = exports['default'];\n//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["postcss.es6"],"names":["postcss","plugins","length","Array","isArray","Processor","plugin","name","initializer","creator","transformer","postcssPlugin","postcssVersion","version","cache","Object","defineProperty","get","process","css","processOpts","pluginOpts","stringify","parse","vendor","list","comment","Comment","defaults","atRule","AtRule","decl","Declaration","rule","Rule","root","Root"],"mappings":";;;;AAAA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;;;AAEA;;;;;;;;;;;;;;;;;;AAkBA,SAASA,OAAT,GAA8B;AAAA,oCAATC,OAAS;AAATA,WAAS;AAAA;;AAC5B,MAAIA,QAAQC,MAAR,KAAmB,CAAnB,IAAwBC,MAAMC,OAAN,CAAcH,QAAQ,CAAR,CAAd,CAA5B,EAAuD;AACrDA,cAAUA,QAAQ,CAAR,CAAV;AACD;AACD,SAAO,IAAII,mBAAJ,CAAcJ,OAAd,CAAP;AACD;;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwEAD,QAAQM,MAAR,GAAiB,SAASA,MAAT,CAAiBC,IAAjB,EAAuBC,WAAvB,EAAoC;AACnD,WAASC,OAAT,GAA2B;AACzB,QAAIC,cAAcF,uCAAlB;AACAE,gBAAYC,aAAZ,GAA4BJ,IAA5B;AACAG,gBAAYE,cAAZ,GAA8B,IAAIP,mBAAJ,EAAD,CAAkBQ,OAA/C;AACA,WAAOH,WAAP;AACD;;AAED,MAAII,cAAJ;AACAC,SAAOC,cAAP,CAAsBP,OAAtB,EAA+B,SAA/B,EAA0C;AACxCQ,OADwC,iBACjC;AACL,UAAI,CAACH,KAAL,EAAYA,QAAQL,SAAR;AACZ,aAAOK,KAAP;AACD;AAJuC,GAA1C;;AAOAL,UAAQS,OAAR,GAAkB,UAAUC,GAAV,EAAeC,WAAf,EAA4BC,UAA5B,EAAwC;AACxD,WAAOrB,QAAQ,CAACS,QAAQY,UAAR,CAAD,CAAR,EAA+BH,OAA/B,CAAuCC,GAAvC,EAA4CC,WAA5C,CAAP;AACD,GAFD;;AAIA,SAAOX,OAAP;AACD,CArBD;;AAuBA;;;;;;;;;;;AAWAT,QAAQsB,SAAR,GAAoBA,mBAApB;;AAEA;;;;;;;;;;;;;;;;;;AAkBAtB,QAAQuB,KAAR,GAAgBA,eAAhB;;AAEA;;;;;;;;AAQAvB,QAAQwB,MAAR,GAAiBA,gBAAjB;;AAEA;;;;;;;;AAQAxB,QAAQyB,IAAR,GAAeA,cAAf;;AAEA;;;;;;;;;;AAUAzB,QAAQ0B,OAAR,GAAkB;AAAA,SAAY,IAAIC,iBAAJ,CAAYC,QAAZ,CAAZ;AAAA,CAAlB;;AAEA;;;;;;;;;;AAUA5B,QAAQ6B,MAAR,GAAiB;AAAA,SAAY,IAAIC,gBAAJ,CAAWF,QAAX,CAAZ;AAAA,CAAjB;;AAEA;;;;;;;;;;AAUA5B,QAAQ+B,IAAR,GAAe;AAAA,SAAY,IAAIC,qBAAJ,CAAgBJ,QAAhB,CAAZ;AAAA,CAAf;;AAEA;;;;;;;;;;AAUA5B,QAAQiC,IAAR,GAAe;AAAA,SAAY,IAAIC,cAAJ,CAASN,QAAT,CAAZ;AAAA,CAAf;;AAEA;;;;;;;;;;AAUA5B,QAAQmC,IAAR,GAAe;AAAA,SAAY,IAAIC,cAAJ,CAASR,QAAT,CAAZ;AAAA,CAAf;;kBAEe5B,O","file":"postcss.js","sourcesContent":["import Declaration from './declaration'\nimport Processor from './processor'\nimport stringify from './stringify'\nimport Comment from './comment'\nimport AtRule from './at-rule'\nimport vendor from './vendor'\nimport parse from './parse'\nimport list from './list'\nimport Rule from './rule'\nimport Root from './root'\n\n/**\n * Create a new {@link Processor} instance that will apply `plugins`\n * as CSS processors.\n *\n * @param {Array.<Plugin|pluginFunction>|Processor} plugins PostCSS plugins.\n *        See {@link Processor#use} for plugin format.\n *\n * @return {Processor} Processor to process multiple CSS.\n *\n * @example\n * import postcss from 'postcss'\n *\n * postcss(plugins).process(css, { from, to }).then(result => {\n *   console.log(result.css)\n * })\n *\n * @namespace postcss\n */\nfunction postcss (...plugins) {\n  if (plugins.length === 1 && Array.isArray(plugins[0])) {\n    plugins = plugins[0]\n  }\n  return new Processor(plugins)\n}\n\n/**\n * Creates a PostCSS plugin with a standard API.\n *\n * The newly-wrapped function will provide both the name and PostCSS\n * version of the plugin.\n *\n * ```js\n * const processor = postcss([replace])\n * processor.plugins[0].postcssPlugin  //=> 'postcss-replace'\n * processor.plugins[0].postcssVersion //=> '6.0.0'\n * ```\n *\n * The plugin function receives 2 arguments: {@link Root}\n * and {@link Result} instance. The function should mutate the provided\n * `Root` node. Alternatively, you can create a new `Root` node\n * and override the `result.root` property.\n *\n * ```js\n * const cleaner = postcss.plugin('postcss-cleaner', () => {\n *   return (root, result) => {\n *     result.root = postcss.root()\n *   }\n * })\n * ```\n *\n * As a convenience, plugins also expose a `process` method so that you can use\n * them as standalone tools.\n *\n * ```js\n * cleaner.process(css, processOpts, pluginOpts)\n * // This is equivalent to:\n * postcss([ cleaner(pluginOpts) ]).process(css, processOpts)\n * ```\n *\n * Asynchronous plugins should return a `Promise` instance.\n *\n * ```js\n * postcss.plugin('postcss-import', () => {\n *   return (root, result) => {\n *     return new Promise( (resolve, reject) => {\n *       fs.readFile('base.css', (base) => {\n *         root.prepend(base)\n *         resolve()\n *       })\n *     })\n *   }\n * })\n * ```\n *\n * Add warnings using the {@link Node#warn} method.\n * Send data to other plugins using the {@link Result#messages} array.\n *\n * ```js\n * postcss.plugin('postcss-caniuse-test', () => {\n *   return (root, result) => {\n *     root.walkDecls(decl => {\n *       if (!caniuse.support(decl.prop)) {\n *         decl.warn(result, 'Some browsers do not support ' + decl.prop)\n *       }\n *     })\n *   }\n * })\n * ```\n *\n * @param {string} name          PostCSS plugin name. Same as in `name`\n *                               property in `package.json`. It will be saved\n *                               in `plugin.postcssPlugin` property.\n * @param {function} initializer Will receive plugin options\n *                               and should return {@link pluginFunction}\n *\n * @return {Plugin} PostCSS plugin.\n */\npostcss.plugin = function plugin (name, initializer) {\n  function creator (...args) {\n    let transformer = initializer(...args)\n    transformer.postcssPlugin = name\n    transformer.postcssVersion = (new Processor()).version\n    return transformer\n  }\n\n  let cache\n  Object.defineProperty(creator, 'postcss', {\n    get () {\n      if (!cache) cache = creator()\n      return cache\n    }\n  })\n\n  creator.process = function (css, processOpts, pluginOpts) {\n    return postcss([creator(pluginOpts)]).process(css, processOpts)\n  }\n\n  return creator\n}\n\n/**\n * Default function to convert a node tree into a CSS string.\n *\n * @param {Node} node       Start node for stringifing. Usually {@link Root}.\n * @param {builder} builder Function to concatenate CSS from node’s parts\n *                          or generate string and source map.\n *\n * @return {void}\n *\n * @function\n */\npostcss.stringify = stringify\n\n/**\n * Parses source css and returns a new {@link Root} node,\n * which contains the source CSS nodes.\n *\n * @param {string|toString} css   String with input CSS or any object\n *                                with toString() method, like a Buffer\n * @param {processOptions} [opts] Options with only `from` and `map` keys.\n *\n * @return {Root} PostCSS AST.\n *\n * @example\n * // Simple CSS concatenation with source map support\n * const root1 = postcss.parse(css1, { from: file1 })\n * const root2 = postcss.parse(css2, { from: file2 })\n * root1.append(root2).toResult().css\n *\n * @function\n */\npostcss.parse = parse\n\n/**\n * Contains the {@link vendor} module.\n *\n * @type {vendor}\n *\n * @example\n * postcss.vendor.unprefixed('-moz-tab') //=> ['tab']\n */\npostcss.vendor = vendor\n\n/**\n * Contains the {@link list} module.\n *\n * @member {list}\n *\n * @example\n * postcss.list.space('5px calc(10% + 5px)') //=> ['5px', 'calc(10% + 5px)']\n */\npostcss.list = list\n\n/**\n * Creates a new {@link Comment} node.\n *\n * @param {object} [defaults] Properties for the new node.\n *\n * @return {Comment} New comment node\n *\n * @example\n * postcss.comment({ text: 'test' })\n */\npostcss.comment = defaults => new Comment(defaults)\n\n/**\n * Creates a new {@link AtRule} node.\n *\n * @param {object} [defaults] Properties for the new node.\n *\n * @return {AtRule} new at-rule node\n *\n * @example\n * postcss.atRule({ name: 'charset' }).toString() //=> \"@charset\"\n */\npostcss.atRule = defaults => new AtRule(defaults)\n\n/**\n * Creates a new {@link Declaration} node.\n *\n * @param {object} [defaults] Properties for the new node.\n *\n * @return {Declaration} new declaration node\n *\n * @example\n * postcss.decl({ prop: 'color', value: 'red' }).toString() //=> \"color: red\"\n */\npostcss.decl = defaults => new Declaration(defaults)\n\n/**\n * Creates a new {@link Rule} node.\n *\n * @param {object} [defaults] Properties for the new node.\n *\n * @return {Rule} new rule node\n *\n * @example\n * postcss.rule({ selector: 'a' }).toString() //=> \"a {\\n}\"\n */\npostcss.rule = defaults => new Rule(defaults)\n\n/**\n * Creates a new {@link Root} node.\n *\n * @param {object} [defaults] Properties for the new node.\n *\n * @return {Root} new root node.\n *\n * @example\n * postcss.root({ after: '\\n' }).toString() //=> \"\\n\"\n */\npostcss.root = defaults => new Root(defaults)\n\nexport default postcss\n"]}\n","'use strict';\n\nexports.__esModule = true;\n\nvar _sourceMap = require('source-map');\n\nvar _sourceMap2 = _interopRequireDefault(_sourceMap);\n\nvar _path = require('path');\n\nvar _path2 = _interopRequireDefault(_path);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar MapGenerator = function () {\n  function MapGenerator(stringify, root, opts) {\n    _classCallCheck(this, MapGenerator);\n\n    this.stringify = stringify;\n    this.mapOpts = opts.map || {};\n    this.root = root;\n    this.opts = opts;\n  }\n\n  MapGenerator.prototype.isMap = function isMap() {\n    if (typeof this.opts.map !== 'undefined') {\n      return !!this.opts.map;\n    } else {\n      return this.previous().length > 0;\n    }\n  };\n\n  MapGenerator.prototype.previous = function previous() {\n    var _this = this;\n\n    if (!this.previousMaps) {\n      this.previousMaps = [];\n      this.root.walk(function (node) {\n        if (node.source && node.source.input.map) {\n          var map = node.source.input.map;\n          if (_this.previousMaps.indexOf(map) === -1) {\n            _this.previousMaps.push(map);\n          }\n        }\n      });\n    }\n\n    return this.previousMaps;\n  };\n\n  MapGenerator.prototype.isInline = function isInline() {\n    if (typeof this.mapOpts.inline !== 'undefined') {\n      return this.mapOpts.inline;\n    }\n\n    var annotation = this.mapOpts.annotation;\n    if (typeof annotation !== 'undefined' && annotation !== true) {\n      return false;\n    }\n\n    if (this.previous().length) {\n      return this.previous().some(function (i) {\n        return i.inline;\n      });\n    } else {\n      return true;\n    }\n  };\n\n  MapGenerator.prototype.isSourcesContent = function isSourcesContent() {\n    if (typeof this.mapOpts.sourcesContent !== 'undefined') {\n      return this.mapOpts.sourcesContent;\n    }\n    if (this.previous().length) {\n      return this.previous().some(function (i) {\n        return i.withContent();\n      });\n    } else {\n      return true;\n    }\n  };\n\n  MapGenerator.prototype.clearAnnotation = function clearAnnotation() {\n    if (this.mapOpts.annotation === false) return;\n\n    var node = void 0;\n    for (var i = this.root.nodes.length - 1; i >= 0; i--) {\n      node = this.root.nodes[i];\n      if (node.type !== 'comment') continue;\n      if (node.text.indexOf('# sourceMappingURL=') === 0) {\n        this.root.removeChild(i);\n      }\n    }\n  };\n\n  MapGenerator.prototype.setSourcesContent = function setSourcesContent() {\n    var _this2 = this;\n\n    var already = {};\n    this.root.walk(function (node) {\n      if (node.source) {\n        var from = node.source.input.from;\n        if (from && !already[from]) {\n          already[from] = true;\n          var relative = _this2.relative(from);\n          _this2.map.setSourceContent(relative, node.source.input.css);\n        }\n      }\n    });\n  };\n\n  MapGenerator.prototype.applyPrevMaps = function applyPrevMaps() {\n    for (var _iterator = this.previous(), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {\n      var _ref;\n\n      if (_isArray) {\n        if (_i >= _iterator.length) break;\n        _ref = _iterator[_i++];\n      } else {\n        _i = _iterator.next();\n        if (_i.done) break;\n        _ref = _i.value;\n      }\n\n      var prev = _ref;\n\n      var from = this.relative(prev.file);\n      var root = prev.root || _path2.default.dirname(prev.file);\n      var map = void 0;\n\n      if (this.mapOpts.sourcesContent === false) {\n        map = new _sourceMap2.default.SourceMapConsumer(prev.text);\n        if (map.sourcesContent) {\n          map.sourcesContent = map.sourcesContent.map(function () {\n            return null;\n          });\n        }\n      } else {\n        map = prev.consumer();\n      }\n\n      this.map.applySourceMap(map, from, this.relative(root));\n    }\n  };\n\n  MapGenerator.prototype.isAnnotation = function isAnnotation() {\n    if (this.isInline()) {\n      return true;\n    } else if (typeof this.mapOpts.annotation !== 'undefined') {\n      return this.mapOpts.annotation;\n    } else if (this.previous().length) {\n      return this.previous().some(function (i) {\n        return i.annotation;\n      });\n    } else {\n      return true;\n    }\n  };\n\n  MapGenerator.prototype.toBase64 = function toBase64(str) {\n    if (Buffer) {\n      return Buffer.from(str).toString('base64');\n    } else {\n      return window.btoa(unescape(encodeURIComponent(str)));\n    }\n  };\n\n  MapGenerator.prototype.addAnnotation = function addAnnotation() {\n    var content = void 0;\n\n    if (this.isInline()) {\n      content = 'data:application/json;base64,' + this.toBase64(this.map.toString());\n    } else if (typeof this.mapOpts.annotation === 'string') {\n      content = this.mapOpts.annotation;\n    } else {\n      content = this.outputFile() + '.map';\n    }\n\n    var eol = '\\n';\n    if (this.css.indexOf('\\r\\n') !== -1) eol = '\\r\\n';\n\n    this.css += eol + '/*# sourceMappingURL=' + content + ' */';\n  };\n\n  MapGenerator.prototype.outputFile = function outputFile() {\n    if (this.opts.to) {\n      return this.relative(this.opts.to);\n    } else if (this.opts.from) {\n      return this.relative(this.opts.from);\n    } else {\n      return 'to.css';\n    }\n  };\n\n  MapGenerator.prototype.generateMap = function generateMap() {\n    this.generateString();\n    if (this.isSourcesContent()) this.setSourcesContent();\n    if (this.previous().length > 0) this.applyPrevMaps();\n    if (this.isAnnotation()) this.addAnnotation();\n\n    if (this.isInline()) {\n      return [this.css];\n    } else {\n      return [this.css, this.map];\n    }\n  };\n\n  MapGenerator.prototype.relative = function relative(file) {\n    if (file.indexOf('<') === 0) return file;\n    if (/^\\w+:\\/\\//.test(file)) return file;\n\n    var from = this.opts.to ? _path2.default.dirname(this.opts.to) : '.';\n\n    if (typeof this.mapOpts.annotation === 'string') {\n      from = _path2.default.dirname(_path2.default.resolve(from, this.mapOpts.annotation));\n    }\n\n    file = _path2.default.relative(from, file);\n    if (_path2.default.sep === '\\\\') {\n      return file.replace(/\\\\/g, '/');\n    } else {\n      return file;\n    }\n  };\n\n  MapGenerator.prototype.sourcePath = function sourcePath(node) {\n    if (this.mapOpts.from) {\n      return this.mapOpts.from;\n    } else {\n      return this.relative(node.source.input.from);\n    }\n  };\n\n  MapGenerator.prototype.generateString = function generateString() {\n    var _this3 = this;\n\n    this.css = '';\n    this.map = new _sourceMap2.default.SourceMapGenerator({ file: this.outputFile() });\n\n    var line = 1;\n    var column = 1;\n\n    var lines = void 0,\n        last = void 0;\n    this.stringify(this.root, function (str, node, type) {\n      _this3.css += str;\n\n      if (node && type !== 'end') {\n        if (node.source && node.source.start) {\n          _this3.map.addMapping({\n            source: _this3.sourcePath(node),\n            generated: { line: line, column: column - 1 },\n            original: {\n              line: node.source.start.line,\n              column: node.source.start.column - 1\n            }\n          });\n        } else {\n          _this3.map.addMapping({\n            source: '<no source>',\n            original: { line: 1, column: 0 },\n            generated: { line: line, column: column - 1 }\n          });\n        }\n      }\n\n      lines = str.match(/\\n/g);\n      if (lines) {\n        line += lines.length;\n        last = str.lastIndexOf('\\n');\n        column = str.length - last;\n      } else {\n        column += str.length;\n      }\n\n      if (node && type !== 'start') {\n        if (node.source && node.source.end) {\n          _this3.map.addMapping({\n            source: _this3.sourcePath(node),\n            generated: { line: line, column: column - 1 },\n            original: {\n              line: node.source.end.line,\n              column: node.source.end.column\n            }\n          });\n        } else {\n          _this3.map.addMapping({\n            source: '<no source>',\n            original: { line: 1, column: 0 },\n            generated: { line: line, column: column - 1 }\n          });\n        }\n      }\n    });\n  };\n\n  MapGenerator.prototype.generate = function generate() {\n    this.clearAnnotation();\n\n    if (this.isMap()) {\n      return this.generateMap();\n    } else {\n      var result = '';\n      this.stringify(this.root, function (i) {\n        result += i;\n      });\n      return [result];\n    }\n  };\n\n  return MapGenerator;\n}();\n\nexports.default = MapGenerator;\nmodule.exports = exports['default'];\n//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["map-generator.es6"],"names":["MapGenerator","stringify","root","opts","mapOpts","map","isMap","previous","length","previousMaps","walk","node","source","input","indexOf","push","isInline","inline","annotation","some","i","isSourcesContent","sourcesContent","withContent","clearAnnotation","nodes","type","text","removeChild","setSourcesContent","already","from","relative","setSourceContent","css","applyPrevMaps","prev","file","path","dirname","mozilla","SourceMapConsumer","consumer","applySourceMap","isAnnotation","toBase64","str","Buffer","toString","window","btoa","unescape","encodeURIComponent","addAnnotation","content","outputFile","eol","to","generateMap","generateString","test","resolve","sep","replace","sourcePath","SourceMapGenerator","line","column","lines","last","start","addMapping","generated","original","match","lastIndexOf","end","generate","result"],"mappings":"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","file":"map-generator.js","sourcesContent":["import mozilla from 'source-map'\nimport path from 'path'\n\nclass MapGenerator {\n  constructor (stringify, root, opts) {\n    this.stringify = stringify\n    this.mapOpts = opts.map || { }\n    this.root = root\n    this.opts = opts\n  }\n\n  isMap () {\n    if (typeof this.opts.map !== 'undefined') {\n      return !!this.opts.map\n    } else {\n      return this.previous().length > 0\n    }\n  }\n\n  previous () {\n    if (!this.previousMaps) {\n      this.previousMaps = []\n      this.root.walk(node => {\n        if (node.source && node.source.input.map) {\n          let map = node.source.input.map\n          if (this.previousMaps.indexOf(map) === -1) {\n            this.previousMaps.push(map)\n          }\n        }\n      })\n    }\n\n    return this.previousMaps\n  }\n\n  isInline () {\n    if (typeof this.mapOpts.inline !== 'undefined') {\n      return this.mapOpts.inline\n    }\n\n    let annotation = this.mapOpts.annotation\n    if (typeof annotation !== 'undefined' && annotation !== true) {\n      return false\n    }\n\n    if (this.previous().length) {\n      return this.previous().some(i => i.inline)\n    } else {\n      return true\n    }\n  }\n\n  isSourcesContent () {\n    if (typeof this.mapOpts.sourcesContent !== 'undefined') {\n      return this.mapOpts.sourcesContent\n    }\n    if (this.previous().length) {\n      return this.previous().some(i => i.withContent())\n    } else {\n      return true\n    }\n  }\n\n  clearAnnotation () {\n    if (this.mapOpts.annotation === false) return\n\n    let node\n    for (let i = this.root.nodes.length - 1; i >= 0; i--) {\n      node = this.root.nodes[i]\n      if (node.type !== 'comment') continue\n      if (node.text.indexOf('# sourceMappingURL=') === 0) {\n        this.root.removeChild(i)\n      }\n    }\n  }\n\n  setSourcesContent () {\n    let already = { }\n    this.root.walk(node => {\n      if (node.source) {\n        let from = node.source.input.from\n        if (from && !already[from]) {\n          already[from] = true\n          let relative = this.relative(from)\n          this.map.setSourceContent(relative, node.source.input.css)\n        }\n      }\n    })\n  }\n\n  applyPrevMaps () {\n    for (let prev of this.previous()) {\n      let from = this.relative(prev.file)\n      let root = prev.root || path.dirname(prev.file)\n      let map\n\n      if (this.mapOpts.sourcesContent === false) {\n        map = new mozilla.SourceMapConsumer(prev.text)\n        if (map.sourcesContent) {\n          map.sourcesContent = map.sourcesContent.map(() => null)\n        }\n      } else {\n        map = prev.consumer()\n      }\n\n      this.map.applySourceMap(map, from, this.relative(root))\n    }\n  }\n\n  isAnnotation () {\n    if (this.isInline()) {\n      return true\n    } else if (typeof this.mapOpts.annotation !== 'undefined') {\n      return this.mapOpts.annotation\n    } else if (this.previous().length) {\n      return this.previous().some(i => i.annotation)\n    } else {\n      return true\n    }\n  }\n\n  toBase64 (str) {\n    if (Buffer) {\n      return Buffer.from(str).toString('base64')\n    } else {\n      return window.btoa(unescape(encodeURIComponent(str)))\n    }\n  }\n\n  addAnnotation () {\n    let content\n\n    if (this.isInline()) {\n      content = 'data:application/json;base64,' +\n                this.toBase64(this.map.toString())\n    } else if (typeof this.mapOpts.annotation === 'string') {\n      content = this.mapOpts.annotation\n    } else {\n      content = this.outputFile() + '.map'\n    }\n\n    let eol = '\\n'\n    if (this.css.indexOf('\\r\\n') !== -1) eol = '\\r\\n'\n\n    this.css += eol + '/*# sourceMappingURL=' + content + ' */'\n  }\n\n  outputFile () {\n    if (this.opts.to) {\n      return this.relative(this.opts.to)\n    } else if (this.opts.from) {\n      return this.relative(this.opts.from)\n    } else {\n      return 'to.css'\n    }\n  }\n\n  generateMap () {\n    this.generateString()\n    if (this.isSourcesContent()) this.setSourcesContent()\n    if (this.previous().length > 0) this.applyPrevMaps()\n    if (this.isAnnotation()) this.addAnnotation()\n\n    if (this.isInline()) {\n      return [this.css]\n    } else {\n      return [this.css, this.map]\n    }\n  }\n\n  relative (file) {\n    if (file.indexOf('<') === 0) return file\n    if (/^\\w+:\\/\\//.test(file)) return file\n\n    let from = this.opts.to ? path.dirname(this.opts.to) : '.'\n\n    if (typeof this.mapOpts.annotation === 'string') {\n      from = path.dirname(path.resolve(from, this.mapOpts.annotation))\n    }\n\n    file = path.relative(from, file)\n    if (path.sep === '\\\\') {\n      return file.replace(/\\\\/g, '/')\n    } else {\n      return file\n    }\n  }\n\n  sourcePath (node) {\n    if (this.mapOpts.from) {\n      return this.mapOpts.from\n    } else {\n      return this.relative(node.source.input.from)\n    }\n  }\n\n  generateString () {\n    this.css = ''\n    this.map = new mozilla.SourceMapGenerator({ file: this.outputFile() })\n\n    let line = 1\n    let column = 1\n\n    let lines, last\n    this.stringify(this.root, (str, node, type) => {\n      this.css += str\n\n      if (node && type !== 'end') {\n        if (node.source && node.source.start) {\n          this.map.addMapping({\n            source: this.sourcePath(node),\n            generated: { line, column: column - 1 },\n            original: {\n              line: node.source.start.line,\n              column: node.source.start.column - 1\n            }\n          })\n        } else {\n          this.map.addMapping({\n            source: '<no source>',\n            original: { line: 1, column: 0 },\n            generated: { line, column: column - 1 }\n          })\n        }\n      }\n\n      lines = str.match(/\\n/g)\n      if (lines) {\n        line += lines.length\n        last = str.lastIndexOf('\\n')\n        column = str.length - last\n      } else {\n        column += str.length\n      }\n\n      if (node && type !== 'start') {\n        if (node.source && node.source.end) {\n          this.map.addMapping({\n            source: this.sourcePath(node),\n            generated: { line, column: column - 1 },\n            original: {\n              line: node.source.end.line,\n              column: node.source.end.column\n            }\n          })\n        } else {\n          this.map.addMapping({\n            source: '<no source>',\n            original: { line: 1, column: 0 },\n            generated: { line, column: column - 1 }\n          })\n        }\n      }\n    })\n  }\n\n  generate () {\n    this.clearAnnotation()\n\n    if (this.isMap()) {\n      return this.generateMap()\n    } else {\n      let result = ''\n      this.stringify(this.root, i => {\n        result += i\n      })\n      return [result]\n    }\n  }\n}\n\nexport default MapGenerator\n"]}\n","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || Function(\"return this\")() || (1, eval)(\"this\");\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n","'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n  lookup[i] = code[i]\n  revLookup[code.charCodeAt(i)] = i\n}\n\n// Support decoding URL-safe base64 strings, as Node.js does.\n// See: https://en.wikipedia.org/wiki/Base64#URL_applications\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction getLens (b64) {\n  var len = b64.length\n\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4')\n  }\n\n  // Trim off extra bytes after placeholder bytes are found\n  // See: https://github.com/beatgammit/base64-js/issues/42\n  var validLen = b64.indexOf('=')\n  if (validLen === -1) validLen = len\n\n  var placeHoldersLen = validLen === len\n    ? 0\n    : 4 - (validLen % 4)\n\n  return [validLen, placeHoldersLen]\n}\n\n// base64 is 4/3 + up to two characters of the original data\nfunction byteLength (b64) {\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction _byteLength (b64, validLen, placeHoldersLen) {\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction toByteArray (b64) {\n  var tmp\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n\n  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))\n\n  var curByte = 0\n\n  // if there are placeholders, only get up to the last complete 4 chars\n  var len = placeHoldersLen > 0\n    ? validLen - 4\n    : validLen\n\n  for (var i = 0; i < len; i += 4) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 18) |\n      (revLookup[b64.charCodeAt(i + 1)] << 12) |\n      (revLookup[b64.charCodeAt(i + 2)] << 6) |\n      revLookup[b64.charCodeAt(i + 3)]\n    arr[curByte++] = (tmp >> 16) & 0xFF\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 2) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 2) |\n      (revLookup[b64.charCodeAt(i + 1)] >> 4)\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 1) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 10) |\n      (revLookup[b64.charCodeAt(i + 1)] << 4) |\n      (revLookup[b64.charCodeAt(i + 2)] >> 2)\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  return arr\n}\n\nfunction tripletToBase64 (num) {\n  return lookup[num >> 18 & 0x3F] +\n    lookup[num >> 12 & 0x3F] +\n    lookup[num >> 6 & 0x3F] +\n    lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n  var tmp\n  var output = []\n  for (var i = start; i < end; i += 3) {\n    tmp =\n      ((uint8[i] << 16) & 0xFF0000) +\n      ((uint8[i + 1] << 8) & 0xFF00) +\n      (uint8[i + 2] & 0xFF)\n    output.push(tripletToBase64(tmp))\n  }\n  return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n  var tmp\n  var len = uint8.length\n  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n  var parts = []\n  var maxChunkLength = 16383 // must be multiple of 3\n\n  // go through the array every three bytes, we'll deal with trailing stuff later\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(\n      uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)\n    ))\n  }\n\n  // pad the end with zeros, but make sure to not forget the extra bytes\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 2] +\n      lookup[(tmp << 4) & 0x3F] +\n      '=='\n    )\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 10] +\n      lookup[(tmp >> 4) & 0x3F] +\n      lookup[(tmp << 2) & 0x3F] +\n      '='\n    )\n  }\n\n  return parts.join('')\n}\n","exports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = ((value * c) - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};\n","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar intToCharMap = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split('');\n\n/**\n * Encode an integer in the range of 0 to 63 to a single base 64 digit.\n */\nexports.encode = function (number) {\n  if (0 <= number && number < intToCharMap.length) {\n    return intToCharMap[number];\n  }\n  throw new TypeError(\"Must be between 0 and 63: \" + number);\n};\n\n/**\n * Decode a single base 64 character code digit to an integer. Returns -1 on\n * failure.\n */\nexports.decode = function (charCode) {\n  var bigA = 65;     // 'A'\n  var bigZ = 90;     // 'Z'\n\n  var littleA = 97;  // 'a'\n  var littleZ = 122; // 'z'\n\n  var zero = 48;     // '0'\n  var nine = 57;     // '9'\n\n  var plus = 43;     // '+'\n  var slash = 47;    // '/'\n\n  var littleOffset = 26;\n  var numberOffset = 52;\n\n  // 0 - 25: ABCDEFGHIJKLMNOPQRSTUVWXYZ\n  if (bigA <= charCode && charCode <= bigZ) {\n    return (charCode - bigA);\n  }\n\n  // 26 - 51: abcdefghijklmnopqrstuvwxyz\n  if (littleA <= charCode && charCode <= littleZ) {\n    return (charCode - littleA + littleOffset);\n  }\n\n  // 52 - 61: 0123456789\n  if (zero <= charCode && charCode <= nine) {\n    return (charCode - zero + numberOffset);\n  }\n\n  // 62: +\n  if (charCode == plus) {\n    return 62;\n  }\n\n  // 63: /\n  if (charCode == slash) {\n    return 63;\n  }\n\n  // Invalid base64 digit.\n  return -1;\n};\n","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2014 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar util = require('./util');\n\n/**\n * Determine whether mappingB is after mappingA with respect to generated\n * position.\n */\nfunction generatedPositionAfter(mappingA, mappingB) {\n  // Optimized for most common case\n  var lineA = mappingA.generatedLine;\n  var lineB = mappingB.generatedLine;\n  var columnA = mappingA.generatedColumn;\n  var columnB = mappingB.generatedColumn;\n  return lineB > lineA || lineB == lineA && columnB >= columnA ||\n         util.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0;\n}\n\n/**\n * A data structure to provide a sorted view of accumulated mappings in a\n * performance conscious manner. It trades a neglibable overhead in general\n * case for a large speedup in case of mappings being added in order.\n */\nfunction MappingList() {\n  this._array = [];\n  this._sorted = true;\n  // Serves as infimum\n  this._last = {generatedLine: -1, generatedColumn: 0};\n}\n\n/**\n * Iterate through internal items. This method takes the same arguments that\n * `Array.prototype.forEach` takes.\n *\n * NOTE: The order of the mappings is NOT guaranteed.\n */\nMappingList.prototype.unsortedForEach =\n  function MappingList_forEach(aCallback, aThisArg) {\n    this._array.forEach(aCallback, aThisArg);\n  };\n\n/**\n * Add the given source mapping.\n *\n * @param Object aMapping\n */\nMappingList.prototype.add = function MappingList_add(aMapping) {\n  if (generatedPositionAfter(this._last, aMapping)) {\n    this._last = aMapping;\n    this._array.push(aMapping);\n  } else {\n    this._sorted = false;\n    this._array.push(aMapping);\n  }\n};\n\n/**\n * Returns the flat, sorted array of mappings. The mappings are sorted by\n * generated position.\n *\n * WARNING: This method returns internal data without copying, for\n * performance. The return value must NOT be mutated, and should be treated as\n * an immutable borrow. If you want to take ownership, you must make your own\n * copy.\n */\nMappingList.prototype.toArray = function MappingList_toArray() {\n  if (!this._sorted) {\n    this._array.sort(util.compareByGeneratedPositionsInflated);\n    this._sorted = true;\n  }\n  return this._array;\n};\n\nexports.MappingList = MappingList;\n","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar util = require('./util');\nvar binarySearch = require('./binary-search');\nvar ArraySet = require('./array-set').ArraySet;\nvar base64VLQ = require('./base64-vlq');\nvar quickSort = require('./quick-sort').quickSort;\n\nfunction SourceMapConsumer(aSourceMap, aSourceMapURL) {\n  var sourceMap = aSourceMap;\n  if (typeof aSourceMap === 'string') {\n    sourceMap = util.parseSourceMapInput(aSourceMap);\n  }\n\n  return sourceMap.sections != null\n    ? new IndexedSourceMapConsumer(sourceMap, aSourceMapURL)\n    : new BasicSourceMapConsumer(sourceMap, aSourceMapURL);\n}\n\nSourceMapConsumer.fromSourceMap = function(aSourceMap, aSourceMapURL) {\n  return BasicSourceMapConsumer.fromSourceMap(aSourceMap, aSourceMapURL);\n}\n\n/**\n * The version of the source mapping spec that we are consuming.\n */\nSourceMapConsumer.prototype._version = 3;\n\n// `__generatedMappings` and `__originalMappings` are arrays that hold the\n// parsed mapping coordinates from the source map's \"mappings\" attribute. They\n// are lazily instantiated, accessed via the `_generatedMappings` and\n// `_originalMappings` getters respectively, and we only parse the mappings\n// and create these arrays once queried for a source location. We jump through\n// these hoops because there can be many thousands of mappings, and parsing\n// them is expensive, so we only want to do it if we must.\n//\n// Each object in the arrays is of the form:\n//\n//     {\n//       generatedLine: The line number in the generated code,\n//       generatedColumn: The column number in the generated code,\n//       source: The path to the original source file that generated this\n//               chunk of code,\n//       originalLine: The line number in the original source that\n//                     corresponds to this chunk of generated code,\n//       originalColumn: The column number in the original source that\n//                       corresponds to this chunk of generated code,\n//       name: The name of the original symbol which generated this chunk of\n//             code.\n//     }\n//\n// All properties except for `generatedLine` and `generatedColumn` can be\n// `null`.\n//\n// `_generatedMappings` is ordered by the generated positions.\n//\n// `_originalMappings` is ordered by the original positions.\n\nSourceMapConsumer.prototype.__generatedMappings = null;\nObject.defineProperty(SourceMapConsumer.prototype, '_generatedMappings', {\n  configurable: true,\n  enumerable: true,\n  get: function () {\n    if (!this.__generatedMappings) {\n      this._parseMappings(this._mappings, this.sourceRoot);\n    }\n\n    return this.__generatedMappings;\n  }\n});\n\nSourceMapConsumer.prototype.__originalMappings = null;\nObject.defineProperty(SourceMapConsumer.prototype, '_originalMappings', {\n  configurable: true,\n  enumerable: true,\n  get: function () {\n    if (!this.__originalMappings) {\n      this._parseMappings(this._mappings, this.sourceRoot);\n    }\n\n    return this.__originalMappings;\n  }\n});\n\nSourceMapConsumer.prototype._charIsMappingSeparator =\n  function SourceMapConsumer_charIsMappingSeparator(aStr, index) {\n    var c = aStr.charAt(index);\n    return c === \";\" || c === \",\";\n  };\n\n/**\n * Parse the mappings in a string in to a data structure which we can easily\n * query (the ordered arrays in the `this.__generatedMappings` and\n * `this.__originalMappings` properties).\n */\nSourceMapConsumer.prototype._parseMappings =\n  function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {\n    throw new Error(\"Subclasses must implement _parseMappings\");\n  };\n\nSourceMapConsumer.GENERATED_ORDER = 1;\nSourceMapConsumer.ORIGINAL_ORDER = 2;\n\nSourceMapConsumer.GREATEST_LOWER_BOUND = 1;\nSourceMapConsumer.LEAST_UPPER_BOUND = 2;\n\n/**\n * Iterate over each mapping between an original source/line/column and a\n * generated line/column in this source map.\n *\n * @param Function aCallback\n *        The function that is called with each mapping.\n * @param Object aContext\n *        Optional. If specified, this object will be the value of `this` every\n *        time that `aCallback` is called.\n * @param aOrder\n *        Either `SourceMapConsumer.GENERATED_ORDER` or\n *        `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to\n *        iterate over the mappings sorted by the generated file's line/column\n *        order or the original's source/line/column order, respectively. Defaults to\n *        `SourceMapConsumer.GENERATED_ORDER`.\n */\nSourceMapConsumer.prototype.eachMapping =\n  function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {\n    var context = aContext || null;\n    var order = aOrder || SourceMapConsumer.GENERATED_ORDER;\n\n    var mappings;\n    switch (order) {\n    case SourceMapConsumer.GENERATED_ORDER:\n      mappings = this._generatedMappings;\n      break;\n    case SourceMapConsumer.ORIGINAL_ORDER:\n      mappings = this._originalMappings;\n      break;\n    default:\n      throw new Error(\"Unknown order of iteration.\");\n    }\n\n    var sourceRoot = this.sourceRoot;\n    mappings.map(function (mapping) {\n      var source = mapping.source === null ? null : this._sources.at(mapping.source);\n      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  };\n\n/**\n * Returns all generated line and column information for the original source,\n * line, and column provided. If no column is provided, returns all mappings\n * corresponding to a either the line we are searching for or the next\n * closest line that has any mappings. Otherwise, returns all mappings\n * corresponding to the given line and either the column we are searching for\n * or the next closest column that has any offsets.\n *\n * The only argument is an object with the following properties:\n *\n *   - source: The filename of the original source.\n *   - line: The line number in the original source.  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.  The\n *    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');\n\n    // When there is no exact match, BasicSourceMapConsumer.prototype._findMapping\n    // returns the index of the closest mapping less than the needle. By\n    // setting needle.originalColumn to 0, we thus find the last mapping for\n    // the given line, provided such a mapping exists.\n    var needle = {\n      source: util.getArg(aArgs, 'source'),\n      originalLine: line,\n      originalColumn: util.getArg(aArgs, 'column', 0)\n    };\n\n    needle.source = this._findSourceIndex(needle.source);\n    if (needle.source < 0) {\n      return [];\n    }\n\n    var mappings = [];\n\n    var index = this._findMapping(needle,\n                                  this._originalMappings,\n                                  \"originalLine\",\n                                  \"originalColumn\",\n                                  util.compareByOriginalPositions,\n                                  binarySearch.LEAST_UPPER_BOUND);\n    if (index >= 0) {\n      var mapping = this._originalMappings[index];\n\n      if (aArgs.column === undefined) {\n        var originalLine = mapping.originalLine;\n\n        // Iterate until either we run out of mappings, or we run into\n        // a mapping for a different line than the one we found. Since\n        // mappings are sorted, this is guaranteed to find all mappings for\n        // the line we found.\n        while (mapping && mapping.originalLine === originalLine) {\n          mappings.push({\n            line: util.getArg(mapping, 'generatedLine', null),\n            column: util.getArg(mapping, 'generatedColumn', null),\n            lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)\n          });\n\n          mapping = this._originalMappings[++index];\n        }\n      } else {\n        var originalColumn = mapping.originalColumn;\n\n        // Iterate until either we run out of mappings, or we run into\n        // a mapping for a different line than the one we were searching for.\n        // Since mappings are sorted, this is guaranteed to find all mappings for\n        // the line we are searching for.\n        while (mapping &&\n               mapping.originalLine === line &&\n               mapping.originalColumn == originalColumn) {\n          mappings.push({\n            line: util.getArg(mapping, 'generatedLine', null),\n            column: util.getArg(mapping, 'generatedColumn', null),\n            lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)\n          });\n\n          mapping = this._originalMappings[++index];\n        }\n      }\n    }\n\n    return mappings;\n  };\n\nexports.SourceMapConsumer = SourceMapConsumer;\n\n/**\n * A BasicSourceMapConsumer instance represents a parsed source map which we can\n * query for information about the original file positions by giving it a file\n * position in the generated source.\n *\n * The first parameter is the raw source map (either as a JSON string, or\n * already parsed to an object). According to the spec, source maps have the\n * following attributes:\n *\n *   - version: Which version of the source map spec this map is following.\n *   - sources: An array of URLs to the original source files.\n *   - names: An array of identifiers which can be referrenced by individual mappings.\n *   - sourceRoot: Optional. The URL root from which all sources are relative.\n *   - sourcesContent: Optional. An array of contents of the original source files.\n *   - mappings: A string of base64 VLQs which contain the actual mappings.\n *   - file: Optional. The generated file this source map is associated with.\n *\n * Here is an example source map, taken from the source map spec[0]:\n *\n *     {\n *       version : 3,\n *       file: \"out.js\",\n *       sourceRoot : \"\",\n *       sources: [\"foo.js\", \"bar.js\"],\n *       names: [\"src\", \"maps\", \"are\", \"fun\"],\n *       mappings: \"AA,AB;;ABCDE;\"\n *     }\n *\n * The second parameter, if given, is a string whose value is the URL\n * at which the source map was found.  This URL is used to compute the\n * sources array.\n *\n * [0]: https://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  }\n\n  var version = util.getArg(sourceMap, 'version');\n  var sources = util.getArg(sourceMap, 'sources');\n  // Sass 3.3 leaves out the 'names' array, so we deviate from the spec (which\n  // requires the array) to play nice here.\n  var names = util.getArg(sourceMap, 'names', []);\n  var sourceRoot = util.getArg(sourceMap, 'sourceRoot', null);\n  var sourcesContent = util.getArg(sourceMap, 'sourcesContent', null);\n  var mappings = util.getArg(sourceMap, 'mappings');\n  var file = util.getArg(sourceMap, 'file', null);\n\n  // Once again, Sass deviates from the spec and supplies the version as a\n  // string rather than a number, so we use loose equality checking here.\n  if (version != this._version) {\n    throw new Error('Unsupported version: ' + version);\n  }\n\n  if (sourceRoot) {\n    sourceRoot = util.normalize(sourceRoot);\n  }\n\n  sources = sources\n    .map(String)\n    // Some source maps produce relative source paths like \"./foo.js\" instead of\n    // \"foo.js\".  Normalize these first so that future comparisons will succeed.\n    // See bugzil.la/1090768.\n    .map(util.normalize)\n    // Always ensure that absolute sources are internally stored relative to\n    // the source root, if the source root is absolute. Not doing this would\n    // be particularly problematic when the source root is a prefix of the\n    // source (valid, but why??). See github issue #199 and bugzil.la/1188982.\n    .map(function (source) {\n      return sourceRoot && util.isAbsolute(sourceRoot) && util.isAbsolute(source)\n        ? util.relative(sourceRoot, source)\n        : source;\n    });\n\n  // Pass `true` below to allow duplicate names and sources. While source maps\n  // are intended to be compressed and deduplicated, the TypeScript compiler\n  // sometimes generates source maps with duplicates in them. See Github issue\n  // #72 and bugzil.la/889492.\n  this._names = ArraySet.fromArray(names.map(String), true);\n  this._sources = ArraySet.fromArray(sources, true);\n\n  this._absoluteSources = this._sources.toArray().map(function (s) {\n    return util.computeSourceURL(sourceRoot, s, aSourceMapURL);\n  });\n\n  this.sourceRoot = sourceRoot;\n  this.sourcesContent = sourcesContent;\n  this._mappings = mappings;\n  this._sourceMapURL = aSourceMapURL;\n  this.file = file;\n}\n\nBasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);\nBasicSourceMapConsumer.prototype.consumer = SourceMapConsumer;\n\n/**\n * Utility function to find the index of a source.  Returns -1 if not\n * found.\n */\nBasicSourceMapConsumer.prototype._findSourceIndex = function(aSource) {\n  var relativeSource = aSource;\n  if (this.sourceRoot != null) {\n    relativeSource = util.relative(this.sourceRoot, relativeSource);\n  }\n\n  if (this._sources.has(relativeSource)) {\n    return this._sources.indexOf(relativeSource);\n  }\n\n  // Maybe aSource is an absolute URL as returned by |sources|.  In\n  // 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[i] == aSource) {\n      return i;\n    }\n  }\n\n  return -1;\n};\n\n/**\n * Create a BasicSourceMapConsumer from a SourceMapGenerator.\n *\n * @param SourceMapGenerator aSourceMap\n *        The source map that will be consumed.\n * @param String aSourceMapURL\n *        The URL at which the source map can be found (optional)\n * @returns BasicSourceMapConsumer\n */\nBasicSourceMapConsumer.fromSourceMap =\n  function SourceMapConsumer_fromSourceMap(aSourceMap, aSourceMapURL) {\n    var smc = Object.create(BasicSourceMapConsumer.prototype);\n\n    var names = smc._names = ArraySet.fromArray(aSourceMap._names.toArray(), true);\n    var sources = smc._sources = ArraySet.fromArray(aSourceMap._sources.toArray(), true);\n    smc.sourceRoot = aSourceMap._sourceRoot;\n    smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(),\n                                                            smc.sourceRoot);\n    smc.file = aSourceMap._file;\n    smc._sourceMapURL = aSourceMapURL;\n    smc._absoluteSources = smc._sources.toArray().map(function (s) {\n      return util.computeSourceURL(smc.sourceRoot, s, aSourceMapURL);\n    });\n\n    // Because we are modifying the entries (by converting string sources and\n    // names to indices into the sources and names ArraySets), we have to make\n    // a copy of the entry or else bad things happen. Shared mutable state\n    // strikes again! See github issue #191.\n\n    var generatedMappings = aSourceMap._mappings.toArray().slice();\n    var destGeneratedMappings = smc.__generatedMappings = [];\n    var destOriginalMappings = smc.__originalMappings = [];\n\n    for (var i = 0, length = generatedMappings.length; i < length; i++) {\n      var srcMapping = generatedMappings[i];\n      var destMapping = new Mapping;\n      destMapping.generatedLine = srcMapping.generatedLine;\n      destMapping.generatedColumn = srcMapping.generatedColumn;\n\n      if (srcMapping.source) {\n        destMapping.source = sources.indexOf(srcMapping.source);\n        destMapping.originalLine = srcMapping.originalLine;\n        destMapping.originalColumn = srcMapping.originalColumn;\n\n        if (srcMapping.name) {\n          destMapping.name = names.indexOf(srcMapping.name);\n        }\n\n        destOriginalMappings.push(destMapping);\n      }\n\n      destGeneratedMappings.push(destMapping);\n    }\n\n    quickSort(smc.__originalMappings, util.compareByOriginalPositions);\n\n    return smc;\n  };\n\n/**\n * The version of the source mapping spec that we are consuming.\n */\nBasicSourceMapConsumer.prototype._version = 3;\n\n/**\n * The list of original sources.\n */\nObject.defineProperty(BasicSourceMapConsumer.prototype, 'sources', {\n  get: function () {\n    return this._absoluteSources.slice();\n  }\n});\n\n/**\n * Provide the JIT with a nice shape / hidden class.\n */\nfunction Mapping() {\n  this.generatedLine = 0;\n  this.generatedColumn = 0;\n  this.source = null;\n  this.originalLine = null;\n  this.originalColumn = null;\n  this.name = null;\n}\n\n/**\n * Parse the mappings in a string in to a data structure which we can easily\n * query (the ordered arrays in the `this.__generatedMappings` and\n * `this.__originalMappings` properties).\n */\nBasicSourceMapConsumer.prototype._parseMappings =\n  function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {\n    var generatedLine = 1;\n    var previousGeneratedColumn = 0;\n    var previousOriginalLine = 0;\n    var previousOriginalColumn = 0;\n    var previousSource = 0;\n    var previousName = 0;\n    var length = aStr.length;\n    var index = 0;\n    var cachedSegments = {};\n    var temp = {};\n    var originalMappings = [];\n    var generatedMappings = [];\n    var mapping, str, segment, end, value;\n\n    while (index < length) {\n      if (aStr.charAt(index) === ';') {\n        generatedLine++;\n        index++;\n        previousGeneratedColumn = 0;\n      }\n      else if (aStr.charAt(index) === ',') {\n        index++;\n      }\n      else {\n        mapping = new Mapping();\n        mapping.generatedLine = generatedLine;\n\n        // Because each offset is encoded relative to the previous one,\n        // many segments often have the same encoding. We can exploit this\n        // fact by caching the parsed variable length fields of each segment,\n        // allowing us to avoid a second parse if we encounter the same\n        // segment again.\n        for (end = index; end < length; end++) {\n          if (this._charIsMappingSeparator(aStr, end)) {\n            break;\n          }\n        }\n        str = aStr.slice(index, end);\n\n        segment = cachedSegments[str];\n        if (segment) {\n          index += str.length;\n        } else {\n          segment = [];\n          while (index < end) {\n            base64VLQ.decode(aStr, index, temp);\n            value = temp.value;\n            index = temp.rest;\n            segment.push(value);\n          }\n\n          if (segment.length === 2) {\n            throw new Error('Found a source, but no line and column');\n          }\n\n          if (segment.length === 3) {\n            throw new Error('Found a source and line, but no column');\n          }\n\n          cachedSegments[str] = segment;\n        }\n\n        // Generated column.\n        mapping.generatedColumn = previousGeneratedColumn + segment[0];\n        previousGeneratedColumn = mapping.generatedColumn;\n\n        if (segment.length > 1) {\n          // Original source.\n          mapping.source = previousSource + segment[1];\n          previousSource += segment[1];\n\n          // Original line.\n          mapping.originalLine = previousOriginalLine + segment[2];\n          previousOriginalLine = mapping.originalLine;\n          // Lines are stored 0-based\n          mapping.originalLine += 1;\n\n          // Original column.\n          mapping.originalColumn = previousOriginalColumn + segment[3];\n          previousOriginalColumn = mapping.originalColumn;\n\n          if (segment.length > 4) {\n            // Original name.\n            mapping.name = previousName + segment[4];\n            previousName += segment[4];\n          }\n        }\n\n        generatedMappings.push(mapping);\n        if (typeof mapping.originalLine === 'number') {\n          originalMappings.push(mapping);\n        }\n      }\n    }\n\n    quickSort(generatedMappings, util.compareByGeneratedPositionsDeflated);\n    this.__generatedMappings = generatedMappings;\n\n    quickSort(originalMappings, util.compareByOriginalPositions);\n    this.__originalMappings = originalMappings;\n  };\n\n/**\n * Find the mapping that best matches the hypothetical \"needle\" mapping that\n * we are searching for in the given \"haystack\" of mappings.\n */\nBasicSourceMapConsumer.prototype._findMapping =\n  function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName,\n                                         aColumnName, aComparator, aBias) {\n    // To return the position we are searching for, we must first find the\n    // mapping for the given position and then return the opposite position it\n    // points to. Because the mappings are sorted, we can use binary search to\n    // find the best mapping.\n\n    if (aNeedle[aLineName] <= 0) {\n      throw new TypeError('Line must be greater than or equal to 1, got '\n                          + aNeedle[aLineName]);\n    }\n    if (aNeedle[aColumnName] < 0) {\n      throw new TypeError('Column must be greater than or equal to 0, got '\n                          + aNeedle[aColumnName]);\n    }\n\n    return binarySearch.search(aNeedle, aMappings, aComparator, aBias);\n  };\n\n/**\n * Compute the last column for each generated mapping. The last column is\n * inclusive.\n */\nBasicSourceMapConsumer.prototype.computeColumnSpans =\n  function SourceMapConsumer_computeColumnSpans() {\n    for (var index = 0; index < this._generatedMappings.length; ++index) {\n      var mapping = this._generatedMappings[index];\n\n      // Mappings do not contain a field for the last generated columnt. We\n      // can come up with an optimistic estimate, however, by assuming that\n      // mappings are contiguous (i.e. given two consecutive mappings, the\n      // first mapping ends where the second one starts).\n      if (index + 1 < this._generatedMappings.length) {\n        var nextMapping = this._generatedMappings[index + 1];\n\n        if (mapping.generatedLine === nextMapping.generatedLine) {\n          mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1;\n          continue;\n        }\n      }\n\n      // The last mapping for each line spans the entire line.\n      mapping.lastGeneratedColumn = Infinity;\n    }\n  };\n\n/**\n * Returns the original source, line, and column information for the generated\n * source's line and column positions provided. The only argument is an object\n * with the following properties:\n *\n *   - line: The line number in the generated source.  The line number\n *     is 1-based.\n *   - column: The column number in the generated source.  The column\n *     number is 0-based.\n *   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or\n *     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the\n *     closest element that is smaller than or greater than the one we are\n *     searching for, respectively, if the exact element cannot be found.\n *     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.\n *\n * and an object is returned with the following properties:\n *\n *   - source: The original source file, or null.\n *   - line: The line number in the original source, or null.  The\n *     line number is 1-based.\n *   - column: The column number in the original source, or null.  The\n *     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    };\n\n    var index = this._findMapping(\n      needle,\n      this._generatedMappings,\n      \"generatedLine\",\n      \"generatedColumn\",\n      util.compareByGeneratedPositionsDeflated,\n      util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)\n    );\n\n    if (index >= 0) {\n      var mapping = this._generatedMappings[index];\n\n      if (mapping.generatedLine === needle.generatedLine) {\n        var source = util.getArg(mapping, 'source', null);\n        if (source !== null) {\n          source = this._sources.at(source);\n          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: name\n        };\n      }\n    }\n\n    return {\n      source: null,\n      line: null,\n      column: null,\n      name: null\n    };\n  };\n\n/**\n * Return true if we have the source content for every source in the source\n * map, false otherwise.\n */\nBasicSourceMapConsumer.prototype.hasContentsOfAllSources =\n  function BasicSourceMapConsumer_hasContentsOfAllSources() {\n    if (!this.sourcesContent) {\n      return false;\n    }\n    return this.sourcesContent.length >= this._sources.size() &&\n      !this.sourcesContent.some(function (sc) { return sc == null; });\n  };\n\n/**\n * Returns the original source content. The only argument is the url of the\n * original source file. Returns null if no original source content is\n * available.\n */\nBasicSourceMapConsumer.prototype.sourceContentFor =\n  function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {\n    if (!this.sourcesContent) {\n      return null;\n    }\n\n    var index = this._findSourceIndex(aSource);\n    if (index >= 0) {\n      return this.sourcesContent[index];\n    }\n\n    var relativeSource = aSource;\n    if (this.sourceRoot != null) {\n      relativeSource = util.relative(this.sourceRoot, relativeSource);\n    }\n\n    var url;\n    if (this.sourceRoot != null\n        && (url = util.urlParse(this.sourceRoot))) {\n      // XXX: file:// URIs and absolute paths lead to unexpected behavior for\n      // many users. We can help them out when they expect file:// URIs to\n      // behave like it would if they were running a local HTTP server. See\n      // https://bugzilla.mozilla.org/show_bug.cgi?id=885597.\n      var fileUriAbsPath = relativeSource.replace(/^file:\\/\\//, \"\");\n      if (url.scheme == \"file\"\n          && this._sources.has(fileUriAbsPath)) {\n        return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)]\n      }\n\n      if ((!url.path || url.path == \"/\")\n          && this._sources.has(\"/\" + relativeSource)) {\n        return this.sourcesContent[this._sources.indexOf(\"/\" + relativeSource)];\n      }\n    }\n\n    // This function is used recursively from\n    // IndexedSourceMapConsumer.prototype.sourceContentFor. In that case, we\n    // don't want to throw if we can't find the source - we just want to\n    // return null, so we provide a flag to exit gracefully.\n    if (nullOnMissing) {\n      return null;\n    }\n    else {\n      throw new Error('\"' + relativeSource + '\" is not in the SourceMap.');\n    }\n  };\n\n/**\n * Returns the generated line and column information for the original source,\n * line, and column positions provided. The only argument is an object with\n * the following properties:\n *\n *   - source: The filename of the original source.\n *   - line: The line number in the original source.  The line number\n *     is 1-based.\n *   - column: The column number in the original source.  The column\n *     number is 0-based.\n *   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or\n *     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the\n *     closest element that is smaller than or greater than the one we are\n *     searching for, respectively, if the exact element cannot be found.\n *     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.\n *\n * and an object is returned with the following properties:\n *\n *   - line: The line number in the generated source, or null.  The\n *     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: null\n      };\n    }\n\n    var needle = {\n      source: source,\n      originalLine: util.getArg(aArgs, 'line'),\n      originalColumn: util.getArg(aArgs, 'column')\n    };\n\n    var index = this._findMapping(\n      needle,\n      this._originalMappings,\n      \"originalLine\",\n      \"originalColumn\",\n      util.compareByOriginalPositions,\n      util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)\n    );\n\n    if (index >= 0) {\n      var mapping = this._originalMappings[index];\n\n      if (mapping.source === needle.source) {\n        return {\n          line: util.getArg(mapping, 'generatedLine', null),\n          column: util.getArg(mapping, 'generatedColumn', null),\n          lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)\n        };\n      }\n    }\n\n    return {\n      line: null,\n      column: null,\n      lastColumn: null\n    };\n  };\n\nexports.BasicSourceMapConsumer = BasicSourceMapConsumer;\n\n/**\n * An IndexedSourceMapConsumer instance represents a parsed source map which\n * we can query for information. It differs from BasicSourceMapConsumer in\n * that it takes \"indexed\" source maps (i.e. ones with a \"sections\" field) as\n * input.\n *\n * The first parameter is a raw source map (either as a JSON string, or already\n * parsed to an object). According to the spec for indexed source maps, they\n * have the following attributes:\n *\n *   - version: Which version of the source map spec this map is following.\n *   - file: Optional. The generated file this source map is associated with.\n *   - sections: A list of section definitions.\n *\n * Each value under the \"sections\" field has two fields:\n *   - offset: The offset into the original specified at which this section\n *       begins to apply, defined as an object with a \"line\" and \"column\"\n *       field.\n *   - map: A source map definition. This source map could also be indexed,\n *       but doesn't have to be.\n *\n * Instead of the \"map\" field, it's also possible to have a \"url\" field\n * specifying a URL to retrieve a source map from, but that's currently\n * unsupported.\n *\n * Here's an example source map, taken from the source map spec[0], but\n * modified to omit a section which uses the \"url\" field.\n *\n *  {\n *    version : 3,\n *    file: \"app.js\",\n *    sections: [{\n *      offset: {line:100, column:10},\n *      map: {\n *        version : 3,\n *        file: \"section.js\",\n *        sources: [\"foo.js\", \"bar.js\"],\n *        names: [\"src\", \"maps\", \"are\", \"fun\"],\n *        mappings: \"AAAA,E;;ABCDE;\"\n *      }\n *    }],\n *  }\n *\n * The second parameter, if given, is a string whose value is the URL\n * at which the source map was found.  This URL is used to compute the\n * sources array.\n *\n * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit#heading=h.535es3xeprgt\n */\nfunction IndexedSourceMapConsumer(aSourceMap, aSourceMapURL) {\n  var sourceMap = aSourceMap;\n  if (typeof aSourceMap === 'string') {\n    sourceMap = util.parseSourceMapInput(aSourceMap);\n  }\n\n  var version = util.getArg(sourceMap, 'version');\n  var sections = util.getArg(sourceMap, 'sections');\n\n  if (version != this._version) {\n    throw new Error('Unsupported version: ' + version);\n  }\n\n  this._sources = new ArraySet();\n  this._names = new ArraySet();\n\n  var lastOffset = {\n    line: -1,\n    column: 0\n  };\n  this._sections = sections.map(function (s) {\n    if (s.url) {\n      // The url field will require support for asynchronicity.\n      // See https://github.com/mozilla/source-map/issues/16\n      throw new Error('Support for url field in sections not implemented.');\n    }\n    var offset = util.getArg(s, 'offset');\n    var offsetLine = util.getArg(offset, 'line');\n    var offsetColumn = util.getArg(offset, 'column');\n\n    if (offsetLine < lastOffset.line ||\n        (offsetLine === lastOffset.line && offsetColumn < lastOffset.column)) {\n      throw new Error('Section offsets must be ordered and non-overlapping.');\n    }\n    lastOffset = offset;\n\n    return {\n      generatedOffset: {\n        // The offset fields are 0-based, but we use 1-based indices when\n        // encoding/decoding from VLQ.\n        generatedLine: offsetLine + 1,\n        generatedColumn: offsetColumn + 1\n      },\n      consumer: new SourceMapConsumer(util.getArg(s, 'map'), aSourceMapURL)\n    }\n  });\n}\n\nIndexedSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);\nIndexedSourceMapConsumer.prototype.constructor = SourceMapConsumer;\n\n/**\n * The version of the source mapping spec that we are consuming.\n */\nIndexedSourceMapConsumer.prototype._version = 3;\n\n/**\n * The list of original sources.\n */\nObject.defineProperty(IndexedSourceMapConsumer.prototype, 'sources', {\n  get: function () {\n    var sources = [];\n    for (var i = 0; i < this._sections.length; i++) {\n      for (var j = 0; j < this._sections[i].consumer.sources.length; j++) {\n        sources.push(this._sections[i].consumer.sources[j]);\n      }\n    }\n    return sources;\n  }\n});\n\n/**\n * Returns the original source, line, and column information for the generated\n * source's line and column positions provided. The only argument is an object\n * with the following properties:\n *\n *   - line: The line number in the generated source.  The line number\n *     is 1-based.\n *   - column: The column number in the generated source.  The column\n *     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.  The\n *     line number is 1-based.\n *   - column: The column number in the original source, or null.  The\n *     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    };\n\n    // Find the section containing the generated position we're trying to map\n    // to an original position.\n    var sectionIndex = binarySearch.search(needle, this._sections,\n      function(needle, section) {\n        var cmp = needle.generatedLine - section.generatedOffset.generatedLine;\n        if (cmp) {\n          return cmp;\n        }\n\n        return (needle.generatedColumn -\n                section.generatedOffset.generatedColumn);\n      });\n    var section = this._sections[sectionIndex];\n\n    if (!section) {\n      return {\n        source: null,\n        line: null,\n        column: null,\n        name: null\n      };\n    }\n\n    return section.consumer.originalPositionFor({\n      line: needle.generatedLine -\n        (section.generatedOffset.generatedLine - 1),\n      column: needle.generatedColumn -\n        (section.generatedOffset.generatedLine === needle.generatedLine\n         ? section.generatedOffset.generatedColumn - 1\n         : 0),\n      bias: aArgs.bias\n    });\n  };\n\n/**\n * Return true if we have the source content for every source in the source\n * map, false otherwise.\n */\nIndexedSourceMapConsumer.prototype.hasContentsOfAllSources =\n  function IndexedSourceMapConsumer_hasContentsOfAllSources() {\n    return this._sections.every(function (s) {\n      return s.consumer.hasContentsOfAllSources();\n    });\n  };\n\n/**\n * Returns the original source content. The only argument is the url of the\n * original source file. Returns null if no original source content is\n * available.\n */\nIndexedSourceMapConsumer.prototype.sourceContentFor =\n  function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {\n    for (var i = 0; i < this._sections.length; i++) {\n      var section = this._sections[i];\n\n      var content = section.consumer.sourceContentFor(aSource, true);\n      if (content) {\n        return content;\n      }\n    }\n    if (nullOnMissing) {\n      return null;\n    }\n    else {\n      throw new Error('\"' + aSource + '\" is not in the SourceMap.');\n    }\n  };\n\n/**\n * Returns the generated line and column information for the original source,\n * line, and column positions provided. The only argument is an object with\n * the following properties:\n *\n *   - source: The filename of the original source.\n *   - line: The line number in the original source.  The line number\n *     is 1-based.\n *   - column: The column number in the original source.  The column\n *     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.  The\n *     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[i];\n\n      // Only consider this section if the requested source is in the list of\n      // sources of the consumer.\n      if (section.consumer._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.line\n             ? section.generatedOffset.generatedColumn - 1\n             : 0)\n        };\n        return ret;\n      }\n    }\n\n    return {\n      line: null,\n      column: null\n    };\n  };\n\n/**\n * Parse the mappings in a string in to a data structure which we can easily\n * query (the ordered arrays in the `this.__generatedMappings` and\n * `this.__originalMappings` properties).\n */\nIndexedSourceMapConsumer.prototype._parseMappings =\n  function IndexedSourceMapConsumer_parseMappings(aStr, aSourceRoot) {\n    this.__generatedMappings = [];\n    this.__originalMappings = [];\n    for (var i = 0; i < this._sections.length; i++) {\n      var section = this._sections[i];\n      var sectionMappings = section.consumer._generatedMappings;\n      for (var j = 0; j < sectionMappings.length; j++) {\n        var mapping = sectionMappings[j];\n\n        var source = section.consumer._sources.at(mapping.source);\n        source = util.computeSourceURL(section.consumer.sourceRoot, source, this._sourceMapURL);\n        this._sources.add(source);\n        source = this._sources.indexOf(source);\n\n        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        }\n\n        // The mappings coming from the consumer for the section have\n        // generated positions relative to the start of the section, so we\n        // need to offset them to be relative to the start of the concatenated\n        // generated file.\n        var adjustedMapping = {\n          source: source,\n          generatedLine: mapping.generatedLine +\n            (section.generatedOffset.generatedLine - 1),\n          generatedColumn: mapping.generatedColumn +\n            (section.generatedOffset.generatedLine === mapping.generatedLine\n            ? section.generatedOffset.generatedColumn - 1\n            : 0),\n          originalLine: mapping.originalLine,\n          originalColumn: mapping.originalColumn,\n          name: name\n        };\n\n        this.__generatedMappings.push(adjustedMapping);\n        if (typeof adjustedMapping.originalLine === 'number') {\n          this.__originalMappings.push(adjustedMapping);\n        }\n      }\n    }\n\n    quickSort(this.__generatedMappings, util.compareByGeneratedPositionsDeflated);\n    quickSort(this.__originalMappings, util.compareByOriginalPositions);\n  };\n\nexports.IndexedSourceMapConsumer = IndexedSourceMapConsumer;\n","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nexports.GREATEST_LOWER_BOUND = 1;\nexports.LEAST_UPPER_BOUND = 2;\n\n/**\n * Recursive implementation of binary search.\n *\n * @param aLow Indices here and lower do not contain the needle.\n * @param aHigh Indices here and higher do not contain the needle.\n * @param aNeedle The element being searched for.\n * @param aHaystack The non-empty array being searched.\n * @param aCompare Function which takes two elements and returns -1, 0, or 1.\n * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or\n *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the\n *     closest element that is smaller than or greater than the one we are\n *     searching for, respectively, if the exact element cannot be found.\n */\nfunction recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare, aBias) {\n  // This function terminates when one of the following is true:\n  //\n  //   1. We find the exact element we are looking for.\n  //\n  //   2. We did not find the exact element, but we can return the index of\n  //      the next-closest element.\n  //\n  //   3. We did not find the exact element, and there is no next-closest\n  //      element than the one we are searching for, so we return -1.\n  var mid = Math.floor((aHigh - aLow) / 2) + aLow;\n  var cmp = aCompare(aNeedle, aHaystack[mid], true);\n  if (cmp === 0) {\n    // Found the element we are looking for.\n    return mid;\n  }\n  else if (cmp > 0) {\n    // Our needle is greater than aHaystack[mid].\n    if (aHigh - mid > 1) {\n      // The element is in the upper half.\n      return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias);\n    }\n\n    // The exact needle element was not found in this haystack. Determine if\n    // we are in termination case (3) or (2) and return the appropriate thing.\n    if (aBias == exports.LEAST_UPPER_BOUND) {\n      return aHigh < aHaystack.length ? aHigh : -1;\n    } else {\n      return mid;\n    }\n  }\n  else {\n    // Our needle is less than aHaystack[mid].\n    if (mid - aLow > 1) {\n      // The element is in the lower half.\n      return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias);\n    }\n\n    // we are in termination case (3) or (2) and return the appropriate thing.\n    if (aBias == exports.LEAST_UPPER_BOUND) {\n      return mid;\n    } else {\n      return aLow < 0 ? -1 : aLow;\n    }\n  }\n}\n\n/**\n * This is an implementation of binary search which will always try and return\n * the index of the closest element if there is no exact hit. This is because\n * mappings between original and generated line/col pairs are single points,\n * and there is an implicit region between each of them, so a miss just means\n * that you aren't on the very start of a region.\n *\n * @param aNeedle The element you are looking for.\n * @param aHaystack The array that is being searched.\n * @param aCompare A function which takes the needle and an element in the\n *     array and returns -1, 0, or 1 depending on whether the needle is less\n *     than, equal to, or greater than the element, respectively.\n * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or\n *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the\n *     closest element that is smaller than or greater than the one we are\n *     searching for, respectively, if the exact element cannot be found.\n *     Defaults to 'binarySearch.GREATEST_LOWER_BOUND'.\n */\nexports.search = function search(aNeedle, aHaystack, aCompare, aBias) {\n  if (aHaystack.length === 0) {\n    return -1;\n  }\n\n  var index = recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack,\n                              aCompare, aBias || exports.GREATEST_LOWER_BOUND);\n  if (index < 0) {\n    return -1;\n  }\n\n  // We have found either the exact element, or the next-closest element than\n  // the one we are searching for. However, there may be more than one such\n  // element. Make sure we always return the smallest of these.\n  while (index - 1 >= 0) {\n    if (aCompare(aHaystack[index], aHaystack[index - 1], true) !== 0) {\n      break;\n    }\n    --index;\n  }\n\n  return index;\n};\n","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\n// It turns out that some (most?) JavaScript engines don't self-host\n// `Array.prototype.sort`. This makes sense because C++ will likely remain\n// faster than JS when doing raw CPU-intensive sorting. However, when using a\n// custom comparator function, calling back and forth between the VM's C++ and\n// JIT'd JS is rather slow *and* loses JIT type information, resulting in\n// worse generated code for the comparator function than would be optimal. In\n// fact, when sorting with a comparator, these costs outweigh the benefits of\n// sorting in C++. By using our own JS-implemented Quick Sort (below), we get\n// a ~3500ms mean speed-up in `bench/bench.html`.\n\n/**\n * Swap the elements indexed by `x` and `y` in the array `ary`.\n *\n * @param {Array} ary\n *        The array.\n * @param {Number} x\n *        The index of the first item.\n * @param {Number} y\n *        The index of the second item.\n */\nfunction swap(ary, x, y) {\n  var temp = ary[x];\n  ary[x] = ary[y];\n  ary[y] = temp;\n}\n\n/**\n * Returns a random integer within the range `low .. high` inclusive.\n *\n * @param {Number} low\n *        The lower bound on the range.\n * @param {Number} high\n *        The upper bound on the range.\n */\nfunction randomIntInRange(low, high) {\n  return Math.round(low + (Math.random() * (high - low)));\n}\n\n/**\n * The Quick Sort algorithm.\n *\n * @param {Array} ary\n *        An array to sort.\n * @param {function} comparator\n *        Function to use to compare two items.\n * @param {Number} p\n *        Start index of the array\n * @param {Number} r\n *        End index of the array\n */\nfunction doQuickSort(ary, comparator, p, r) {\n  // If our lower bound is less than our upper bound, we (1) partition the\n  // array into two pieces and (2) recurse on each half. If it is not, this is\n  // the empty array and our base case.\n\n  if (p < r) {\n    // (1) Partitioning.\n    //\n    // The partitioning chooses a pivot between `p` and `r` and moves all\n    // elements that are less than or equal to the pivot to the before it, and\n    // all the elements that are greater than it after it. The effect is that\n    // once partition is done, the pivot is in the exact place it will be when\n    // the array is put in sorted order, and it will not need to be moved\n    // again. This runs in O(n) time.\n\n    // Always choose a random pivot so that an input array which is reverse\n    // sorted does not cause O(n^2) running time.\n    var pivotIndex = randomIntInRange(p, r);\n    var i = p - 1;\n\n    swap(ary, pivotIndex, r);\n    var pivot = ary[r];\n\n    // Immediately after `j` is incremented in this loop, the following hold\n    // true:\n    //\n    //   * Every element in `ary[p .. i]` is less than or equal to the pivot.\n    //\n    //   * Every element in `ary[i+1 .. j-1]` is greater than the pivot.\n    for (var j = p; j < r; j++) {\n      if (comparator(ary[j], pivot) <= 0) {\n        i += 1;\n        swap(ary, i, j);\n      }\n    }\n\n    swap(ary, i + 1, j);\n    var q = i + 1;\n\n    // (2) Recurse on each half.\n\n    doQuickSort(ary, comparator, p, q - 1);\n    doQuickSort(ary, comparator, q + 1, r);\n  }\n}\n\n/**\n * Sort the given array in-place with the given comparator function.\n *\n * @param {Array} ary\n *        An array to sort.\n * @param {function} comparator\n *        Function to use to compare two items.\n */\nexports.quickSort = function (ary, comparator) {\n  doQuickSort(ary, comparator, 0, ary.length - 1);\n};\n","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar SourceMapGenerator = require('./source-map-generator').SourceMapGenerator;\nvar util = require('./util');\n\n// Matches a Windows-style `\\r\\n` newline or a `\\n` newline used by all other\n// operating systems these days (capturing the result).\nvar REGEX_NEWLINE = /(\\r?\\n)/;\n\n// Newline character code for charCodeAt() comparisons\nvar NEWLINE_CODE = 10;\n\n// Private symbol for identifying `SourceNode`s when multiple versions of\n// the source-map library are loaded. This MUST NOT CHANGE across\n// versions!\nvar isSourceNode = \"$$$isSourceNode$$$\";\n\n/**\n * SourceNodes provide a way to abstract over interpolating/concatenating\n * snippets of generated JavaScript source code while maintaining the line and\n * column information associated with the original source code.\n *\n * @param aLine The original line number.\n * @param aColumn The original column number.\n * @param aSource The original source's filename.\n * @param aChunks Optional. An array of strings which are snippets of\n *        generated JS, or other SourceNodes.\n * @param aName The original identifier.\n */\nfunction SourceNode(aLine, aColumn, aSource, aChunks, aName) {\n  this.children = [];\n  this.sourceContents = {};\n  this.line = aLine == null ? null : aLine;\n  this.column = aColumn == null ? null : aColumn;\n  this.source = aSource == null ? null : aSource;\n  this.name = aName == null ? null : aName;\n  this[isSourceNode] = true;\n  if (aChunks != null) this.add(aChunks);\n}\n\n/**\n * Creates a SourceNode from generated code and a SourceMapConsumer.\n *\n * @param aGeneratedCode The generated code\n * @param aSourceMapConsumer The SourceMap for the generated code\n * @param aRelativePath Optional. The path that relative sources in the\n *        SourceMapConsumer should be relative to.\n */\nSourceNode.fromStringWithSourceMap =\n  function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {\n    // The SourceNode we want to fill with the generated code\n    // and the SourceMap\n    var node = new SourceNode();\n\n    // All even indices of this array are one line of the generated code,\n    // while all odd indices are the newlines between two adjacent lines\n    // (since `REGEX_NEWLINE` captures its match).\n    // Processed fragments are 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;\n\n      function getNextLine() {\n        return remainingLinesIndex < remainingLines.length ?\n            remainingLines[remainingLinesIndex++] : undefined;\n      }\n    };\n\n    // We need to remember the position of \"remainingLines\"\n    var lastGeneratedLine = 1, lastGeneratedColumn = 0;\n\n    // The generate SourceNodes we need a code range.\n    // To extract it current and last mapping is used.\n    // Here we store the last mapping.\n    var lastMapping = null;\n\n    aSourceMapConsumer.eachMapping(function (mapping) {\n      if (lastMapping !== null) {\n        // We add the code from \"lastMapping\" to \"mapping\":\n        // First check if there is a new line in between.\n        if (lastGeneratedLine < mapping.generatedLine) {\n          // Associate first line with \"lastMapping\"\n          addMappingWithCode(lastMapping, shiftNextLine());\n          lastGeneratedLine++;\n          lastGeneratedColumn = 0;\n          // The remaining code is added without mapping\n        } else {\n          // There is no new line in between.\n          // Associate the code between \"lastGeneratedColumn\" and\n          // \"mapping.generatedColumn\" with \"lastMapping\"\n          var nextLine = remainingLines[remainingLinesIndex] || '';\n          var code = nextLine.substr(0, mapping.generatedColumn -\n                                        lastGeneratedColumn);\n          remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn -\n                                              lastGeneratedColumn);\n          lastGeneratedColumn = mapping.generatedColumn;\n          addMappingWithCode(lastMapping, code);\n          // No more remaining code, continue\n          lastMapping = mapping;\n          return;\n        }\n      }\n      // We add the generated code until the first mapping\n      // to the SourceNode without any mapping.\n      // Each line is added as separate string.\n      while (lastGeneratedLine < mapping.generatedLine) {\n        node.add(shiftNextLine());\n        lastGeneratedLine++;\n      }\n      if (lastGeneratedColumn < mapping.generatedColumn) {\n        var nextLine = remainingLines[remainingLinesIndex] || '';\n        node.add(nextLine.substr(0, mapping.generatedColumn));\n        remainingLines[remainingLinesIndex] = 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 mapping\n      node.add(remainingLines.splice(remainingLinesIndex).join(\"\"));\n    }\n\n    // Copy sourcesContent into SourceNode\n    aSourceMapConsumer.sources.forEach(function (sourceFile) {\n      var content = aSourceMapConsumer.sourceContentFor(sourceFile);\n      if (content != null) {\n        if (aRelativePath != null) {\n          sourceFile = util.join(aRelativePath, sourceFile);\n        }\n        node.setSourceContent(sourceFile, content);\n      }\n    });\n\n    return node;\n\n    function addMappingWithCode(mapping, code) {\n      if (mapping === null || mapping.source === undefined) {\n        node.add(code);\n      } else {\n        var source = aRelativePath\n          ? util.join(aRelativePath, mapping.source)\n          : mapping.source;\n        node.add(new SourceNode(mapping.originalLine,\n                                mapping.originalColumn,\n                                source,\n                                code,\n                                mapping.name));\n      }\n    }\n  };\n\n/**\n * Add a chunk of generated JS to this source node.\n *\n * @param aChunk A string snippet of generated JS code, another instance of\n *        SourceNode, or an array where each member is one of those things.\n */\nSourceNode.prototype.add = function SourceNode_add(aChunk) {\n  if (Array.isArray(aChunk)) {\n    aChunk.forEach(function (chunk) {\n      this.add(chunk);\n    }, this);\n  }\n  else if (aChunk[isSourceNode] || typeof aChunk === \"string\") {\n    if (aChunk) {\n      this.children.push(aChunk);\n    }\n  }\n  else {\n    throw new TypeError(\n      \"Expected a SourceNode, string, or an array of SourceNodes and strings. Got \" + aChunk\n    );\n  }\n  return this;\n};\n\n/**\n * Add a chunk of generated JS to the beginning of this source node.\n *\n * @param aChunk A string snippet of generated JS code, another instance of\n *        SourceNode, or an array where each member is one of those things.\n */\nSourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {\n  if (Array.isArray(aChunk)) {\n    for (var i = aChunk.length-1; i >= 0; i--) {\n      this.prepend(aChunk[i]);\n    }\n  }\n  else if (aChunk[isSourceNode] || typeof aChunk === \"string\") {\n    this.children.unshift(aChunk);\n  }\n  else {\n    throw new TypeError(\n      \"Expected a SourceNode, string, or an array of SourceNodes and strings. Got \" + aChunk\n    );\n  }\n  return this;\n};\n\n/**\n * Walk over the tree of JS snippets in this node and its children. The\n * walking function is called once for each snippet of JS and is passed that\n * snippet and the its original associated source's line/column location.\n *\n * @param aFn The traversal function.\n */\nSourceNode.prototype.walk = function SourceNode_walk(aFn) {\n  var chunk;\n  for (var i = 0, len = this.children.length; i < len; i++) {\n    chunk = this.children[i];\n    if (chunk[isSourceNode]) {\n      chunk.walk(aFn);\n    }\n    else {\n      if (chunk !== '') {\n        aFn(chunk, { source: this.source,\n                     line: this.line,\n                     column: this.column,\n                     name: this.name });\n      }\n    }\n  }\n};\n\n/**\n * Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between\n * each of `this.children`.\n *\n * @param aSep The separator.\n */\nSourceNode.prototype.join = function SourceNode_join(aSep) {\n  var newChildren;\n  var i;\n  var len = this.children.length;\n  if (len > 0) {\n    newChildren = [];\n    for (i = 0; i < len-1; i++) {\n      newChildren.push(this.children[i]);\n      newChildren.push(aSep);\n    }\n    newChildren.push(this.children[i]);\n    this.children = newChildren;\n  }\n  return this;\n};\n\n/**\n * Call String.prototype.replace on the very right-most source snippet. Useful\n * for trimming whitespace from the end of a source node, etc.\n *\n * @param aPattern The pattern to replace.\n * @param aReplacement The thing to replace the pattern with.\n */\nSourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {\n  var lastChild = this.children[this.children.length - 1];\n  if (lastChild[isSourceNode]) {\n    lastChild.replaceRight(aPattern, aReplacement);\n  }\n  else if (typeof lastChild === 'string') {\n    this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);\n  }\n  else {\n    this.children.push(''.replace(aPattern, aReplacement));\n  }\n  return this;\n};\n\n/**\n * Set the source content for a source file. This will be added to the SourceMapGenerator\n * in the sourcesContent field.\n *\n * @param aSourceFile The filename of the source file\n * @param aSourceContent The content of the source file\n */\nSourceNode.prototype.setSourceContent =\n  function SourceNode_setSourceContent(aSourceFile, aSourceContent) {\n    this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;\n  };\n\n/**\n * Walk over the tree of SourceNodes. The walking function is called for each\n * source file content and is passed the filename and source content.\n *\n * @param aFn The traversal function.\n */\nSourceNode.prototype.walkSourceContents =\n  function SourceNode_walkSourceContents(aFn) {\n    for (var i = 0, len = this.children.length; i < len; i++) {\n      if (this.children[i][isSourceNode]) {\n        this.children[i].walkSourceContents(aFn);\n      }\n    }\n\n    var sources = Object.keys(this.sourceContents);\n    for (var i = 0, len = sources.length; i < len; i++) {\n      aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);\n    }\n  };\n\n/**\n * Return the string representation of this source node. Walks over the tree\n * and concatenates all the various snippets together to one string.\n */\nSourceNode.prototype.toString = function SourceNode_toString() {\n  var str = \"\";\n  this.walk(function (chunk) {\n    str += chunk;\n  });\n  return str;\n};\n\n/**\n * Returns the string representation of this source node along with a source\n * map.\n */\nSourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {\n  var generated = {\n    code: \"\",\n    line: 1,\n    column: 0\n  };\n  var map = new SourceMapGenerator(aArgs);\n  var sourceMappingActive = false;\n  var lastOriginalSource = null;\n  var lastOriginalLine = null;\n  var lastOriginalColumn = null;\n  var lastOriginalName = null;\n  this.walk(function (chunk, original) {\n    generated.code += chunk;\n    if (original.source !== null\n        && original.line !== null\n        && original.column !== null) {\n      if(lastOriginalSource !== original.source\n         || lastOriginalLine !== original.line\n         || lastOriginalColumn !== original.column\n         || lastOriginalName !== original.name) {\n        map.addMapping({\n          source: original.source,\n          original: {\n            line: original.line,\n            column: original.column\n          },\n          generated: {\n            line: generated.line,\n            column: generated.column\n          },\n          name: original.name\n        });\n      }\n      lastOriginalSource = original.source;\n      lastOriginalLine = original.line;\n      lastOriginalColumn = original.column;\n      lastOriginalName = original.name;\n      sourceMappingActive = true;\n    } else if (sourceMappingActive) {\n      map.addMapping({\n        generated: {\n          line: generated.line,\n          column: generated.column\n        }\n      });\n      lastOriginalSource = null;\n      sourceMappingActive = false;\n    }\n    for (var idx = 0, length = chunk.length; idx < length; idx++) {\n      if (chunk.charCodeAt(idx) === NEWLINE_CODE) {\n        generated.line++;\n        generated.column = 0;\n        // Mappings end at eol\n        if (idx + 1 === length) {\n          lastOriginalSource = null;\n          sourceMappingActive = false;\n        } else if (sourceMappingActive) {\n          map.addMapping({\n            source: original.source,\n            original: {\n              line: original.line,\n              column: original.column\n            },\n            generated: {\n              line: generated.line,\n              column: generated.column\n            },\n            name: original.name\n          });\n        }\n      } else {\n        generated.column++;\n      }\n    }\n  });\n  this.walkSourceContents(function (sourceFile, sourceContent) {\n    map.setSourceContent(sourceFile, sourceContent);\n  });\n\n  return { code: generated.code, map: map };\n};\n\nexports.SourceNode = SourceNode;\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","'use strict';\n\nexports.__esModule = true;\nexports.default = warnOnce;\nvar printed = {};\n\nfunction warnOnce(message) {\n  if (printed[message]) return;\n  printed[message] = true;\n\n  if (typeof console !== 'undefined' && console.warn) {\n    console.warn(message);\n  }\n}\nmodule.exports = exports['default'];\n//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIndhcm4tb25jZS5lczYiXSwibmFtZXMiOlsid2Fybk9uY2UiLCJwcmludGVkIiwibWVzc2FnZSIsImNvbnNvbGUiLCJ3YXJuIl0sIm1hcHBpbmdzIjoiOzs7a0JBRXdCQSxRO0FBRnhCLElBQUlDLFVBQVUsRUFBZDs7QUFFZSxTQUFTRCxRQUFULENBQW1CRSxPQUFuQixFQUE0QjtBQUN6QyxNQUFJRCxRQUFRQyxPQUFSLENBQUosRUFBc0I7QUFDdEJELFVBQVFDLE9BQVIsSUFBbUIsSUFBbkI7O0FBRUEsTUFBSSxPQUFPQyxPQUFQLEtBQW1CLFdBQW5CLElBQWtDQSxRQUFRQyxJQUE5QyxFQUFvRDtBQUNsREQsWUFBUUMsSUFBUixDQUFhRixPQUFiO0FBQ0Q7QUFDRiIsImZpbGUiOiJ3YXJuLW9uY2UuanMiLCJzb3VyY2VzQ29udGVudCI6WyJsZXQgcHJpbnRlZCA9IHsgfVxuXG5leHBvcnQgZGVmYXVsdCBmdW5jdGlvbiB3YXJuT25jZSAobWVzc2FnZSkge1xuICBpZiAocHJpbnRlZFttZXNzYWdlXSkgcmV0dXJuXG4gIHByaW50ZWRbbWVzc2FnZV0gPSB0cnVlXG5cbiAgaWYgKHR5cGVvZiBjb25zb2xlICE9PSAndW5kZWZpbmVkJyAmJiBjb25zb2xlLndhcm4pIHtcbiAgICBjb25zb2xlLndhcm4obWVzc2FnZSlcbiAgfVxufVxuIl19\n","'use strict';\n\nexports.__esModule = true;\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _warning = require('./warning');\n\nvar _warning2 = _interopRequireDefault(_warning);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n/**\n * Provides the result of the PostCSS transformations.\n *\n * A Result instance is returned by {@link LazyResult#then}\n * or {@link Root#toResult} methods.\n *\n * @example\n * postcss([cssnext]).process(css).then(result => {\n *  console.log(result.css)\n * })\n *\n * @example\n * const result2 = postcss.parse(css).toResult()\n */\nvar Result = function () {\n  /**\n   * @param {Processor} processor Processor used for this transformation.\n   * @param {Root}      root      Root node after all transformations.\n   * @param {processOptions} opts Options from the {@link Processor#process}\n   *                              or {@link Root#toResult}.\n   */\n  function Result(processor, root, opts) {\n    _classCallCheck(this, Result);\n\n    /**\n     * The Processor instance used for this transformation.\n     *\n     * @type {Processor}\n     *\n     * @example\n     * for (const plugin of result.processor.plugins) {\n     *   if (plugin.postcssPlugin === 'postcss-bad') {\n     *     throw 'postcss-good is incompatible with postcss-bad'\n     *   }\n     * })\n     */\n    this.processor = processor;\n    /**\n     * Contains messages from plugins (e.g., warnings or custom messages).\n     * Each message should have type and plugin properties.\n     *\n     * @type {Message[]}\n     *\n     * @example\n     * postcss.plugin('postcss-min-browser', () => {\n     *   return (root, result) => {\n     *     const browsers = detectMinBrowsersByCanIUse(root)\n     *     result.messages.push({\n     *       type: 'min-browser',\n     *       plugin: 'postcss-min-browser',\n     *       browsers\n     *     })\n     *   }\n     * })\n     */\n    this.messages = [];\n    /**\n     * Root node after all transformations.\n     *\n     * @type {Root}\n     *\n     * @example\n     * root.toResult().root === root\n     */\n    this.root = root;\n    /**\n     * Options from the {@link Processor#process} or {@link Root#toResult} call\n     * that produced this Result instance.\n     *\n     * @type {processOptions}\n     *\n     * @example\n     * root.toResult(opts).opts === opts\n     */\n    this.opts = opts;\n    /**\n     * A CSS string representing of {@link Result#root}.\n     *\n     * @type {string}\n     *\n     * @example\n     * postcss.parse('a{}').toResult().css //=> \"a{}\"\n     */\n    this.css = undefined;\n    /**\n     * An instance of `SourceMapGenerator` class from the `source-map` library,\n     * representing changes to the {@link Result#root} instance.\n     *\n     * @type {SourceMapGenerator}\n     *\n     * @example\n     * result.map.toJSON() //=> { version: 3, file: 'a.css', … }\n     *\n     * @example\n     * if (result.map) {\n     *   fs.writeFileSync(result.opts.to + '.map', result.map.toString())\n     * }\n     */\n    this.map = undefined;\n  }\n\n  /**\n   * Returns for @{link Result#css} content.\n   *\n   * @example\n   * result + '' === result.css\n   *\n   * @return {string} String representing of {@link Result#root}.\n   */\n\n\n  Result.prototype.toString = function toString() {\n    return this.css;\n  };\n\n  /**\n   * Creates an instance of {@link Warning} and adds it\n   * to {@link Result#messages}.\n   *\n   * @param {string} text        Warning message.\n   * @param {Object} [opts]      Warning options.\n   * @param {Node}   opts.node   CSS node that caused the warning.\n   * @param {string} opts.word   Word in CSS source that caused the warning.\n   * @param {number} opts.index  Index in CSS node string that caused\n   *                             the warning.\n   * @param {string} opts.plugin Name of the plugin that created\n   *                             this warning. {@link Result#warn} fills\n   *                             this property automatically.\n   *\n   * @return {Warning} Created warning.\n   */\n\n\n  Result.prototype.warn = function warn(text) {\n    var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    if (!opts.plugin) {\n      if (this.lastPlugin && this.lastPlugin.postcssPlugin) {\n        opts.plugin = this.lastPlugin.postcssPlugin;\n      }\n    }\n\n    var warning = new _warning2.default(text, opts);\n    this.messages.push(warning);\n\n    return warning;\n  };\n\n  /**\n     * Returns warnings from plugins. Filters {@link Warning} instances\n     * from {@link Result#messages}.\n     *\n     * @example\n     * result.warnings().forEach(warn => {\n     *   console.warn(warn.toString())\n     * })\n     *\n     * @return {Warning[]} Warnings from plugins.\n     */\n\n\n  Result.prototype.warnings = function warnings() {\n    return this.messages.filter(function (i) {\n      return i.type === 'warning';\n    });\n  };\n\n  /**\n   * An alias for the {@link Result#css} property.\n   * Use it with syntaxes that generate non-CSS output.\n   *\n   * @type {string}\n   *\n   * @example\n   * result.css === result.content\n   */\n\n\n  _createClass(Result, [{\n    key: 'content',\n    get: function get() {\n      return this.css;\n    }\n  }]);\n\n  return Result;\n}();\n\nexports.default = Result;\n\n/**\n * @typedef  {object} Message\n * @property {string} type   Message type.\n * @property {string} plugin Source PostCSS plugin name.\n */\n\nmodule.exports = exports['default'];\n//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["result.es6"],"names":["Result","processor","root","opts","messages","css","undefined","map","toString","warn","text","plugin","lastPlugin","postcssPlugin","warning","Warning","push","warnings","filter","i","type"],"mappings":";;;;;;AAAA;;;;;;;;AAEA;;;;;;;;;;;;;;IAcMA,M;AACJ;;;;;;AAMA,kBAAaC,SAAb,EAAwBC,IAAxB,EAA8BC,IAA9B,EAAoC;AAAA;;AAClC;;;;;;;;;;;;AAYA,SAAKF,SAAL,GAAiBA,SAAjB;AACA;;;;;;;;;;;;;;;;;;AAkBA,SAAKG,QAAL,GAAgB,EAAhB;AACA;;;;;;;;AAQA,SAAKF,IAAL,GAAYA,IAAZ;AACA;;;;;;;;;AASA,SAAKC,IAAL,GAAYA,IAAZ;AACA;;;;;;;;AAQA,SAAKE,GAAL,GAAWC,SAAX;AACA;;;;;;;;;;;;;;AAcA,SAAKC,GAAL,GAAWD,SAAX;AACD;;AAED;;;;;;;;;;mBAQAE,Q,uBAAY;AACV,WAAO,KAAKH,GAAZ;AACD,G;;AAED;;;;;;;;;;;;;;;;;;mBAgBAI,I,iBAAMC,I,EAAkB;AAAA,QAAZP,IAAY,uEAAL,EAAK;;AACtB,QAAI,CAACA,KAAKQ,MAAV,EAAkB;AAChB,UAAI,KAAKC,UAAL,IAAmB,KAAKA,UAAL,CAAgBC,aAAvC,EAAsD;AACpDV,aAAKQ,MAAL,GAAc,KAAKC,UAAL,CAAgBC,aAA9B;AACD;AACF;;AAED,QAAIC,UAAU,IAAIC,iBAAJ,CAAYL,IAAZ,EAAkBP,IAAlB,CAAd;AACA,SAAKC,QAAL,CAAcY,IAAd,CAAmBF,OAAnB;;AAEA,WAAOA,OAAP;AACD,G;;AAED;;;;;;;;;;;;;mBAWAG,Q,uBAAY;AACV,WAAO,KAAKb,QAAL,CAAcc,MAAd,CAAqB;AAAA,aAAKC,EAAEC,IAAF,KAAW,SAAhB;AAAA,KAArB,CAAP;AACD,G;;AAED;;;;;;;;;;;;;wBASe;AACb,aAAO,KAAKf,GAAZ;AACD;;;;;;kBAGYL,M;;AAEf","file":"result.js","sourcesContent":["import Warning from './warning'\n\n/**\n * Provides the result of the PostCSS transformations.\n *\n * A Result instance is returned by {@link LazyResult#then}\n * or {@link Root#toResult} methods.\n *\n * @example\n * postcss([cssnext]).process(css).then(result => {\n *  console.log(result.css)\n * })\n *\n * @example\n * const result2 = postcss.parse(css).toResult()\n */\nclass Result {\n  /**\n   * @param {Processor} processor Processor used for this transformation.\n   * @param {Root}      root      Root node after all transformations.\n   * @param {processOptions} opts Options from the {@link Processor#process}\n   *                              or {@link Root#toResult}.\n   */\n  constructor (processor, root, opts) {\n    /**\n     * The Processor instance used for this transformation.\n     *\n     * @type {Processor}\n     *\n     * @example\n     * for (const plugin of result.processor.plugins) {\n     *   if (plugin.postcssPlugin === 'postcss-bad') {\n     *     throw 'postcss-good is incompatible with postcss-bad'\n     *   }\n     * })\n     */\n    this.processor = processor\n    /**\n     * Contains messages from plugins (e.g., warnings or custom messages).\n     * Each message should have type and plugin properties.\n     *\n     * @type {Message[]}\n     *\n     * @example\n     * postcss.plugin('postcss-min-browser', () => {\n     *   return (root, result) => {\n     *     const browsers = detectMinBrowsersByCanIUse(root)\n     *     result.messages.push({\n     *       type: 'min-browser',\n     *       plugin: 'postcss-min-browser',\n     *       browsers\n     *     })\n     *   }\n     * })\n     */\n    this.messages = []\n    /**\n     * Root node after all transformations.\n     *\n     * @type {Root}\n     *\n     * @example\n     * root.toResult().root === root\n     */\n    this.root = root\n    /**\n     * Options from the {@link Processor#process} or {@link Root#toResult} call\n     * that produced this Result instance.\n     *\n     * @type {processOptions}\n     *\n     * @example\n     * root.toResult(opts).opts === opts\n     */\n    this.opts = opts\n    /**\n     * A CSS string representing of {@link Result#root}.\n     *\n     * @type {string}\n     *\n     * @example\n     * postcss.parse('a{}').toResult().css //=> \"a{}\"\n     */\n    this.css = undefined\n    /**\n     * An instance of `SourceMapGenerator` class from the `source-map` library,\n     * representing changes to the {@link Result#root} instance.\n     *\n     * @type {SourceMapGenerator}\n     *\n     * @example\n     * result.map.toJSON() //=> { version: 3, file: 'a.css', … }\n     *\n     * @example\n     * if (result.map) {\n     *   fs.writeFileSync(result.opts.to + '.map', result.map.toString())\n     * }\n     */\n    this.map = undefined\n  }\n\n  /**\n   * Returns for @{link Result#css} content.\n   *\n   * @example\n   * result + '' === result.css\n   *\n   * @return {string} String representing of {@link Result#root}.\n   */\n  toString () {\n    return this.css\n  }\n\n  /**\n   * Creates an instance of {@link Warning} and adds it\n   * to {@link Result#messages}.\n   *\n   * @param {string} text        Warning message.\n   * @param {Object} [opts]      Warning options.\n   * @param {Node}   opts.node   CSS node that caused the warning.\n   * @param {string} opts.word   Word in CSS source that caused the warning.\n   * @param {number} opts.index  Index in CSS node string that caused\n   *                             the warning.\n   * @param {string} opts.plugin Name of the plugin that created\n   *                             this warning. {@link Result#warn} fills\n   *                             this property automatically.\n   *\n   * @return {Warning} Created warning.\n   */\n  warn (text, opts = { }) {\n    if (!opts.plugin) {\n      if (this.lastPlugin && this.lastPlugin.postcssPlugin) {\n        opts.plugin = this.lastPlugin.postcssPlugin\n      }\n    }\n\n    let warning = new Warning(text, opts)\n    this.messages.push(warning)\n\n    return warning\n  }\n\n  /**\n     * Returns warnings from plugins. Filters {@link Warning} instances\n     * from {@link Result#messages}.\n     *\n     * @example\n     * result.warnings().forEach(warn => {\n     *   console.warn(warn.toString())\n     * })\n     *\n     * @return {Warning[]} Warnings from plugins.\n     */\n  warnings () {\n    return this.messages.filter(i => i.type === 'warning')\n  }\n\n  /**\n   * An alias for the {@link Result#css} property.\n   * Use it with syntaxes that generate non-CSS output.\n   *\n   * @type {string}\n   *\n   * @example\n   * result.css === result.content\n   */\n  get content () {\n    return this.css\n  }\n}\n\nexport default Result\n\n/**\n * @typedef  {object} Message\n * @property {string} type   Message type.\n * @property {string} plugin Source PostCSS plugin name.\n */\n"]}\n","'use strict';\n\nexports.__esModule = true;\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n/**\n * Represents a plugin’s warning. It can be created using {@link Node#warn}.\n *\n * @example\n * if (decl.important) {\n *   decl.warn(result, 'Avoid !important', { word: '!important' })\n * }\n */\nvar Warning = function () {\n  /**\n   * @param {string} text        Warning message.\n   * @param {Object} [opts]      Warning options.\n   * @param {Node}   opts.node   CSS node that caused the warning.\n   * @param {string} opts.word   Word in CSS source that caused the warning.\n   * @param {number} opts.index  Index in CSS node string that caused\n   *                             the warning.\n   * @param {string} opts.plugin Name of the plugin that created\n   *                             this warning. {@link Result#warn} fills\n   *                             this property automatically.\n   */\n  function Warning(text) {\n    var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    _classCallCheck(this, Warning);\n\n    /**\n     * Type to filter warnings from {@link Result#messages}.\n     * Always equal to `\"warning\"`.\n     *\n     * @type {string}\n     *\n     * @example\n     * const nonWarning = result.messages.filter(i => i.type !== 'warning')\n     */\n    this.type = 'warning';\n    /**\n     * The warning message.\n     *\n     * @type {string}\n     *\n     * @example\n     * warning.text //=> 'Try to avoid !important'\n     */\n    this.text = text;\n\n    if (opts.node && opts.node.source) {\n      var pos = opts.node.positionBy(opts);\n      /**\n       * Line in the input file with this warning’s source.\n       * @type {number}\n       *\n       * @example\n       * warning.line //=> 5\n       */\n      this.line = pos.line;\n      /**\n       * Column in the input file with this warning’s source.\n       *\n       * @type {number}\n       *\n       * @example\n       * warning.column //=> 6\n       */\n      this.column = pos.column;\n    }\n\n    for (var opt in opts) {\n      this[opt] = opts[opt];\n    }\n  }\n\n  /**\n   * Returns a warning position and message.\n   *\n   * @example\n   * warning.toString() //=> 'postcss-lint:a.css:10:14: Avoid !important'\n   *\n   * @return {string} Warning position and message.\n   */\n\n\n  Warning.prototype.toString = function toString() {\n    if (this.node) {\n      return this.node.error(this.text, {\n        plugin: this.plugin,\n        index: this.index,\n        word: this.word\n      }).message;\n    } else if (this.plugin) {\n      return this.plugin + ': ' + this.text;\n    } else {\n      return this.text;\n    }\n  };\n\n  /**\n   * @memberof Warning#\n   * @member {string} plugin The name of the plugin that created\n   *                         it will fill this property automatically.\n   *                         this warning. When you call {@link Node#warn}\n   *\n   * @example\n   * warning.plugin //=> 'postcss-important'\n   */\n\n  /**\n   * @memberof Warning#\n   * @member {Node} node Contains the CSS node that caused the warning.\n   *\n   * @example\n   * warning.node.toString() //=> 'color: white !important'\n   */\n\n\n  return Warning;\n}();\n\nexports.default = Warning;\nmodule.exports = exports['default'];\n//# sourceMappingURL=data:application/json;charset=utf8;base64,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\n","'use strict';\n\nexports.__esModule = true;\n\nvar _declaration = require('./declaration');\n\nvar _declaration2 = _interopRequireDefault(_declaration);\n\nvar _tokenize = require('./tokenize');\n\nvar _tokenize2 = _interopRequireDefault(_tokenize);\n\nvar _comment = require('./comment');\n\nvar _comment2 = _interopRequireDefault(_comment);\n\nvar _atRule = require('./at-rule');\n\nvar _atRule2 = _interopRequireDefault(_atRule);\n\nvar _root = require('./root');\n\nvar _root2 = _interopRequireDefault(_root);\n\nvar _rule = require('./rule');\n\nvar _rule2 = _interopRequireDefault(_rule);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar Parser = function () {\n  function Parser(input) {\n    _classCallCheck(this, Parser);\n\n    this.input = input;\n\n    this.root = new _root2.default();\n    this.current = this.root;\n    this.spaces = '';\n    this.semicolon = false;\n\n    this.createTokenizer();\n    this.root.source = { input: input, start: { line: 1, column: 1 } };\n  }\n\n  Parser.prototype.createTokenizer = function createTokenizer() {\n    this.tokenizer = (0, _tokenize2.default)(this.input);\n  };\n\n  Parser.prototype.parse = function parse() {\n    var token = void 0;\n    while (!this.tokenizer.endOfFile()) {\n      token = this.tokenizer.nextToken();\n\n      switch (token[0]) {\n        case 'space':\n          this.spaces += token[1];\n          break;\n\n        case ';':\n          this.freeSemicolon(token);\n          break;\n\n        case '}':\n          this.end(token);\n          break;\n\n        case 'comment':\n          this.comment(token);\n          break;\n\n        case 'at-word':\n          this.atrule(token);\n          break;\n\n        case '{':\n          this.emptyRule(token);\n          break;\n\n        default:\n          this.other(token);\n          break;\n      }\n    }\n    this.endFile();\n  };\n\n  Parser.prototype.comment = function comment(token) {\n    var node = new _comment2.default();\n    this.init(node, token[2], token[3]);\n    node.source.end = { line: token[4], column: token[5] };\n\n    var text = token[1].slice(2, -2);\n    if (/^\\s*$/.test(text)) {\n      node.text = '';\n      node.raws.left = text;\n      node.raws.right = '';\n    } else {\n      var match = text.match(/^(\\s*)([^]*[^\\s])(\\s*)$/);\n      node.text = match[2];\n      node.raws.left = match[1];\n      node.raws.right = match[3];\n    }\n  };\n\n  Parser.prototype.emptyRule = function emptyRule(token) {\n    var node = new _rule2.default();\n    this.init(node, token[2], token[3]);\n    node.selector = '';\n    node.raws.between = '';\n    this.current = node;\n  };\n\n  Parser.prototype.other = function other(start) {\n    var end = false;\n    var type = null;\n    var colon = false;\n    var bracket = null;\n    var brackets = [];\n\n    var tokens = [];\n    var token = start;\n    while (token) {\n      type = token[0];\n      tokens.push(token);\n\n      if (type === '(' || type === '[') {\n        if (!bracket) bracket = token;\n        brackets.push(type === '(' ? ')' : ']');\n      } else if (brackets.length === 0) {\n        if (type === ';') {\n          if (colon) {\n            this.decl(tokens);\n            return;\n          } else {\n            break;\n          }\n        } else if (type === '{') {\n          this.rule(tokens);\n          return;\n        } else if (type === '}') {\n          this.tokenizer.back(tokens.pop());\n          end = true;\n          break;\n        } else if (type === ':') {\n          colon = true;\n        }\n      } else if (type === brackets[brackets.length - 1]) {\n        brackets.pop();\n        if (brackets.length === 0) bracket = null;\n      }\n\n      token = this.tokenizer.nextToken();\n    }\n\n    if (this.tokenizer.endOfFile()) end = true;\n    if (brackets.length > 0) this.unclosedBracket(bracket);\n\n    if (end && colon) {\n      while (tokens.length) {\n        token = tokens[tokens.length - 1][0];\n        if (token !== 'space' && token !== 'comment') break;\n        this.tokenizer.back(tokens.pop());\n      }\n      this.decl(tokens);\n    } else {\n      this.unknownWord(tokens);\n    }\n  };\n\n  Parser.prototype.rule = function rule(tokens) {\n    tokens.pop();\n\n    var node = new _rule2.default();\n    this.init(node, tokens[0][2], tokens[0][3]);\n\n    node.raws.between = this.spacesAndCommentsFromEnd(tokens);\n    this.raw(node, 'selector', tokens);\n    this.current = node;\n  };\n\n  Parser.prototype.decl = function decl(tokens) {\n    var node = new _declaration2.default();\n    this.init(node);\n\n    var last = tokens[tokens.length - 1];\n    if (last[0] === ';') {\n      this.semicolon = true;\n      tokens.pop();\n    }\n    if (last[4]) {\n      node.source.end = { line: last[4], column: last[5] };\n    } else {\n      node.source.end = { line: last[2], column: last[3] };\n    }\n\n    while (tokens[0][0] !== 'word') {\n      if (tokens.length === 1) this.unknownWord(tokens);\n      node.raws.before += tokens.shift()[1];\n    }\n    node.source.start = { line: tokens[0][2], column: tokens[0][3] };\n\n    node.prop = '';\n    while (tokens.length) {\n      var type = tokens[0][0];\n      if (type === ':' || type === 'space' || type === 'comment') {\n        break;\n      }\n      node.prop += tokens.shift()[1];\n    }\n\n    node.raws.between = '';\n\n    var token = void 0;\n    while (tokens.length) {\n      token = tokens.shift();\n\n      if (token[0] === ':') {\n        node.raws.between += token[1];\n        break;\n      } else {\n        node.raws.between += token[1];\n      }\n    }\n\n    if (node.prop[0] === '_' || node.prop[0] === '*') {\n      node.raws.before += node.prop[0];\n      node.prop = node.prop.slice(1);\n    }\n    node.raws.between += this.spacesAndCommentsFromStart(tokens);\n    this.precheckMissedSemicolon(tokens);\n\n    for (var i = tokens.length - 1; i > 0; i--) {\n      token = tokens[i];\n      if (token[1].toLowerCase() === '!important') {\n        node.important = true;\n        var string = this.stringFrom(tokens, i);\n        string = this.spacesFromEnd(tokens) + string;\n        if (string !== ' !important') node.raws.important = string;\n        break;\n      } else if (token[1].toLowerCase() === 'important') {\n        var cache = tokens.slice(0);\n        var str = '';\n        for (var j = i; j > 0; j--) {\n          var _type = cache[j][0];\n          if (str.trim().indexOf('!') === 0 && _type !== 'space') {\n            break;\n          }\n          str = cache.pop()[1] + str;\n        }\n        if (str.trim().indexOf('!') === 0) {\n          node.important = true;\n          node.raws.important = str;\n          tokens = cache;\n        }\n      }\n\n      if (token[0] !== 'space' && token[0] !== 'comment') {\n        break;\n      }\n    }\n\n    this.raw(node, 'value', tokens);\n\n    if (node.value.indexOf(':') !== -1) this.checkMissedSemicolon(tokens);\n  };\n\n  Parser.prototype.atrule = function atrule(token) {\n    var node = new _atRule2.default();\n    node.name = token[1].slice(1);\n    if (node.name === '') {\n      this.unnamedAtrule(node, token);\n    }\n    this.init(node, token[2], token[3]);\n\n    var prev = void 0;\n    var shift = void 0;\n    var last = false;\n    var open = false;\n    var params = [];\n\n    while (!this.tokenizer.endOfFile()) {\n      token = this.tokenizer.nextToken();\n\n      if (token[0] === ';') {\n        node.source.end = { line: token[2], column: token[3] };\n        this.semicolon = true;\n        break;\n      } else if (token[0] === '{') {\n        open = true;\n        break;\n      } else if (token[0] === '}') {\n        if (params.length > 0) {\n          shift = params.length - 1;\n          prev = params[shift];\n          while (prev && prev[0] === 'space') {\n            prev = params[--shift];\n          }\n          if (prev) {\n            node.source.end = { line: prev[4], column: prev[5] };\n          }\n        }\n        this.end(token);\n        break;\n      } else {\n        params.push(token);\n      }\n\n      if (this.tokenizer.endOfFile()) {\n        last = true;\n        break;\n      }\n    }\n\n    node.raws.between = this.spacesAndCommentsFromEnd(params);\n    if (params.length) {\n      node.raws.afterName = this.spacesAndCommentsFromStart(params);\n      this.raw(node, 'params', params);\n      if (last) {\n        token = params[params.length - 1];\n        node.source.end = { line: token[4], column: token[5] };\n        this.spaces = node.raws.between;\n        node.raws.between = '';\n      }\n    } else {\n      node.raws.afterName = '';\n      node.params = '';\n    }\n\n    if (open) {\n      node.nodes = [];\n      this.current = node;\n    }\n  };\n\n  Parser.prototype.end = function end(token) {\n    if (this.current.nodes && this.current.nodes.length) {\n      this.current.raws.semicolon = this.semicolon;\n    }\n    this.semicolon = false;\n\n    this.current.raws.after = (this.current.raws.after || '') + this.spaces;\n    this.spaces = '';\n\n    if (this.current.parent) {\n      this.current.source.end = { line: token[2], column: token[3] };\n      this.current = this.current.parent;\n    } else {\n      this.unexpectedClose(token);\n    }\n  };\n\n  Parser.prototype.endFile = function endFile() {\n    if (this.current.parent) this.unclosedBlock();\n    if (this.current.nodes && this.current.nodes.length) {\n      this.current.raws.semicolon = this.semicolon;\n    }\n    this.current.raws.after = (this.current.raws.after || '') + this.spaces;\n  };\n\n  Parser.prototype.freeSemicolon = function freeSemicolon(token) {\n    this.spaces += token[1];\n    if (this.current.nodes) {\n      var prev = this.current.nodes[this.current.nodes.length - 1];\n      if (prev && prev.type === 'rule' && !prev.raws.ownSemicolon) {\n        prev.raws.ownSemicolon = this.spaces;\n        this.spaces = '';\n      }\n    }\n  };\n\n  // Helpers\n\n  Parser.prototype.init = function init(node, line, column) {\n    this.current.push(node);\n\n    node.source = { start: { line: line, column: column }, input: this.input };\n    node.raws.before = this.spaces;\n    this.spaces = '';\n    if (node.type !== 'comment') this.semicolon = false;\n  };\n\n  Parser.prototype.raw = function raw(node, prop, tokens) {\n    var token = void 0,\n        type = void 0;\n    var length = tokens.length;\n    var value = '';\n    var clean = true;\n    var next = void 0,\n        prev = void 0;\n    var pattern = /^([.|#])?([\\w])+/i;\n\n    for (var i = 0; i < length; i += 1) {\n      token = tokens[i];\n      type = token[0];\n\n      if (type === 'comment' && node.type === 'rule') {\n        prev = tokens[i - 1];\n        next = tokens[i + 1];\n\n        if (prev[0] !== 'space' && next[0] !== 'space' && pattern.test(prev[1]) && pattern.test(next[1])) {\n          value += token[1];\n        } else {\n          clean = false;\n        }\n\n        continue;\n      }\n\n      if (type === 'comment' || type === 'space' && i === length - 1) {\n        clean = false;\n      } else {\n        value += token[1];\n      }\n    }\n    if (!clean) {\n      var raw = tokens.reduce(function (all, i) {\n        return all + i[1];\n      }, '');\n      node.raws[prop] = { value: value, raw: raw };\n    }\n    node[prop] = value;\n  };\n\n  Parser.prototype.spacesAndCommentsFromEnd = function spacesAndCommentsFromEnd(tokens) {\n    var lastTokenType = void 0;\n    var spaces = '';\n    while (tokens.length) {\n      lastTokenType = tokens[tokens.length - 1][0];\n      if (lastTokenType !== 'space' && lastTokenType !== 'comment') break;\n      spaces = tokens.pop()[1] + spaces;\n    }\n    return spaces;\n  };\n\n  Parser.prototype.spacesAndCommentsFromStart = function spacesAndCommentsFromStart(tokens) {\n    var next = void 0;\n    var spaces = '';\n    while (tokens.length) {\n      next = tokens[0][0];\n      if (next !== 'space' && next !== 'comment') break;\n      spaces += tokens.shift()[1];\n    }\n    return spaces;\n  };\n\n  Parser.prototype.spacesFromEnd = function spacesFromEnd(tokens) {\n    var lastTokenType = void 0;\n    var spaces = '';\n    while (tokens.length) {\n      lastTokenType = tokens[tokens.length - 1][0];\n      if (lastTokenType !== 'space') break;\n      spaces = tokens.pop()[1] + spaces;\n    }\n    return spaces;\n  };\n\n  Parser.prototype.stringFrom = function stringFrom(tokens, from) {\n    var result = '';\n    for (var i = from; i < tokens.length; i++) {\n      result += tokens[i][1];\n    }\n    tokens.splice(from, tokens.length - from);\n    return result;\n  };\n\n  Parser.prototype.colon = function colon(tokens) {\n    var brackets = 0;\n    var token = void 0,\n        type = void 0,\n        prev = void 0;\n    for (var i = 0; i < tokens.length; i++) {\n      token = tokens[i];\n      type = token[0];\n\n      if (type === '(') {\n        brackets += 1;\n      } else if (type === ')') {\n        brackets -= 1;\n      } else if (brackets === 0 && type === ':') {\n        if (!prev) {\n          this.doubleColon(token);\n        } else if (prev[0] === 'word' && prev[1] === 'progid') {\n          continue;\n        } else {\n          return i;\n        }\n      }\n\n      prev = token;\n    }\n    return false;\n  };\n\n  // Errors\n\n  Parser.prototype.unclosedBracket = function unclosedBracket(bracket) {\n    throw this.input.error('Unclosed bracket', bracket[2], bracket[3]);\n  };\n\n  Parser.prototype.unknownWord = function unknownWord(tokens) {\n    throw this.input.error('Unknown word', tokens[0][2], tokens[0][3]);\n  };\n\n  Parser.prototype.unexpectedClose = function unexpectedClose(token) {\n    throw this.input.error('Unexpected }', token[2], token[3]);\n  };\n\n  Parser.prototype.unclosedBlock = function unclosedBlock() {\n    var pos = this.current.source.start;\n    throw this.input.error('Unclosed block', pos.line, pos.column);\n  };\n\n  Parser.prototype.doubleColon = function doubleColon(token) {\n    throw this.input.error('Double colon', token[2], token[3]);\n  };\n\n  Parser.prototype.unnamedAtrule = function unnamedAtrule(node, token) {\n    throw this.input.error('At-rule without name', token[2], token[3]);\n  };\n\n  Parser.prototype.precheckMissedSemicolon = function precheckMissedSemicolon() /* tokens */{\n    // Hook for Safe Parser\n  };\n\n  Parser.prototype.checkMissedSemicolon = function checkMissedSemicolon(tokens) {\n    var colon = this.colon(tokens);\n    if (colon === false) return;\n\n    var founded = 0;\n    var token = void 0;\n    for (var j = colon - 1; j >= 0; j--) {\n      token = tokens[j];\n      if (token[0] !== 'space') {\n        founded += 1;\n        if (founded === 2) break;\n      }\n    }\n    throw this.input.error('Missed semicolon', token[2], token[3]);\n  };\n\n  return Parser;\n}();\n\nexports.default = Parser;\nmodule.exports = exports['default'];\n//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["parser.es6"],"names":["Parser","input","root","Root","current","spaces","semicolon","createTokenizer","source","start","line","column","tokenizer","parse","token","endOfFile","nextToken","freeSemicolon","end","comment","atrule","emptyRule","other","endFile","node","Comment","init","text","slice","test","raws","left","right","match","Rule","selector","between","type","colon","bracket","brackets","tokens","push","length","decl","rule","back","pop","unclosedBracket","unknownWord","spacesAndCommentsFromEnd","raw","Declaration","last","before","shift","prop","spacesAndCommentsFromStart","precheckMissedSemicolon","i","toLowerCase","important","string","stringFrom","spacesFromEnd","cache","str","j","trim","indexOf","value","checkMissedSemicolon","AtRule","name","unnamedAtrule","prev","open","params","afterName","nodes","after","parent","unexpectedClose","unclosedBlock","ownSemicolon","clean","next","pattern","reduce","all","lastTokenType","from","result","splice","doubleColon","error","pos","founded"],"mappings":"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","file":"parser.js","sourcesContent":["import Declaration from './declaration'\nimport tokenizer from './tokenize'\nimport Comment from './comment'\nimport AtRule from './at-rule'\nimport Root from './root'\nimport Rule from './rule'\n\nexport default class Parser {\n  constructor (input) {\n    this.input = input\n\n    this.root = new Root()\n    this.current = this.root\n    this.spaces = ''\n    this.semicolon = false\n\n    this.createTokenizer()\n    this.root.source = { input, start: { line: 1, column: 1 } }\n  }\n\n  createTokenizer () {\n    this.tokenizer = tokenizer(this.input)\n  }\n\n  parse () {\n    let token\n    while (!this.tokenizer.endOfFile()) {\n      token = this.tokenizer.nextToken()\n\n      switch (token[0]) {\n        case 'space':\n          this.spaces += token[1]\n          break\n\n        case ';':\n          this.freeSemicolon(token)\n          break\n\n        case '}':\n          this.end(token)\n          break\n\n        case 'comment':\n          this.comment(token)\n          break\n\n        case 'at-word':\n          this.atrule(token)\n          break\n\n        case '{':\n          this.emptyRule(token)\n          break\n\n        default:\n          this.other(token)\n          break\n      }\n    }\n    this.endFile()\n  }\n\n  comment (token) {\n    let node = new Comment()\n    this.init(node, token[2], token[3])\n    node.source.end = { line: token[4], column: token[5] }\n\n    let text = token[1].slice(2, -2)\n    if (/^\\s*$/.test(text)) {\n      node.text = ''\n      node.raws.left = text\n      node.raws.right = ''\n    } else {\n      let match = text.match(/^(\\s*)([^]*[^\\s])(\\s*)$/)\n      node.text = match[2]\n      node.raws.left = match[1]\n      node.raws.right = match[3]\n    }\n  }\n\n  emptyRule (token) {\n    let node = new Rule()\n    this.init(node, token[2], token[3])\n    node.selector = ''\n    node.raws.between = ''\n    this.current = node\n  }\n\n  other (start) {\n    let end = false\n    let type = null\n    let colon = false\n    let bracket = null\n    let brackets = []\n\n    let tokens = []\n    let token = start\n    while (token) {\n      type = token[0]\n      tokens.push(token)\n\n      if (type === '(' || type === '[') {\n        if (!bracket) bracket = token\n        brackets.push(type === '(' ? ')' : ']')\n      } else if (brackets.length === 0) {\n        if (type === ';') {\n          if (colon) {\n            this.decl(tokens)\n            return\n          } else {\n            break\n          }\n        } else if (type === '{') {\n          this.rule(tokens)\n          return\n        } else if (type === '}') {\n          this.tokenizer.back(tokens.pop())\n          end = true\n          break\n        } else if (type === ':') {\n          colon = true\n        }\n      } else if (type === brackets[brackets.length - 1]) {\n        brackets.pop()\n        if (brackets.length === 0) bracket = null\n      }\n\n      token = this.tokenizer.nextToken()\n    }\n\n    if (this.tokenizer.endOfFile()) end = true\n    if (brackets.length > 0) this.unclosedBracket(bracket)\n\n    if (end && colon) {\n      while (tokens.length) {\n        token = tokens[tokens.length - 1][0]\n        if (token !== 'space' && token !== 'comment') break\n        this.tokenizer.back(tokens.pop())\n      }\n      this.decl(tokens)\n    } else {\n      this.unknownWord(tokens)\n    }\n  }\n\n  rule (tokens) {\n    tokens.pop()\n\n    let node = new Rule()\n    this.init(node, tokens[0][2], tokens[0][3])\n\n    node.raws.between = this.spacesAndCommentsFromEnd(tokens)\n    this.raw(node, 'selector', tokens)\n    this.current = node\n  }\n\n  decl (tokens) {\n    let node = new Declaration()\n    this.init(node)\n\n    let last = tokens[tokens.length - 1]\n    if (last[0] === ';') {\n      this.semicolon = true\n      tokens.pop()\n    }\n    if (last[4]) {\n      node.source.end = { line: last[4], column: last[5] }\n    } else {\n      node.source.end = { line: last[2], column: last[3] }\n    }\n\n    while (tokens[0][0] !== 'word') {\n      if (tokens.length === 1) this.unknownWord(tokens)\n      node.raws.before += tokens.shift()[1]\n    }\n    node.source.start = { line: tokens[0][2], column: tokens[0][3] }\n\n    node.prop = ''\n    while (tokens.length) {\n      let type = tokens[0][0]\n      if (type === ':' || type === 'space' || type === 'comment') {\n        break\n      }\n      node.prop += tokens.shift()[1]\n    }\n\n    node.raws.between = ''\n\n    let token\n    while (tokens.length) {\n      token = tokens.shift()\n\n      if (token[0] === ':') {\n        node.raws.between += token[1]\n        break\n      } else {\n        node.raws.between += token[1]\n      }\n    }\n\n    if (node.prop[0] === '_' || node.prop[0] === '*') {\n      node.raws.before += node.prop[0]\n      node.prop = node.prop.slice(1)\n    }\n    node.raws.between += this.spacesAndCommentsFromStart(tokens)\n    this.precheckMissedSemicolon(tokens)\n\n    for (let i = tokens.length - 1; i > 0; i--) {\n      token = tokens[i]\n      if (token[1].toLowerCase() === '!important') {\n        node.important = true\n        let string = this.stringFrom(tokens, i)\n        string = this.spacesFromEnd(tokens) + string\n        if (string !== ' !important') node.raws.important = string\n        break\n      } else if (token[1].toLowerCase() === 'important') {\n        let cache = tokens.slice(0)\n        let str = ''\n        for (let j = i; j > 0; j--) {\n          let type = cache[j][0]\n          if (str.trim().indexOf('!') === 0 && type !== 'space') {\n            break\n          }\n          str = cache.pop()[1] + str\n        }\n        if (str.trim().indexOf('!') === 0) {\n          node.important = true\n          node.raws.important = str\n          tokens = cache\n        }\n      }\n\n      if (token[0] !== 'space' && token[0] !== 'comment') {\n        break\n      }\n    }\n\n    this.raw(node, 'value', tokens)\n\n    if (node.value.indexOf(':') !== -1) this.checkMissedSemicolon(tokens)\n  }\n\n  atrule (token) {\n    let node = new AtRule()\n    node.name = token[1].slice(1)\n    if (node.name === '') {\n      this.unnamedAtrule(node, token)\n    }\n    this.init(node, token[2], token[3])\n\n    let prev\n    let shift\n    let last = false\n    let open = false\n    let params = []\n\n    while (!this.tokenizer.endOfFile()) {\n      token = this.tokenizer.nextToken()\n\n      if (token[0] === ';') {\n        node.source.end = { line: token[2], column: token[3] }\n        this.semicolon = true\n        break\n      } else if (token[0] === '{') {\n        open = true\n        break\n      } else if (token[0] === '}') {\n        if (params.length > 0) {\n          shift = params.length - 1\n          prev = params[shift]\n          while (prev && prev[0] === 'space') {\n            prev = params[--shift]\n          }\n          if (prev) {\n            node.source.end = { line: prev[4], column: prev[5] }\n          }\n        }\n        this.end(token)\n        break\n      } else {\n        params.push(token)\n      }\n\n      if (this.tokenizer.endOfFile()) {\n        last = true\n        break\n      }\n    }\n\n    node.raws.between = this.spacesAndCommentsFromEnd(params)\n    if (params.length) {\n      node.raws.afterName = this.spacesAndCommentsFromStart(params)\n      this.raw(node, 'params', params)\n      if (last) {\n        token = params[params.length - 1]\n        node.source.end = { line: token[4], column: token[5] }\n        this.spaces = node.raws.between\n        node.raws.between = ''\n      }\n    } else {\n      node.raws.afterName = ''\n      node.params = ''\n    }\n\n    if (open) {\n      node.nodes = []\n      this.current = node\n    }\n  }\n\n  end (token) {\n    if (this.current.nodes && this.current.nodes.length) {\n      this.current.raws.semicolon = this.semicolon\n    }\n    this.semicolon = false\n\n    this.current.raws.after = (this.current.raws.after || '') + this.spaces\n    this.spaces = ''\n\n    if (this.current.parent) {\n      this.current.source.end = { line: token[2], column: token[3] }\n      this.current = this.current.parent\n    } else {\n      this.unexpectedClose(token)\n    }\n  }\n\n  endFile () {\n    if (this.current.parent) this.unclosedBlock()\n    if (this.current.nodes && this.current.nodes.length) {\n      this.current.raws.semicolon = this.semicolon\n    }\n    this.current.raws.after = (this.current.raws.after || '') + this.spaces\n  }\n\n  freeSemicolon (token) {\n    this.spaces += token[1]\n    if (this.current.nodes) {\n      let prev = this.current.nodes[this.current.nodes.length - 1]\n      if (prev && prev.type === 'rule' && !prev.raws.ownSemicolon) {\n        prev.raws.ownSemicolon = this.spaces\n        this.spaces = ''\n      }\n    }\n  }\n\n  // Helpers\n\n  init (node, line, column) {\n    this.current.push(node)\n\n    node.source = { start: { line, column }, input: this.input }\n    node.raws.before = this.spaces\n    this.spaces = ''\n    if (node.type !== 'comment') this.semicolon = false\n  }\n\n  raw (node, prop, tokens) {\n    let token, type\n    let length = tokens.length\n    let value = ''\n    let clean = true\n    let next, prev\n    let pattern = /^([.|#])?([\\w])+/i\n\n    for (let i = 0; i < length; i += 1) {\n      token = tokens[i]\n      type = token[0]\n\n      if (type === 'comment' && node.type === 'rule') {\n        prev = tokens[i - 1]\n        next = tokens[i + 1]\n\n        if (\n          prev[0] !== 'space' &&\n          next[0] !== 'space' &&\n          pattern.test(prev[1]) &&\n          pattern.test(next[1])\n        ) {\n          value += token[1]\n        } else {\n          clean = false\n        }\n\n        continue\n      }\n\n      if (type === 'comment' || (type === 'space' && i === length - 1)) {\n        clean = false\n      } else {\n        value += token[1]\n      }\n    }\n    if (!clean) {\n      let raw = tokens.reduce((all, i) => all + i[1], '')\n      node.raws[prop] = { value, raw }\n    }\n    node[prop] = value\n  }\n\n  spacesAndCommentsFromEnd (tokens) {\n    let lastTokenType\n    let spaces = ''\n    while (tokens.length) {\n      lastTokenType = tokens[tokens.length - 1][0]\n      if (lastTokenType !== 'space' && lastTokenType !== 'comment') break\n      spaces = tokens.pop()[1] + spaces\n    }\n    return spaces\n  }\n\n  spacesAndCommentsFromStart (tokens) {\n    let next\n    let spaces = ''\n    while (tokens.length) {\n      next = tokens[0][0]\n      if (next !== 'space' && next !== 'comment') break\n      spaces += tokens.shift()[1]\n    }\n    return spaces\n  }\n\n  spacesFromEnd (tokens) {\n    let lastTokenType\n    let spaces = ''\n    while (tokens.length) {\n      lastTokenType = tokens[tokens.length - 1][0]\n      if (lastTokenType !== 'space') break\n      spaces = tokens.pop()[1] + spaces\n    }\n    return spaces\n  }\n\n  stringFrom (tokens, from) {\n    let result = ''\n    for (let i = from; i < tokens.length; i++) {\n      result += tokens[i][1]\n    }\n    tokens.splice(from, tokens.length - from)\n    return result\n  }\n\n  colon (tokens) {\n    let brackets = 0\n    let token, type, prev\n    for (let i = 0; i < tokens.length; i++) {\n      token = tokens[i]\n      type = token[0]\n\n      if (type === '(') {\n        brackets += 1\n      } else if (type === ')') {\n        brackets -= 1\n      } else if (brackets === 0 && type === ':') {\n        if (!prev) {\n          this.doubleColon(token)\n        } else if (prev[0] === 'word' && prev[1] === 'progid') {\n          continue\n        } else {\n          return i\n        }\n      }\n\n      prev = token\n    }\n    return false\n  }\n\n  // Errors\n\n  unclosedBracket (bracket) {\n    throw this.input.error('Unclosed bracket', bracket[2], bracket[3])\n  }\n\n  unknownWord (tokens) {\n    throw this.input.error('Unknown word', tokens[0][2], tokens[0][3])\n  }\n\n  unexpectedClose (token) {\n    throw this.input.error('Unexpected }', token[2], token[3])\n  }\n\n  unclosedBlock () {\n    let pos = this.current.source.start\n    throw this.input.error('Unclosed block', pos.line, pos.column)\n  }\n\n  doubleColon (token) {\n    throw this.input.error('Double colon', token[2], token[3])\n  }\n\n  unnamedAtrule (node, token) {\n    throw this.input.error('At-rule without name', token[2], token[3])\n  }\n\n  precheckMissedSemicolon (/* tokens */) {\n    // Hook for Safe Parser\n  }\n\n  checkMissedSemicolon (tokens) {\n    let colon = this.colon(tokens)\n    if (colon === false) return\n\n    let founded = 0\n    let token\n    for (let j = colon - 1; j >= 0; j--) {\n      token = tokens[j]\n      if (token[0] !== 'space') {\n        founded += 1\n        if (founded === 2) break\n      }\n    }\n    throw this.input.error('Missed semicolon', token[2], token[3])\n  }\n}\n"]}\n","'use strict';\n\nexports.__esModule = true;\nexports.default = tokenizer;\nvar SINGLE_QUOTE = 39;\nvar DOUBLE_QUOTE = 34;\nvar BACKSLASH = 92;\nvar SLASH = 47;\nvar NEWLINE = 10;\nvar SPACE = 32;\nvar FEED = 12;\nvar TAB = 9;\nvar CR = 13;\nvar OPEN_SQUARE = 91;\nvar CLOSE_SQUARE = 93;\nvar OPEN_PARENTHESES = 40;\nvar CLOSE_PARENTHESES = 41;\nvar OPEN_CURLY = 123;\nvar CLOSE_CURLY = 125;\nvar SEMICOLON = 59;\nvar ASTERISK = 42;\nvar COLON = 58;\nvar AT = 64;\n\nvar RE_AT_END = /[ \\n\\t\\r\\f{}()'\"\\\\;/[\\]#]/g;\nvar RE_WORD_END = /[ \\n\\t\\r\\f(){}:;@!'\"\\\\\\][#]|\\/(?=\\*)/g;\nvar RE_BAD_BRACKET = /.[\\\\/(\"'\\n]/;\nvar RE_HEX_ESCAPE = /[a-f0-9]/i;\n\nfunction tokenizer(input) {\n  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n  var css = input.css.valueOf();\n  var ignore = options.ignoreErrors;\n\n  var code = void 0,\n      next = void 0,\n      quote = void 0,\n      lines = void 0,\n      last = void 0,\n      content = void 0,\n      escape = void 0;\n  var nextLine = void 0,\n      nextOffset = void 0,\n      escaped = void 0,\n      escapePos = void 0,\n      prev = void 0,\n      n = void 0,\n      currentToken = void 0;\n\n  var length = css.length;\n  var offset = -1;\n  var line = 1;\n  var pos = 0;\n  var buffer = [];\n  var returned = [];\n\n  function unclosed(what) {\n    throw input.error('Unclosed ' + what, line, pos - offset);\n  }\n\n  function endOfFile() {\n    return returned.length === 0 && pos >= length;\n  }\n\n  function nextToken() {\n    if (returned.length) return returned.pop();\n    if (pos >= length) return;\n\n    code = css.charCodeAt(pos);\n    if (code === NEWLINE || code === FEED || code === CR && css.charCodeAt(pos + 1) !== NEWLINE) {\n      offset = pos;\n      line += 1;\n    }\n\n    switch (code) {\n      case NEWLINE:\n      case SPACE:\n      case TAB:\n      case CR:\n      case FEED:\n        next = pos;\n        do {\n          next += 1;\n          code = css.charCodeAt(next);\n          if (code === NEWLINE) {\n            offset = next;\n            line += 1;\n          }\n        } while (code === SPACE || code === NEWLINE || code === TAB || code === CR || code === FEED);\n\n        currentToken = ['space', css.slice(pos, next)];\n        pos = next - 1;\n        break;\n\n      case OPEN_SQUARE:\n        currentToken = ['[', '[', line, pos - offset];\n        break;\n\n      case CLOSE_SQUARE:\n        currentToken = [']', ']', line, pos - offset];\n        break;\n\n      case OPEN_CURLY:\n        currentToken = ['{', '{', line, pos - offset];\n        break;\n\n      case CLOSE_CURLY:\n        currentToken = ['}', '}', line, pos - offset];\n        break;\n\n      case COLON:\n        currentToken = [':', ':', line, pos - offset];\n        break;\n\n      case SEMICOLON:\n        currentToken = [';', ';', line, pos - offset];\n        break;\n\n      case OPEN_PARENTHESES:\n        prev = buffer.length ? buffer.pop()[1] : '';\n        n = css.charCodeAt(pos + 1);\n        if (prev === 'url' && n !== SINGLE_QUOTE && n !== DOUBLE_QUOTE && n !== SPACE && n !== NEWLINE && n !== TAB && n !== FEED && n !== CR) {\n          next = pos;\n          do {\n            escaped = false;\n            next = css.indexOf(')', next + 1);\n            if (next === -1) {\n              if (ignore) {\n                next = pos;\n                break;\n              } else {\n                unclosed('bracket');\n              }\n            }\n            escapePos = next;\n            while (css.charCodeAt(escapePos - 1) === BACKSLASH) {\n              escapePos -= 1;\n              escaped = !escaped;\n            }\n          } while (escaped);\n\n          currentToken = ['brackets', css.slice(pos, next + 1), line, pos - offset, line, next - offset];\n\n          pos = next;\n        } else {\n          next = css.indexOf(')', pos + 1);\n          content = css.slice(pos, next + 1);\n\n          if (next === -1 || RE_BAD_BRACKET.test(content)) {\n            currentToken = ['(', '(', line, pos - offset];\n          } else {\n            currentToken = ['brackets', content, line, pos - offset, line, next - offset];\n            pos = next;\n          }\n        }\n\n        break;\n\n      case CLOSE_PARENTHESES:\n        currentToken = [')', ')', line, pos - offset];\n        break;\n\n      case SINGLE_QUOTE:\n      case DOUBLE_QUOTE:\n        quote = code === SINGLE_QUOTE ? '\\'' : '\"';\n        next = pos;\n        do {\n          escaped = false;\n          next = css.indexOf(quote, next + 1);\n          if (next === -1) {\n            if (ignore) {\n              next = pos + 1;\n              break;\n            } else {\n              unclosed('string');\n            }\n          }\n          escapePos = next;\n          while (css.charCodeAt(escapePos - 1) === BACKSLASH) {\n            escapePos -= 1;\n            escaped = !escaped;\n          }\n        } while (escaped);\n\n        content = css.slice(pos, next + 1);\n        lines = content.split('\\n');\n        last = lines.length - 1;\n\n        if (last > 0) {\n          nextLine = line + last;\n          nextOffset = next - lines[last].length;\n        } else {\n          nextLine = line;\n          nextOffset = offset;\n        }\n\n        currentToken = ['string', css.slice(pos, next + 1), line, pos - offset, nextLine, next - nextOffset];\n\n        offset = nextOffset;\n        line = nextLine;\n        pos = next;\n        break;\n\n      case AT:\n        RE_AT_END.lastIndex = pos + 1;\n        RE_AT_END.test(css);\n        if (RE_AT_END.lastIndex === 0) {\n          next = css.length - 1;\n        } else {\n          next = RE_AT_END.lastIndex - 2;\n        }\n\n        currentToken = ['at-word', css.slice(pos, next + 1), line, pos - offset, line, next - offset];\n\n        pos = next;\n        break;\n\n      case BACKSLASH:\n        next = pos;\n        escape = true;\n        while (css.charCodeAt(next + 1) === BACKSLASH) {\n          next += 1;\n          escape = !escape;\n        }\n        code = css.charCodeAt(next + 1);\n        if (escape && code !== SLASH && code !== SPACE && code !== NEWLINE && code !== TAB && code !== CR && code !== FEED) {\n          next += 1;\n          if (RE_HEX_ESCAPE.test(css.charAt(next))) {\n            while (RE_HEX_ESCAPE.test(css.charAt(next + 1))) {\n              next += 1;\n            }\n            if (css.charCodeAt(next + 1) === SPACE) {\n              next += 1;\n            }\n          }\n        }\n\n        currentToken = ['word', css.slice(pos, next + 1), line, pos - offset, line, next - offset];\n\n        pos = next;\n        break;\n\n      default:\n        if (code === SLASH && css.charCodeAt(pos + 1) === ASTERISK) {\n          next = css.indexOf('*/', pos + 2) + 1;\n          if (next === 0) {\n            if (ignore) {\n              next = css.length;\n            } else {\n              unclosed('comment');\n            }\n          }\n\n          content = css.slice(pos, next + 1);\n          lines = content.split('\\n');\n          last = lines.length - 1;\n\n          if (last > 0) {\n            nextLine = line + last;\n            nextOffset = next - lines[last].length;\n          } else {\n            nextLine = line;\n            nextOffset = offset;\n          }\n\n          currentToken = ['comment', content, line, pos - offset, nextLine, next - nextOffset];\n\n          offset = nextOffset;\n          line = nextLine;\n          pos = next;\n        } else {\n          RE_WORD_END.lastIndex = pos + 1;\n          RE_WORD_END.test(css);\n          if (RE_WORD_END.lastIndex === 0) {\n            next = css.length - 1;\n          } else {\n            next = RE_WORD_END.lastIndex - 2;\n          }\n\n          currentToken = ['word', css.slice(pos, next + 1), line, pos - offset, line, next - offset];\n\n          buffer.push(currentToken);\n\n          pos = next;\n        }\n\n        break;\n    }\n\n    pos++;\n    return currentToken;\n  }\n\n  function back(token) {\n    returned.push(token);\n  }\n\n  return {\n    back: back,\n    nextToken: nextToken,\n    endOfFile: endOfFile\n  };\n}\nmodule.exports = exports['default'];\n//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["tokenize.es6"],"names":["tokenizer","SINGLE_QUOTE","DOUBLE_QUOTE","BACKSLASH","SLASH","NEWLINE","SPACE","FEED","TAB","CR","OPEN_SQUARE","CLOSE_SQUARE","OPEN_PARENTHESES","CLOSE_PARENTHESES","OPEN_CURLY","CLOSE_CURLY","SEMICOLON","ASTERISK","COLON","AT","RE_AT_END","RE_WORD_END","RE_BAD_BRACKET","RE_HEX_ESCAPE","input","options","css","valueOf","ignore","ignoreErrors","code","next","quote","lines","last","content","escape","nextLine","nextOffset","escaped","escapePos","prev","n","currentToken","length","offset","line","pos","buffer","returned","unclosed","what","error","endOfFile","nextToken","pop","charCodeAt","slice","indexOf","test","split","lastIndex","charAt","push","back","token"],"mappings":"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","file":"tokenize.js","sourcesContent":["const SINGLE_QUOTE = '\\''.charCodeAt(0)\nconst DOUBLE_QUOTE = '\"'.charCodeAt(0)\nconst BACKSLASH = '\\\\'.charCodeAt(0)\nconst SLASH = '/'.charCodeAt(0)\nconst NEWLINE = '\\n'.charCodeAt(0)\nconst SPACE = ' '.charCodeAt(0)\nconst FEED = '\\f'.charCodeAt(0)\nconst TAB = '\\t'.charCodeAt(0)\nconst CR = '\\r'.charCodeAt(0)\nconst OPEN_SQUARE = '['.charCodeAt(0)\nconst CLOSE_SQUARE = ']'.charCodeAt(0)\nconst OPEN_PARENTHESES = '('.charCodeAt(0)\nconst CLOSE_PARENTHESES = ')'.charCodeAt(0)\nconst OPEN_CURLY = '{'.charCodeAt(0)\nconst CLOSE_CURLY = '}'.charCodeAt(0)\nconst SEMICOLON = ';'.charCodeAt(0)\nconst ASTERISK = '*'.charCodeAt(0)\nconst COLON = ':'.charCodeAt(0)\nconst AT = '@'.charCodeAt(0)\n\nconst RE_AT_END = /[ \\n\\t\\r\\f{}()'\"\\\\;/[\\]#]/g\nconst RE_WORD_END = /[ \\n\\t\\r\\f(){}:;@!'\"\\\\\\][#]|\\/(?=\\*)/g\nconst RE_BAD_BRACKET = /.[\\\\/(\"'\\n]/\nconst RE_HEX_ESCAPE = /[a-f0-9]/i\n\nexport default function tokenizer (input, options = {}) {\n  let css = input.css.valueOf()\n  let ignore = options.ignoreErrors\n\n  let code, next, quote, lines, last, content, escape\n  let nextLine, nextOffset, escaped, escapePos, prev, n, currentToken\n\n  let length = css.length\n  let offset = -1\n  let line = 1\n  let pos = 0\n  let buffer = []\n  let returned = []\n\n  function unclosed (what) {\n    throw input.error('Unclosed ' + what, line, pos - offset)\n  }\n\n  function endOfFile () {\n    return returned.length === 0 && pos >= length\n  }\n\n  function nextToken () {\n    if (returned.length) return returned.pop()\n    if (pos >= length) return\n\n    code = css.charCodeAt(pos)\n    if (\n      code === NEWLINE || code === FEED ||\n      (code === CR && css.charCodeAt(pos + 1) !== NEWLINE)\n    ) {\n      offset = pos\n      line += 1\n    }\n\n    switch (code) {\n      case NEWLINE:\n      case SPACE:\n      case TAB:\n      case CR:\n      case FEED:\n        next = pos\n        do {\n          next += 1\n          code = css.charCodeAt(next)\n          if (code === NEWLINE) {\n            offset = next\n            line += 1\n          }\n        } while (\n          code === SPACE ||\n          code === NEWLINE ||\n          code === TAB ||\n          code === CR ||\n          code === FEED\n        )\n\n        currentToken = ['space', css.slice(pos, next)]\n        pos = next - 1\n        break\n\n      case OPEN_SQUARE:\n        currentToken = ['[', '[', line, pos - offset]\n        break\n\n      case CLOSE_SQUARE:\n        currentToken = [']', ']', line, pos - offset]\n        break\n\n      case OPEN_CURLY:\n        currentToken = ['{', '{', line, pos - offset]\n        break\n\n      case CLOSE_CURLY:\n        currentToken = ['}', '}', line, pos - offset]\n        break\n\n      case COLON:\n        currentToken = [':', ':', line, pos - offset]\n        break\n\n      case SEMICOLON:\n        currentToken = [';', ';', line, pos - offset]\n        break\n\n      case OPEN_PARENTHESES:\n        prev = buffer.length ? buffer.pop()[1] : ''\n        n = css.charCodeAt(pos + 1)\n        if (\n          prev === 'url' &&\n          n !== SINGLE_QUOTE && n !== DOUBLE_QUOTE &&\n          n !== SPACE && n !== NEWLINE && n !== TAB &&\n          n !== FEED && n !== CR\n        ) {\n          next = pos\n          do {\n            escaped = false\n            next = css.indexOf(')', next + 1)\n            if (next === -1) {\n              if (ignore) {\n                next = pos\n                break\n              } else {\n                unclosed('bracket')\n              }\n            }\n            escapePos = next\n            while (css.charCodeAt(escapePos - 1) === BACKSLASH) {\n              escapePos -= 1\n              escaped = !escaped\n            }\n          } while (escaped)\n\n          currentToken = ['brackets', css.slice(pos, next + 1),\n            line, pos - offset,\n            line, next - offset\n          ]\n\n          pos = next\n        } else {\n          next = css.indexOf(')', pos + 1)\n          content = css.slice(pos, next + 1)\n\n          if (next === -1 || RE_BAD_BRACKET.test(content)) {\n            currentToken = ['(', '(', line, pos - offset]\n          } else {\n            currentToken = ['brackets', content,\n              line, pos - offset,\n              line, next - offset\n            ]\n            pos = next\n          }\n        }\n\n        break\n\n      case CLOSE_PARENTHESES:\n        currentToken = [')', ')', line, pos - offset]\n        break\n\n      case SINGLE_QUOTE:\n      case DOUBLE_QUOTE:\n        quote = code === SINGLE_QUOTE ? '\\'' : '\"'\n        next = pos\n        do {\n          escaped = false\n          next = css.indexOf(quote, next + 1)\n          if (next === -1) {\n            if (ignore) {\n              next = pos + 1\n              break\n            } else {\n              unclosed('string')\n            }\n          }\n          escapePos = next\n          while (css.charCodeAt(escapePos - 1) === BACKSLASH) {\n            escapePos -= 1\n            escaped = !escaped\n          }\n        } while (escaped)\n\n        content = css.slice(pos, next + 1)\n        lines = content.split('\\n')\n        last = lines.length - 1\n\n        if (last > 0) {\n          nextLine = line + last\n          nextOffset = next - lines[last].length\n        } else {\n          nextLine = line\n          nextOffset = offset\n        }\n\n        currentToken = ['string', css.slice(pos, next + 1),\n          line, pos - offset,\n          nextLine, next - nextOffset\n        ]\n\n        offset = nextOffset\n        line = nextLine\n        pos = next\n        break\n\n      case AT:\n        RE_AT_END.lastIndex = pos + 1\n        RE_AT_END.test(css)\n        if (RE_AT_END.lastIndex === 0) {\n          next = css.length - 1\n        } else {\n          next = RE_AT_END.lastIndex - 2\n        }\n\n        currentToken = ['at-word', css.slice(pos, next + 1),\n          line, pos - offset,\n          line, next - offset\n        ]\n\n        pos = next\n        break\n\n      case BACKSLASH:\n        next = pos\n        escape = true\n        while (css.charCodeAt(next + 1) === BACKSLASH) {\n          next += 1\n          escape = !escape\n        }\n        code = css.charCodeAt(next + 1)\n        if (\n          escape &&\n          code !== SLASH &&\n          code !== SPACE &&\n          code !== NEWLINE &&\n          code !== TAB &&\n          code !== CR &&\n          code !== FEED\n        ) {\n          next += 1\n          if (RE_HEX_ESCAPE.test(css.charAt(next))) {\n            while (RE_HEX_ESCAPE.test(css.charAt(next + 1))) {\n              next += 1\n            }\n            if (css.charCodeAt(next + 1) === SPACE) {\n              next += 1\n            }\n          }\n        }\n\n        currentToken = ['word', css.slice(pos, next + 1),\n          line, pos - offset,\n          line, next - offset\n        ]\n\n        pos = next\n        break\n\n      default:\n        if (code === SLASH && css.charCodeAt(pos + 1) === ASTERISK) {\n          next = css.indexOf('*/', pos + 2) + 1\n          if (next === 0) {\n            if (ignore) {\n              next = css.length\n            } else {\n              unclosed('comment')\n            }\n          }\n\n          content = css.slice(pos, next + 1)\n          lines = content.split('\\n')\n          last = lines.length - 1\n\n          if (last > 0) {\n            nextLine = line + last\n            nextOffset = next - lines[last].length\n          } else {\n            nextLine = line\n            nextOffset = offset\n          }\n\n          currentToken = ['comment', content,\n            line, pos - offset,\n            nextLine, next - nextOffset\n          ]\n\n          offset = nextOffset\n          line = nextLine\n          pos = next\n        } else {\n          RE_WORD_END.lastIndex = pos + 1\n          RE_WORD_END.test(css)\n          if (RE_WORD_END.lastIndex === 0) {\n            next = css.length - 1\n          } else {\n            next = RE_WORD_END.lastIndex - 2\n          }\n\n          currentToken = ['word', css.slice(pos, next + 1),\n            line, pos - offset,\n            line, next - offset\n          ]\n\n          buffer.push(currentToken)\n\n          pos = next\n        }\n\n        break\n    }\n\n    pos++\n    return currentToken\n  }\n\n  function back (token) {\n    returned.push(token)\n  }\n\n  return {\n    back,\n    nextToken,\n    endOfFile\n  }\n}\n"]}\n","'use strict';\n\nexports.__esModule = true;\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _cssSyntaxError = require('./css-syntax-error');\n\nvar _cssSyntaxError2 = _interopRequireDefault(_cssSyntaxError);\n\nvar _previousMap = require('./previous-map');\n\nvar _previousMap2 = _interopRequireDefault(_previousMap);\n\nvar _path = require('path');\n\nvar _path2 = _interopRequireDefault(_path);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar sequence = 0;\n\n/**\n * Represents the source CSS.\n *\n * @example\n * const root  = postcss.parse(css, { from: file })\n * const input = root.source.input\n */\n\nvar Input = function () {\n  /**\n   * @param {string} css    Input CSS source.\n   * @param {object} [opts] {@link Processor#process} options.\n   */\n  function Input(css) {\n    var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    _classCallCheck(this, Input);\n\n    if (css === null || (typeof css === 'undefined' ? 'undefined' : _typeof(css)) === 'object' && !css.toString) {\n      throw new Error('PostCSS received ' + css + ' instead of CSS string');\n    }\n\n    /**\n     * Input CSS source\n     *\n     * @type {string}\n     *\n     * @example\n     * const input = postcss.parse('a{}', { from: file }).input\n     * input.css //=> \"a{}\"\n     */\n    this.css = css.toString();\n\n    if (this.css[0] === '\\uFEFF' || this.css[0] === '\\uFFFE') {\n      this.css = this.css.slice(1);\n    }\n\n    if (opts.from) {\n      if (/^\\w+:\\/\\//.test(opts.from)) {\n        /**\n         * The absolute path to the CSS source file defined\n         * with the `from` option.\n         *\n         * @type {string}\n         *\n         * @example\n         * const root = postcss.parse(css, { from: 'a.css' })\n         * root.source.input.file //=> '/home/ai/a.css'\n         */\n        this.file = opts.from;\n      } else {\n        this.file = _path2.default.resolve(opts.from);\n      }\n    }\n\n    var map = new _previousMap2.default(this.css, opts);\n    if (map.text) {\n      /**\n       * The input source map passed from a compilation step before PostCSS\n       * (for example, from Sass compiler).\n       *\n       * @type {PreviousMap}\n       *\n       * @example\n       * root.source.input.map.consumer().sources //=> ['a.sass']\n       */\n      this.map = map;\n      var file = map.consumer().file;\n      if (!this.file && file) this.file = this.mapResolve(file);\n    }\n\n    if (!this.file) {\n      sequence += 1;\n      /**\n       * The unique ID of the CSS source. It will be created if `from` option\n       * is not provided (because PostCSS does not know the file path).\n       *\n       * @type {string}\n       *\n       * @example\n       * const root = postcss.parse(css)\n       * root.source.input.file //=> undefined\n       * root.source.input.id   //=> \"<input css 1>\"\n       */\n      this.id = '<input css ' + sequence + '>';\n    }\n    if (this.map) this.map.file = this.from;\n  }\n\n  Input.prototype.error = function error(message, line, column) {\n    var opts = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};\n\n    var result = void 0;\n    var origin = this.origin(line, column);\n    if (origin) {\n      result = new _cssSyntaxError2.default(message, origin.line, origin.column, origin.source, origin.file, opts.plugin);\n    } else {\n      result = new _cssSyntaxError2.default(message, line, column, this.css, this.file, opts.plugin);\n    }\n\n    result.input = { line: line, column: column, source: this.css };\n    if (this.file) result.input.file = this.file;\n\n    return result;\n  };\n\n  /**\n   * Reads the input source map and returns a symbol position\n   * in the input source (e.g., in a Sass file that was compiled\n   * to CSS before being passed to PostCSS).\n   *\n   * @param {number} line   Line in input CSS.\n   * @param {number} column Column in input CSS.\n   *\n   * @return {filePosition} Position in input source.\n   *\n   * @example\n   * root.source.input.origin(1, 1) //=> { file: 'a.css', line: 3, column: 1 }\n   */\n\n\n  Input.prototype.origin = function origin(line, column) {\n    if (!this.map) return false;\n    var consumer = this.map.consumer();\n\n    var from = consumer.originalPositionFor({ line: line, column: column });\n    if (!from.source) return false;\n\n    var result = {\n      file: this.mapResolve(from.source),\n      line: from.line,\n      column: from.column\n    };\n\n    var source = consumer.sourceContentFor(from.source);\n    if (source) result.source = source;\n\n    return result;\n  };\n\n  Input.prototype.mapResolve = function mapResolve(file) {\n    if (/^\\w+:\\/\\//.test(file)) {\n      return file;\n    } else {\n      return _path2.default.resolve(this.map.consumer().sourceRoot || '.', file);\n    }\n  };\n\n  /**\n   * The CSS source identifier. Contains {@link Input#file} if the user\n   * set the `from` option, or {@link Input#id} if they did not.\n   *\n   * @type {string}\n   *\n   * @example\n   * const root = postcss.parse(css, { from: 'a.css' })\n   * root.source.input.from //=> \"/home/ai/a.css\"\n   *\n   * const root = postcss.parse(css)\n   * root.source.input.from //=> \"<input css 1>\"\n   */\n\n\n  _createClass(Input, [{\n    key: 'from',\n    get: function get() {\n      return this.file || this.id;\n    }\n  }]);\n\n  return Input;\n}();\n\nexports.default = Input;\n\n/**\n * @typedef  {object} filePosition\n * @property {string} file   Path to file.\n * @property {number} line   Source line in file.\n * @property {number} column Source column in file.\n */\n\nmodule.exports = exports['default'];\n//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["input.es6"],"names":["sequence","Input","css","opts","toString","Error","slice","from","test","file","path","resolve","map","PreviousMap","text","consumer","mapResolve","id","error","message","line","column","result","origin","CssSyntaxError","source","plugin","input","originalPositionFor","sourceContentFor","sourceRoot"],"mappings":"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","file":"input.js","sourcesContent":["import CssSyntaxError from './css-syntax-error'\nimport PreviousMap from './previous-map'\n\nimport path from 'path'\n\nlet sequence = 0\n\n/**\n * Represents the source CSS.\n *\n * @example\n * const root  = postcss.parse(css, { from: file })\n * const input = root.source.input\n */\nclass Input {\n  /**\n   * @param {string} css    Input CSS source.\n   * @param {object} [opts] {@link Processor#process} options.\n   */\n  constructor (css, opts = { }) {\n    if (css === null || (typeof css === 'object' && !css.toString)) {\n      throw new Error(`PostCSS received ${ css } instead of CSS string`)\n    }\n\n    /**\n     * Input CSS source\n     *\n     * @type {string}\n     *\n     * @example\n     * const input = postcss.parse('a{}', { from: file }).input\n     * input.css //=> \"a{}\"\n     */\n    this.css = css.toString()\n\n    if (this.css[0] === '\\uFEFF' || this.css[0] === '\\uFFFE') {\n      this.css = this.css.slice(1)\n    }\n\n    if (opts.from) {\n      if (/^\\w+:\\/\\//.test(opts.from)) {\n        /**\n         * The absolute path to the CSS source file defined\n         * with the `from` option.\n         *\n         * @type {string}\n         *\n         * @example\n         * const root = postcss.parse(css, { from: 'a.css' })\n         * root.source.input.file //=> '/home/ai/a.css'\n         */\n        this.file = opts.from\n      } else {\n        this.file = path.resolve(opts.from)\n      }\n    }\n\n    let map = new PreviousMap(this.css, opts)\n    if (map.text) {\n      /**\n       * The input source map passed from a compilation step before PostCSS\n       * (for example, from Sass compiler).\n       *\n       * @type {PreviousMap}\n       *\n       * @example\n       * root.source.input.map.consumer().sources //=> ['a.sass']\n       */\n      this.map = map\n      let file = map.consumer().file\n      if (!this.file && file) this.file = this.mapResolve(file)\n    }\n\n    if (!this.file) {\n      sequence += 1\n      /**\n       * The unique ID of the CSS source. It will be created if `from` option\n       * is not provided (because PostCSS does not know the file path).\n       *\n       * @type {string}\n       *\n       * @example\n       * const root = postcss.parse(css)\n       * root.source.input.file //=> undefined\n       * root.source.input.id   //=> \"<input css 1>\"\n       */\n      this.id = '<input css ' + sequence + '>'\n    }\n    if (this.map) this.map.file = this.from\n  }\n\n  error (message, line, column, opts = { }) {\n    let result\n    let origin = this.origin(line, column)\n    if (origin) {\n      result = new CssSyntaxError(\n        message, origin.line, origin.column,\n        origin.source, origin.file, opts.plugin\n      )\n    } else {\n      result = new CssSyntaxError(\n        message, line, column, this.css, this.file, opts.plugin)\n    }\n\n    result.input = { line, column, source: this.css }\n    if (this.file) result.input.file = this.file\n\n    return result\n  }\n\n  /**\n   * Reads the input source map and returns a symbol position\n   * in the input source (e.g., in a Sass file that was compiled\n   * to CSS before being passed to PostCSS).\n   *\n   * @param {number} line   Line in input CSS.\n   * @param {number} column Column in input CSS.\n   *\n   * @return {filePosition} Position in input source.\n   *\n   * @example\n   * root.source.input.origin(1, 1) //=> { file: 'a.css', line: 3, column: 1 }\n   */\n  origin (line, column) {\n    if (!this.map) return false\n    let consumer = this.map.consumer()\n\n    let from = consumer.originalPositionFor({ line, column })\n    if (!from.source) return false\n\n    let result = {\n      file: this.mapResolve(from.source),\n      line: from.line,\n      column: from.column\n    }\n\n    let source = consumer.sourceContentFor(from.source)\n    if (source) result.source = source\n\n    return result\n  }\n\n  mapResolve (file) {\n    if (/^\\w+:\\/\\//.test(file)) {\n      return file\n    } else {\n      return path.resolve(this.map.consumer().sourceRoot || '.', file)\n    }\n  }\n\n  /**\n   * The CSS source identifier. Contains {@link Input#file} if the user\n   * set the `from` option, or {@link Input#id} if they did not.\n   *\n   * @type {string}\n   *\n   * @example\n   * const root = postcss.parse(css, { from: 'a.css' })\n   * root.source.input.from //=> \"/home/ai/a.css\"\n   *\n   * const root = postcss.parse(css)\n   * root.source.input.from //=> \"<input css 1>\"\n   */\n  get from () {\n    return this.file || this.id\n  }\n}\n\nexport default Input\n\n/**\n * @typedef  {object} filePosition\n * @property {string} file   Path to file.\n * @property {number} line   Source line in file.\n * @property {number} column Source column in file.\n */\n"]}\n","'use strict';\n\nexports.__esModule = true;\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nvar _sourceMap = require('source-map');\n\nvar _sourceMap2 = _interopRequireDefault(_sourceMap);\n\nvar _path = require('path');\n\nvar _path2 = _interopRequireDefault(_path);\n\nvar _fs = require('fs');\n\nvar _fs2 = _interopRequireDefault(_fs);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction fromBase64(str) {\n  if (Buffer) {\n    return Buffer.from(str, 'base64').toString();\n  } else {\n    return window.atob(str);\n  }\n}\n\n/**\n * Source map information from input CSS.\n * For example, source map after Sass compiler.\n *\n * This class will automatically find source map in input CSS or in file system\n * near input file (according `from` option).\n *\n * @example\n * const root = postcss.parse(css, { from: 'a.sass.css' })\n * root.input.map //=> PreviousMap\n */\n\nvar PreviousMap = function () {\n  /**\n   * @param {string}         css    Input CSS source.\n   * @param {processOptions} [opts] {@link Processor#process} options.\n   */\n  function PreviousMap(css, opts) {\n    _classCallCheck(this, PreviousMap);\n\n    this.loadAnnotation(css);\n    /**\n     * Was source map inlined by data-uri to input CSS.\n     *\n     * @type {boolean}\n     */\n    this.inline = this.startWith(this.annotation, 'data:');\n\n    var prev = opts.map ? opts.map.prev : undefined;\n    var text = this.loadMap(opts.from, prev);\n    if (text) this.text = text;\n  }\n\n  /**\n   * Create a instance of `SourceMapGenerator` class\n   * from the `source-map` library to work with source map information.\n   *\n   * It is lazy method, so it will create object only on first call\n   * and then it will use cache.\n   *\n   * @return {SourceMapGenerator} Object with source map information.\n   */\n\n\n  PreviousMap.prototype.consumer = function consumer() {\n    if (!this.consumerCache) {\n      this.consumerCache = new _sourceMap2.default.SourceMapConsumer(this.text);\n    }\n    return this.consumerCache;\n  };\n\n  /**\n   * Does source map contains `sourcesContent` with input source text.\n   *\n   * @return {boolean} Is `sourcesContent` present.\n   */\n\n\n  PreviousMap.prototype.withContent = function withContent() {\n    return !!(this.consumer().sourcesContent && this.consumer().sourcesContent.length > 0);\n  };\n\n  PreviousMap.prototype.startWith = function startWith(string, start) {\n    if (!string) return false;\n    return string.substr(0, start.length) === start;\n  };\n\n  PreviousMap.prototype.loadAnnotation = function loadAnnotation(css) {\n    var match = css.match(/\\/\\*\\s*# sourceMappingURL=(.*)\\s*\\*\\//);\n    if (match) this.annotation = match[1].trim();\n  };\n\n  PreviousMap.prototype.decodeInline = function decodeInline(text) {\n    var baseCharsetUri = /^data:application\\/json;charset=utf-?8;base64,/;\n    var baseUri = /^data:application\\/json;base64,/;\n    var uri = 'data:application/json,';\n\n    if (this.startWith(text, uri)) {\n      return decodeURIComponent(text.substr(uri.length));\n    } else if (baseCharsetUri.test(text) || baseUri.test(text)) {\n      return fromBase64(text.substr(RegExp.lastMatch.length));\n    } else {\n      var encoding = text.match(/data:application\\/json;([^,]+),/)[1];\n      throw new Error('Unsupported source map encoding ' + encoding);\n    }\n  };\n\n  PreviousMap.prototype.loadMap = function loadMap(file, prev) {\n    if (prev === false) return false;\n\n    if (prev) {\n      if (typeof prev === 'string') {\n        return prev;\n      } else if (typeof prev === 'function') {\n        var prevPath = prev(file);\n        if (prevPath && _fs2.default.existsSync && _fs2.default.existsSync(prevPath)) {\n          return _fs2.default.readFileSync(prevPath, 'utf-8').toString().trim();\n        } else {\n          throw new Error('Unable to load previous source map: ' + prevPath.toString());\n        }\n      } else if (prev instanceof _sourceMap2.default.SourceMapConsumer) {\n        return _sourceMap2.default.SourceMapGenerator.fromSourceMap(prev).toString();\n      } else if (prev instanceof _sourceMap2.default.SourceMapGenerator) {\n        return prev.toString();\n      } else if (this.isMap(prev)) {\n        return JSON.stringify(prev);\n      } else {\n        throw new Error('Unsupported previous source map format: ' + prev.toString());\n      }\n    } else if (this.inline) {\n      return this.decodeInline(this.annotation);\n    } else if (this.annotation) {\n      var map = this.annotation;\n      if (file) map = _path2.default.join(_path2.default.dirname(file), map);\n\n      this.root = _path2.default.dirname(map);\n      if (_fs2.default.existsSync && _fs2.default.existsSync(map)) {\n        return _fs2.default.readFileSync(map, 'utf-8').toString().trim();\n      } else {\n        return false;\n      }\n    }\n  };\n\n  PreviousMap.prototype.isMap = function isMap(map) {\n    if ((typeof map === 'undefined' ? 'undefined' : _typeof(map)) !== 'object') return false;\n    return typeof map.mappings === 'string' || typeof map._mappings === 'string';\n  };\n\n  return PreviousMap;\n}();\n\nexports.default = PreviousMap;\nmodule.exports = exports['default'];\n//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["previous-map.es6"],"names":["fromBase64","str","Buffer","from","toString","window","atob","PreviousMap","css","opts","loadAnnotation","inline","startWith","annotation","prev","map","undefined","text","loadMap","consumer","consumerCache","mozilla","SourceMapConsumer","withContent","sourcesContent","length","string","start","substr","match","trim","decodeInline","baseCharsetUri","baseUri","uri","decodeURIComponent","test","RegExp","lastMatch","encoding","Error","file","prevPath","fs","existsSync","readFileSync","SourceMapGenerator","fromSourceMap","isMap","JSON","stringify","path","join","dirname","root","mappings","_mappings"],"mappings":"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","file":"previous-map.js","sourcesContent":["import mozilla from 'source-map'\nimport path from 'path'\nimport fs from 'fs'\n\nfunction fromBase64 (str) {\n  if (Buffer) {\n    return Buffer.from(str, 'base64').toString()\n  } else {\n    return window.atob(str)\n  }\n}\n\n/**\n * Source map information from input CSS.\n * For example, source map after Sass compiler.\n *\n * This class will automatically find source map in input CSS or in file system\n * near input file (according `from` option).\n *\n * @example\n * const root = postcss.parse(css, { from: 'a.sass.css' })\n * root.input.map //=> PreviousMap\n */\nclass PreviousMap {\n  /**\n   * @param {string}         css    Input CSS source.\n   * @param {processOptions} [opts] {@link Processor#process} options.\n   */\n  constructor (css, opts) {\n    this.loadAnnotation(css)\n    /**\n     * Was source map inlined by data-uri to input CSS.\n     *\n     * @type {boolean}\n     */\n    this.inline = this.startWith(this.annotation, 'data:')\n\n    let prev = opts.map ? opts.map.prev : undefined\n    let text = this.loadMap(opts.from, prev)\n    if (text) this.text = text\n  }\n\n  /**\n   * Create a instance of `SourceMapGenerator` class\n   * from the `source-map` library to work with source map information.\n   *\n   * It is lazy method, so it will create object only on first call\n   * and then it will use cache.\n   *\n   * @return {SourceMapGenerator} Object with source map information.\n   */\n  consumer () {\n    if (!this.consumerCache) {\n      this.consumerCache = new mozilla.SourceMapConsumer(this.text)\n    }\n    return this.consumerCache\n  }\n\n  /**\n   * Does source map contains `sourcesContent` with input source text.\n   *\n   * @return {boolean} Is `sourcesContent` present.\n   */\n  withContent () {\n    return !!(this.consumer().sourcesContent &&\n              this.consumer().sourcesContent.length > 0)\n  }\n\n  startWith (string, start) {\n    if (!string) return false\n    return string.substr(0, start.length) === start\n  }\n\n  loadAnnotation (css) {\n    let match = css.match(/\\/\\*\\s*# sourceMappingURL=(.*)\\s*\\*\\//)\n    if (match) this.annotation = match[1].trim()\n  }\n\n  decodeInline (text) {\n    let baseCharsetUri = /^data:application\\/json;charset=utf-?8;base64,/\n    let baseUri = /^data:application\\/json;base64,/\n    let uri = 'data:application/json,'\n\n    if (this.startWith(text, uri)) {\n      return decodeURIComponent(text.substr(uri.length))\n    } else if (baseCharsetUri.test(text) || baseUri.test(text)) {\n      return fromBase64(text.substr(RegExp.lastMatch.length))\n    } else {\n      let encoding = text.match(/data:application\\/json;([^,]+),/)[1]\n      throw new Error('Unsupported source map encoding ' + encoding)\n    }\n  }\n\n  loadMap (file, prev) {\n    if (prev === false) return false\n\n    if (prev) {\n      if (typeof prev === 'string') {\n        return prev\n      } else if (typeof prev === 'function') {\n        let prevPath = prev(file)\n        if (prevPath && fs.existsSync && fs.existsSync(prevPath)) {\n          return fs.readFileSync(prevPath, 'utf-8').toString().trim()\n        } else {\n          throw new Error(\n            'Unable to load previous source map: ' + prevPath.toString())\n        }\n      } else if (prev instanceof mozilla.SourceMapConsumer) {\n        return mozilla.SourceMapGenerator.fromSourceMap(prev).toString()\n      } else if (prev instanceof mozilla.SourceMapGenerator) {\n        return prev.toString()\n      } else if (this.isMap(prev)) {\n        return JSON.stringify(prev)\n      } else {\n        throw new Error(\n          'Unsupported previous source map format: ' + prev.toString())\n      }\n    } else if (this.inline) {\n      return this.decodeInline(this.annotation)\n    } else if (this.annotation) {\n      let map = this.annotation\n      if (file) map = path.join(path.dirname(file), map)\n\n      this.root = path.dirname(map)\n      if (fs.existsSync && fs.existsSync(map)) {\n        return fs.readFileSync(map, 'utf-8').toString().trim()\n      } else {\n        return false\n      }\n    }\n  }\n\n  isMap (map) {\n    if (typeof map !== 'object') return false\n    return typeof map.mappings === 'string' || typeof map._mappings === 'string'\n  }\n}\n\nexport default PreviousMap\n"]}\n","'use strict';\n\nexports.__esModule = true;\n/**\n * Contains helpers for working with vendor prefixes.\n *\n * @example\n * const vendor = postcss.vendor\n *\n * @namespace vendor\n */\nvar vendor = {\n\n  /**\n   * Returns the vendor prefix extracted from an input string.\n   *\n   * @param {string} prop String with or without vendor prefix.\n   *\n   * @return {string} vendor prefix or empty string\n   *\n   * @example\n   * postcss.vendor.prefix('-moz-tab-size') //=> '-moz-'\n   * postcss.vendor.prefix('tab-size')      //=> ''\n   */\n  prefix: function prefix(prop) {\n    var match = prop.match(/^(-\\w+-)/);\n    if (match) {\n      return match[0];\n    } else {\n      return '';\n    }\n  },\n\n\n  /**\n     * Returns the input string stripped of its vendor prefix.\n     *\n     * @param {string} prop String with or without vendor prefix.\n     *\n     * @return {string} String name without vendor prefixes.\n     *\n     * @example\n     * postcss.vendor.unprefixed('-moz-tab-size') //=> 'tab-size'\n     */\n  unprefixed: function unprefixed(prop) {\n    return prop.replace(/^-\\w+-/, '');\n  }\n};\n\nexports.default = vendor;\nmodule.exports = exports['default'];\n//# sourceMappingURL=data:application/json;charset=utf8;base64,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\n"],"sourceRoot":""}