{"version":3,"sources":["webpack:///./js/Core/CustomizationLoader.js","webpack:///./webpack/new/node_modules/postcss/lib/container.js","webpack:///./webpack/new/node_modules/source-map/lib/util.js","webpack:///./webpack/new/node_modules/postcss/lib/root.js","webpack:///./webpack/new/node_modules/buffer/index.js","webpack:///./webpack/new/node_modules/postcss/lib/declaration.js","webpack:///./webpack/new/node_modules/postcss/lib/node.js","webpack:///./webpack/new/node_modules/postcss/lib/stringify.js","webpack:///./webpack/new/node_modules/postcss/lib/input.js","webpack:///./webpack/new/node_modules/postcss/lib/comment.js","webpack:///declaration.es6","webpack:///node.es6","webpack:///stringify.es6","webpack:///./webpack/new/node_modules/path-browserify/index.js","webpack:///parse.es6","webpack:///comment.es6","webpack:///at-rule.es6","webpack:///container.es6","webpack:///rule.es6","webpack:///./webpack/new/node_modules/postcss/lib/css-syntax-error.js","webpack:///./webpack/new/node_modules/postcss/lib/symbols.js","webpack:///./webpack/new/node_modules/postcss/lib/document.js","webpack:///./webpack/new/node_modules/postcss/lib/result.js","webpack:///./webpack/new/node_modules/postcss/lib/parse.js","webpack:///./webpack/new/node_modules/postcss/lib/at-rule.js","webpack:///./webpack/new/node_modules/postcss/lib/rule.js","webpack:///css-syntax-error.es6","webpack:///stringifier.es6","webpack:///processor.es6","webpack:///lazy-result.es6","webpack:///./webpack/new/node_modules/source-map/source-map.js","webpack:///./webpack/new/node_modules/source-map/lib/source-map-generator.js","webpack:///./webpack/new/node_modules/source-map/lib/base64-vlq.js","webpack:///./webpack/new/node_modules/source-map/lib/array-set.js","webpack:///./webpack/new/node_modules/process/browser.js","webpack:///list.es6","webpack:///root.es6","webpack:///./webpack/new/node_modules/postcss/lib/stringifier.js","webpack:///./webpack/new/node_modules/postcss/lib/lazy-result.js","webpack:///./webpack/new/node_modules/postcss/lib/map-generator.js","webpack:///./webpack/new/node_modules/postcss/lib/previous-map.js","webpack:///./webpack/new/node_modules/postcss/lib/warn-once.js","webpack:///./webpack/new/node_modules/postcss/lib/warning.js","webpack:///./webpack/new/node_modules/postcss/lib/list.js","webpack:///./js/Core/CustomCssLoader.js","webpack:///./webpack/new/node_modules/postcss-value-parser/lib/index.js","webpack:///./webpack/new/node_modules/postcss-value-parser/lib/parse.js","webpack:///./webpack/new/node_modules/postcss-value-parser/lib/walk.js","webpack:///./webpack/new/node_modules/postcss-value-parser/lib/stringify.js","webpack:///./webpack/new/node_modules/postcss-value-parser/lib/unit.js","webpack:///postcss.es6","webpack:///map-generator.es6","webpack:///./webpack/new/node_modules/base64-js/index.js","webpack:///./webpack/new/node_modules/ieee754/index.js","webpack:///./webpack/new/node_modules/isarray/index.js","webpack:///./webpack/new/node_modules/source-map/lib/base64.js","webpack:///./webpack/new/node_modules/source-map/lib/mapping-list.js","webpack:///./webpack/new/node_modules/source-map/lib/source-map-consumer.js","webpack:///./webpack/new/node_modules/source-map/lib/binary-search.js","webpack:///./webpack/new/node_modules/source-map/lib/quick-sort.js","webpack:///./webpack/new/node_modules/source-map/lib/source-node.js","webpack:///warn-once.es6","webpack:///result.es6","webpack:///warning.es6","webpack:///parser.es6","webpack:///tokenize.es6","webpack:///input.es6","webpack:///previous-map.es6","webpack:///vendor.es6","webpack:///./webpack/new/node_modules/postcss/lib/postcss.js","webpack:///./webpack/new/node_modules/picocolors/picocolors.browser.js","webpack:///./webpack/new/node_modules/nanoid/non-secure/index.js","webpack:///./webpack/new/node_modules/postcss/lib/parser.js","webpack:///./webpack/new/node_modules/postcss/lib/tokenize.js","webpack:///./webpack/new/node_modules/postcss/lib/processor.js","webpack:///./webpack/new/node_modules/postcss/lib/no-work-result.js","webpack:///./webpack/new/node_modules/postcss/lib/fromJSON.js"],"names":["ko","require","Ajax","Constants","Promise","CustomCssLoader","ArrayHelpers","Array","StringCustomizationPageId","module","exports","params","_this","this","_serverData","serverData","_pageId","pageId","_loadStrings","customStringsUrl","customUrl","retryCount","maxRetries","slMaxRetry","reject","resolve","ajaxParams","targetUrl","contentType","ContentType","Json","requestType","RequestType","Get","timeout","successCallback","_event","response","failureCallback","error","Handler","sendRequest","_loadResource","then","JSON","parse","strings","isLoadFailure","customCssLoader","observable","isLoadComplete","initialize","load","customResourceUrls","customCssUrl","loadPromises","stringPromises","customStringsFiles","promisesArray","stringFilesToLoad","ConditionalAccess","conditionalAccess","push","AttributeCollection","attributeCollection","ProofUpPage","authenticatorNudgeScreen","ErrorPage","adminConsent","LoginPage","MessagePage","numStringsToLoad","length","idx","_loadCustomStringsFiles","customCss","loadAsync","allSettled","promisesResults","customStringsArray","forEach","promiseResult","status","value","concat","all","catch","_typeof","o","Symbol","iterator","constructor","prototype","_toConsumableArray","arr","isArray","_arrayLikeToArray","_arrayWithoutHoles","iter","from","_iterableToArray","_unsupportedIterableToArray","TypeError","_nonIterableSpread","_classCallCheck","instance","Constructor","_defineProperties","target","props","i","descriptor","enumerable","configurable","writable","Object","defineProperty","_toPropertyKey","key","t","r","e","toPrimitive","call","String","Number","_toPrimitive","_callSuper","_getPrototypeOf","self","ReferenceError","_assertThisInitialized","_possibleConstructorReturn","Boolean","valueOf","Reflect","construct","_isNativeReflectConstruct","apply","_get","get","bind","property","receiver","base","_superPropBase","desc","getOwnPropertyDescriptor","arguments","object","hasOwnProperty","setPrototypeOf","getPrototypeOf","__proto__","_setPrototypeOf","p","_createForOfIteratorHelper","allowArrayLike","it","F","s","n","done","_e","f","err","normalCompletion","didErr","step","next","_e2","return","minLen","toString","slice","name","test","len","arr2","Rule","AtRule","Root","_require","isClean","my","Declaration","Comment","Container","_Node","protoProps","staticProps","subClass","superClass","create","_inherits","_len","children","_key","_i","_children","_step2","child","nodes","normalize","last","_iterator2","node","proxyOf","markDirty","keepBetween","_step3","_iterator3","cleanRaws","callback","undefined","index","result","getIterator","indexes","condition","every","lastEach","prop","startsWith","_len2","args","_key2","map","toProxy","cb","_len3","other","_key3","root","set","indexOf","exist","add","existIndex","reverse","_step4","_iterator4","splice","id","type","_step5","_iterator5","sample","cleanSource","source","_step6","_iterator6","parent","removeChild","_step7","_iterator7","Error","selector","text","rebuild","markDirtyUp","_step","_iterator","raws","before","replace","_len4","_key4","_step8","_iterator8","_step9","first","_iterator9","unshift","_step10","_iterator10","pattern","opts","walkDecls","decl","includes","fast","some","each","addToError","walk","RegExp","registerParse","dependant","registerRule","registerAtRule","registerRoot","default","getArg","aArgs","aName","aDefaultValue","urlRegexp","dataUrlRegexp","urlParse","aUrl","match","scheme","auth","host","port","path","urlGenerate","aParsedUrl","url","aPath","part","isAbsolute","parts","split","up","join","aRoot","aPathUrl","aRootUrl","joined","charAt","relative","level","lastIndexOf","substr","supportsNullProto","identity","isProtoString","charCodeAt","strcmp","aStr1","aStr2","toSetString","aStr","fromSetString","compareByOriginalPositions","mappingA","mappingB","onlyCompareOriginal","cmp","originalLine","originalColumn","generatedColumn","generatedLine","compareByGeneratedPositionsDeflated","onlyCompareGenerated","compareByGeneratedPositionsInflated","parseSourceMapInput","str","computeSourceURL","sourceRoot","sourceURL","sourceMapURL","parsed","substring","LazyResult","Processor","_Container","defaults","ignore","lazy","stringify","registerLazyResult","registerProcessor","base64","ieee754","kMaxLength","Buffer","TYPED_ARRAY_SUPPORT","createBuffer","that","RangeError","Uint8Array","arg","encodingOrOffset","allocUnsafe","ArrayBuffer","array","byteOffset","byteLength","fromArrayLike","fromArrayBuffer","string","encoding","isEncoding","actual","write","fromString","obj","isBuffer","checked","copy","buffer","val","data","fromObject","assertSize","size","isView","loweredCase","utf8ToBytes","base64ToBytes","toLowerCase","slowToString","start","end","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","b","m","bidirectionalIndexOf","dir","isNaN","arrayIndexOf","indexSize","arrLength","valLength","read","buf","readUInt16BE","foundIndex","found","j","hexWrite","offset","remaining","strLen","parseInt","utf8Write","blitBuffer","asciiWrite","byteArray","asciiToBytes","latin1Write","base64Write","ucs2Write","units","c","hi","lo","utf16leToBytes","fromByteArray","Math","min","res","secondByte","thirdByte","fourthByte","tempCodePoint","firstByte","codePoint","bytesPerSequence","codePoints","fromCharCode","decodeCodePointsArray","SlowBuffer","alloc","INSPECT_MAX_BYTES","global","foo","subarray","typedArraySupport","poolSize","_augment","species","fill","allocUnsafeSlow","_isBuffer","compare","a","x","y","list","pos","swap16","swap32","swap64","equals","inspect","max","thisStart","thisEnd","thisCopy","targetCopy","isFinite","toJSON","_arr","ret","out","toHex","bytes","checkOffset","ext","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","code","INVALID_BASE64_RE","Infinity","leadSurrogate","toByteArray","trim","stringtrim","base64clean","src","dst","ownKeys","keys","getOwnPropertySymbols","filter","_objectSpread","_defineProperty","getOwnPropertyDescriptors","defineProperties","CssSyntaxError","Stringifier","cloneNode","cloned","Node","clone","append","postcssNode","stack","input","line","column","insertAfter","overrides","insertBefore","after","between","message","_this$rangeBy","rangeBy","stringRepresentation","positionInside","word","endIndex","defaultType","raw","bookmark","foundSelf","_nodes","remove","_","inputs","fixed","emitInputs","Map","inputsNextIndex","inputId","proxyCache","Proxy","getProxyProcessor","stringifier","warn","builder","SourceMapConsumer","SourceMapGenerator","_require2","fileURLToPath","pathToFileURL","_require3","nanoid","terminalHighlight","PreviousMap","fromOffsetCache","sourceMapAvailable","pathAvailable","Input","css","hasBOM","file","consumer","mapResolve","endLine","endColumn","fromOffset","col","origin","plugin","lineToIndex","lines","prevIndex","l","mid","to","fromUrl","originalPositionFor","URL","mapFile","protocol","sourceContentFor","json","consumerCache","registerInput","_cssSyntaxError","_interopRequireDefault","_stringifier","_stringify","positionBy","cloneBefore","cloneAfter","replaceWith","prev","normalizeArray","allowAboveRoot","xs","resolvedPath","resolvedAbsolute","process","cwd","trailingSlash","paths","fromParts","toParts","samePartsLength","outputParts","sep","delimiter","dirname","hasRoot","matchedSlash","basename","extname","startDot","startPart","preDotState","_parser","_input","parser","_Container$prototype$","prepend","_Container$prototype$2","_declaration","_comment","walkRules","walkAtRules","walkComments","_isArray","_i2","_ref","_isArray2","_i3","_ref2","_isArray3","_i4","_ref3","_isArray4","_i5","_ref4","_isArray5","_i6","_ref5","_isArray6","_i7","_ref6","removeAll","_isArray7","_i8","_ref7","replaceValues","_isArray8","_i9","_ref8","_isArray9","_i10","_ref9","_i11","_container","_list","comma","values","_wrapNativeSuper","Class","_cache","fn","Function","_isNativeFunction","has","Wrapper","_construct","pico","_Error","reason","setMessage","captureStackTrace","color","_this2","isColorSupported","mark","aside","maxWidth","_pico$createColors","createColors","bold","gray","red","number","gutter","spacing","showSourceCode","Document","Warning","Result","processor","messages","lastPlugin","postcssPlugin","warning","Parser","_get2","_get3","_supportsColor","_chalk","_terminalHighlight","stdout","DEFAULT_RAW","colon","indent","beforeDecl","beforeRule","beforeOpen","beforeClose","beforeComment","emptyBody","commentLeft","commentRight","semicolon","body","comment","left","right","rawValue","important","rule","block","ownSemicolon","atrule","afterName","own","detect","rawCache","beforeAfter","method","toUpperCase","rawSemicolon","rawEmptyBody","rawIndent","rawBeforeComment","rawBeforeDecl","rawBeforeRule","rawBeforeClose","rawBeforeOpen","rawColon","depth","_lazyResult","plugins","version","use","normalized","postcss","_mapGenerator","_stringify2","_result","_parse","isPromise","stringified","processed","inline","syntax","warnings","sync","onFulfilled","onRejected","async","finally","onFinally","handleError","postcssVersion","console","asyncTick","promise","run","processing","generate","content","SourceNode","base64VLQ","util","ArraySet","MappingList","_file","_sourceRoot","_skipValidation","_sources","_names","_mappings","_sourcesContents","_version","fromSourceMap","aSourceMapConsumer","generator","eachMapping","mapping","newMapping","generated","original","addMapping","sources","sourceFile","sourceRelative","setSourceContent","_validateMapping","aSourceFile","aSourceContent","applySourceMap","aSourceMapPath","newSources","newNames","unsortedForEach","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","shifted","shift","rest","hasNativeMap","_array","_set","fromArray","aArray","aAllowDuplicates","getOwnPropertyNames","sStr","isDuplicate","at","aIdx","cachedSetTimeout","cachedClearTimeout","defaultSetTimout","defaultClearTimeout","runTimeout","fun","setTimeout","clearTimeout","currentQueue","queue","draining","queueIndex","cleanUpNextTick","drainQueue","marker","runClearTimeout","Item","noop","nextTick","title","browser","env","argv","versions","on","addListener","once","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","chdir","umask","separators","current","func","quote","escape","letter","space","toResult","_regeneratorRuntime","asyncIterator","u","toStringTag","define","wrap","Generator","Context","makeInvokeMethod","tryCatch","h","GeneratorFunction","GeneratorFunctionPrototype","d","v","g","defineIteratorMethods","_invoke","AsyncIterator","invoke","__await","callInvokeWithMethodAndArg","delegate","maybeInvokeDelegate","sent","_sent","dispatchException","abrupt","resultName","nextLoc","pushTryEntry","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","resetTryEntry","completion","reset","displayName","isGeneratorFunction","awrap","pop","stop","rval","handle","complete","finish","delegateYield","_slicedToArray","_arrayWithHoles","_iterableToArrayLimit","_nonIterableRest","asyncGeneratorStep","gen","_next","_throw","info","MapGenerator","TYPE_TO_CLASS_NAME","document","PLUGIN_PROPS","AtRuleExit","CommentExit","DeclarationExit","DocumentExit","Once","OnceExit","prepare","RootExit","RuleExit","NOT_VISITORS","getEvents","toStack","eventIndex","events","visitorIndex","visitors","cleanMarks","_Symbol$toStringTag","helpers","_runAsync","runAsync","event","hasListener","_callee","_promise","_loop","_this3","_context2","runOnRoot","t0","prepareVisitors","visitTick","t1","_step2$value","visitor","roots","_context","subRoot","t3","_this4","getAsyncError","walkSync","visitSync","_step5$value","visit","_visitors$visit$visit","_this5","registerPostcss","cssString","mapOpts","usesFileUrls","absolute","memoizedFileURLs","memoizedPaths","memoizedURLs","isInline","toBase64","annotation","outputFile","eol","previous","toUrl","clearAnnotation","isMap","generateMap","generateString","isSourcesContent","setSourcesContent","applyPrevMaps","isAnnotation","addAnnotation","sourcePath","withContent","cached","previousMaps","already","toFileUrl","window","btoa","unescape","encodeURIComponent","fileURL","encodeURI","existsSync","readFileSync","loadAnnotation","startWith","loadMap","decodeURIComponent","lastMatch","atob","sourceMapString","sections","comments","getAnnotationURL","prevPath","loadFile","decodeInline","printed","range","opt","inQuote","prevQuote","postcssValueParser","Helpers","ApiRequest","ClientTracingConstants","doc","head","fixCustomCssRemoval","ServerData","fRemoveCustomCss","fUsePostCssHotfix","c_AllowedCssAtRules","c_AllowedCssSelectors","c_DisallowedCssProperties","c_AllowedCssCharactersRegex","c_AllowedCssPseudoSelectorRegex","c_AllowedCssUrlSchemesRegex","_customCssNode","_sanitizeCss","parsedCss","_sanitizeAtRule","filteredSelectors","arrayFilter","selectors","_sanitizeRule","propertyValue","parsedNodes","parsedNode","_sanitizePropertyValue","_sanitizeProperty","checkApiCanary","eventId","EventIds","Api_GetCustomCss","_loadInternalAsync","sanitizedCss","createElement","innerHTML","appendChild","ValueParser","bubble","unit","openParentheses","closeParentheses","singleQuote","doubleQuote","backslash","slash","star","uLower","uUpper","plus","isUnicodeRange","token","escapePos","whitespacePos","parenthesesOpenPos","tokens","balanced","sourceIndex","unclosed","stringifyNode","custom","customResult","minus","dot","exp","EXP","nextCode","nextNextCode","likeNumber","_processor","_atRule","_vendor","_rule","_root","initializer","creator","transformer","cache","processOpts","pluginOpts","vendor","atRule","_sourceMap","_path","b64","lens","getLens","validLen","placeHoldersLen","tmp","Arr","_byteLength","curByte","revLookup","uint8","extraBytes","len2","encodeChunk","lookup","num","output","isLE","mLen","nBytes","eLen","eMax","eBias","nBits","NaN","rt","abs","log","LN2","intToCharMap","charCode","_sorted","_last","aCallback","aThisArg","aMapping","lineA","lineB","columnA","columnB","sort","binarySearch","quickSort","aSourceMap","aSourceMapURL","sourceMap","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","ary","doQuickSort","comparator","low","high","round","random","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","_warning","_tokenize","spaces","createTokenizer","tokenizer","endOfFile","nextToken","freeSemicolon","emptyRule","endFile","init","bracket","brackets","back","unclosedBracket","unknownWord","spacesAndCommentsFromEnd","spacesAndCommentsFromStart","precheckMissedSemicolon","stringFrom","spacesFromEnd","_type","checkMissedSemicolon","unnamedAtrule","open","unexpectedClose","unclosedBlock","clean","reduce","lastTokenType","doubleColon","founded","options","nextOffset","escaped","currentToken","ignoreErrors","returned","what","ignoreUnclosed","NEWLINE","FEED","CR","SPACE","TAB","OPEN_SQUARE","CLOSE_SQUARE","OPEN_CURLY","CLOSE_CURLY","COLON","SEMICOLON","CLOSE_PARENTHESES","controlChar","OPEN_PARENTHESES","SINGLE_QUOTE","DOUBLE_QUOTE","BACKSLASH","RE_BAD_BRACKET","AT","RE_AT_END","lastIndex","SLASH","RE_HEX_ESCAPE","ASTERISK","RE_WORD_END","position","_previousMap","sequence","_fs","annotations","lastAnnotation","uri","prefix","unprefixed","fromJSON","warningPrinted","LANG","dim","italic","underline","inverse","hidden","strikethrough","black","green","yellow","blue","magenta","cyan","white","bgBlack","bgRed","bgGreen","bgYellow","bgBlue","bgMagenta","bgCyan","bgWhite","urlAlphabet","customAlphabet","alphabet","defaultSize","SAFE_COMMENT_NEIGHBOR","empty","customProperty","getPosition","entries","_step$value","findLastWithPosition","firstSpaces","NoWorkResult","_css","_opts","_map","_map$generate2","generatedCSS","generatedMap","_excluded","_excluded2","_objectWithoutProperties","excluded","sourceKeys","_objectWithoutPropertiesLoose","sourceSymbolKeys","propertyIsEnumerable","ownInputs","inputHydrated","_defaults$source"],"mappings":"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","file":"content/js/asyncchunk/convergedlogin_pcustomizationloader_8e14dcf0e3ff5580d170.js","sourcesContent":["var ko = require(\"knockout\");\r\nvar Ajax = require(\"./AjaxHandlerControl\");\r\nvar Constants = require(\"./Constants\");\r\nvar Promise = require(\"./Promise\");\r\nvar CustomCssLoader = require(\"../Core/CustomCssLoader\");\r\nvar Helpers = require(\"./Helpers\");\r\n\r\nvar ArrayHelpers = Helpers.Array;\r\nvar StringCustomizationPageId = Constants.StringCustomizationPageId;\r\n\r\n\r\nfunction CustomizationLoader(params)\r\n{\r\n    var _this = this;\r\n\r\n    var c_requestTimeout = 30000; \r\n\r\n    \r\n    var _serverData = params.serverData;\r\n    var _pageId = params.pageId;\r\n    \r\n\r\n    _this.customCssLoader = new CustomCssLoader();\r\n\r\n    _this.strings = ko.observable({});\r\n    _this.strings.isLoadComplete = ko.observable(false);\r\n    _this.strings.isLoadFailure = ko.observable(false);\r\n\r\n    \r\n    \r\n    _this.isLoadComplete = ko.observable(false);\r\n\r\n    \r\n    \r\n    _this.isLoadFailure = ko.observable(false);\r\n\r\n    \r\n    _this.initialize = function () { };\r\n\r\n    \r\n    _this.load = function (customResourceUrls)\r\n    {\r\n        var loadPromises = [];\r\n        var stringPromises = [];\r\n\r\n        if (customResourceUrls.customStringsFiles)\r\n        {\r\n            _loadCustomStringsFiles(customResourceUrls.customStringsFiles, stringPromises);\r\n        }\r\n\r\n        if (customResourceUrls.customCss)\r\n        {\r\n            loadPromises.push(_loadCustomCss(customResourceUrls.customCss));\r\n        }\r\n\r\n        \r\n        Promise.allSettled(stringPromises).then(\r\n            function onResolve(promisesResults)\r\n            {\r\n                var customStringsArray = [];\r\n\r\n                \r\n                ArrayHelpers.forEach(promisesResults,\r\n                    function (promiseResult)\r\n                    {\r\n                        if (promiseResult && promiseResult.status === \"fulfilled\" && promiseResult.value)\r\n                        {\r\n                            customStringsArray = customStringsArray.concat(promiseResult.value);\r\n                        }\r\n                    });\r\n\r\n                _this.strings(customStringsArray);\r\n                _this.strings.isLoadComplete(true);\r\n            });\r\n\r\n        \r\n        \r\n        Promise.allSettled(loadPromises.concat(stringPromises)).then(\r\n            function onResolve()\r\n            {\r\n                _this.isLoadComplete(true);\r\n            });\r\n\r\n        return Promise.all(loadPromises).catch(\r\n            function onReject(error)\r\n            {\r\n                _this.isLoadFailure(true);\r\n                \r\n                throw error;\r\n            });\r\n    };\r\n\r\n    function _loadCustomStringsFiles(customStringsFiles, promisesArray)\r\n    {\r\n        var stringFilesToLoad = [];\r\n\r\n        \r\n        switch (_pageId)\r\n        {\r\n            case StringCustomizationPageId.ConditionalAccess:\r\n                if (customStringsFiles.conditionalAccess)\r\n                {\r\n                    stringFilesToLoad.push(customStringsFiles.conditionalAccess);\r\n                }\r\n                break;\r\n\r\n            case StringCustomizationPageId.AttributeCollection:\r\n                if (customStringsFiles.attributeCollection)\r\n                {\r\n                    stringFilesToLoad.push(customStringsFiles.attributeCollection);\r\n                }\r\n                break;\r\n\r\n            case StringCustomizationPageId.ProofUpPage:\r\n                if (customStringsFiles.authenticatorNudgeScreen)\r\n                {\r\n                    stringFilesToLoad.push(customStringsFiles.authenticatorNudgeScreen);\r\n                }\r\n\r\n                if (customStringsFiles.conditionalAccess)\r\n                {\r\n                    stringFilesToLoad.push(customStringsFiles.conditionalAccess);\r\n                }\r\n                break;\r\n\r\n            case StringCustomizationPageId.ErrorPage:\r\n                if (customStringsFiles.adminConsent)\r\n                {\r\n                    stringFilesToLoad.push(customStringsFiles.adminConsent);\r\n                }\r\n\r\n                if (customStringsFiles.conditionalAccess)\r\n                {\r\n                    stringFilesToLoad.push(customStringsFiles.conditionalAccess);\r\n                }\r\n                break;\r\n\r\n            case StringCustomizationPageId.LoginPage:\r\n                if (customStringsFiles.attributeCollection)\r\n                {\r\n                    stringFilesToLoad.push(customStringsFiles.attributeCollection);\r\n                }\r\n                break;\r\n\r\n            case StringCustomizationPageId.MessagePage:\r\n            default:\r\n                break;\r\n        }\r\n\r\n        var numStringsToLoad = stringFilesToLoad.length;\r\n        if (numStringsToLoad)\r\n        {\r\n            for (var idx = 0; idx < numStringsToLoad; idx++)\r\n            {\r\n                promisesArray.push(_loadStrings(stringFilesToLoad[idx]));\r\n            }\r\n        }\r\n        else\r\n        {\r\n            _this.strings.isLoadComplete(true);\r\n        }\r\n    }\r\n\r\n    function _loadStrings(customStringsUrl)\r\n    {\r\n        \r\n        return _loadResource(customStringsUrl).then(\r\n            function onResolve(response)\r\n            {\r\n                return JSON.parse(response);\r\n            },\r\n            function onReject()\r\n            {\r\n                _this.strings.isLoadFailure(true);\r\n            });\r\n    }\r\n\r\n    function _loadCustomCss(customCssUrl)\r\n    {\r\n        return _this.customCssLoader.loadAsync(customCssUrl);\r\n    }\r\n\r\n    function _loadResource(customUrl)\r\n    {\r\n        var retryCount = 0;\r\n        var maxRetries = _serverData.slMaxRetry || 0;\r\n\r\n        if (!customUrl)\r\n        {\r\n            return Promise.reject();\r\n        }\r\n\r\n        var loadPromise = new Promise(function (resolve, reject)\r\n        {\r\n            var ajaxParams = {\r\n                targetUrl: customUrl,\r\n                contentType: Constants.ContentType.Json,\r\n                requestType: Ajax.RequestType.Get,\r\n                timeout: c_requestTimeout,\r\n                successCallback: function (_event, response)\r\n                {\r\n                    resolve(response);\r\n                },\r\n                failureCallback: function (error)\r\n                {\r\n                    if (retryCount < maxRetries)\r\n                    {\r\n                        retryCount += 1;\r\n                        var retry = new Ajax.Handler(ajaxParams);\r\n                        retry.sendRequest();\r\n                    }\r\n                    else\r\n                    {\r\n                        reject(error);\r\n                    }\r\n                }\r\n            };\r\n\r\n            var request = new Ajax.Handler(ajaxParams);\r\n            request.sendRequest();\r\n        });\r\n\r\n        return loadPromise;\r\n    }\r\n}\r\n\r\nmodule.exports = CustomizationLoader;","'use strict'\n\nlet { isClean, my } = require('./symbols')\nlet Declaration = require('./declaration')\nlet Comment = require('./comment')\nlet Node = require('./node')\n\nlet parse, Rule, AtRule, Root\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\nfunction markDirtyUp(node) {\n  node[isClean] = false\n  if (node.proxyOf.nodes) {\n    for (let i of node.proxyOf.nodes) {\n      markDirtyUp(i)\n    }\n  }\n}\n\nclass Container extends Node {\n  append(...children) {\n    for (let child of children) {\n      let nodes = this.normalize(child, this.last)\n      for (let node of nodes) this.proxyOf.nodes.push(node)\n    }\n\n    this.markDirty()\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  each(callback) {\n    if (!this.proxyOf.nodes) return undefined\n    let iterator = this.getIterator()\n\n    let index, result\n    while (this.indexes[iterator] < this.proxyOf.nodes.length) {\n      index = this.indexes[iterator]\n      result = callback(this.proxyOf.nodes[index], index)\n      if (result === false) break\n\n      this.indexes[iterator] += 1\n    }\n\n    delete this.indexes[iterator]\n    return result\n  }\n\n  every(condition) {\n    return this.nodes.every(condition)\n  }\n\n  getIterator() {\n    if (!this.lastEach) this.lastEach = 0\n    if (!this.indexes) this.indexes = {}\n\n    this.lastEach += 1\n    let iterator = this.lastEach\n    this.indexes[iterator] = 0\n\n    return iterator\n  }\n\n  getProxyProcessor() {\n    return {\n      get(node, prop) {\n        if (prop === 'proxyOf') {\n          return node\n        } else if (!node[prop]) {\n          return node[prop]\n        } else if (\n          prop === 'each' ||\n          (typeof prop === 'string' && prop.startsWith('walk'))\n        ) {\n          return (...args) => {\n            return node[prop](\n              ...args.map(i => {\n                if (typeof i === 'function') {\n                  return (child, index) => i(child.toProxy(), index)\n                } else {\n                  return i\n                }\n              })\n            )\n          }\n        } else if (prop === 'every' || prop === 'some') {\n          return cb => {\n            return node[prop]((child, ...other) =>\n              cb(child.toProxy(), ...other)\n            )\n          }\n        } else if (prop === 'root') {\n          return () => node.root().toProxy()\n        } else if (prop === 'nodes') {\n          return node.nodes.map(i => i.toProxy())\n        } else if (prop === 'first' || prop === 'last') {\n          return node[prop].toProxy()\n        } else {\n          return node[prop]\n        }\n      },\n\n      set(node, prop, value) {\n        if (node[prop] === value) return true\n        node[prop] = value\n        if (prop === 'name' || prop === 'params' || prop === 'selector') {\n          node.markDirty()\n        }\n        return true\n      }\n    }\n  }\n\n  index(child) {\n    if (typeof child === 'number') return child\n    if (child.proxyOf) child = child.proxyOf\n    return this.proxyOf.nodes.indexOf(child)\n  }\n\n  insertAfter(exist, add) {\n    let existIndex = this.index(exist)\n    let nodes = this.normalize(add, this.proxyOf.nodes[existIndex]).reverse()\n    existIndex = this.index(exist)\n    for (let node of nodes) this.proxyOf.nodes.splice(existIndex + 1, 0, node)\n\n    let index\n    for (let id in this.indexes) {\n      index = this.indexes[id]\n      if (existIndex < index) {\n        this.indexes[id] = index + nodes.length\n      }\n    }\n\n    this.markDirty()\n\n    return this\n  }\n\n  insertBefore(exist, add) {\n    let existIndex = this.index(exist)\n    let type = existIndex === 0 ? 'prepend' : false\n    let nodes = this.normalize(add, this.proxyOf.nodes[existIndex], type).reverse()\n    existIndex = this.index(exist)\n    for (let node of nodes) this.proxyOf.nodes.splice(existIndex, 0, node)\n\n    let index\n    for (let id in this.indexes) {\n      index = this.indexes[id]\n      if (existIndex <= index) {\n        this.indexes[id] = index + nodes.length\n      }\n    }\n\n    this.markDirty()\n\n    return this\n  }\n\n  normalize(nodes, sample) {\n    if (typeof nodes === 'string') {\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' && this.type !== 'document') {\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      nodes = [new Rule(nodes)]\n    } else if (nodes.name) {\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      /* c8 ignore next */\n      if (!i[my]) Container.rebuild(i)\n      i = i.proxyOf\n      if (i.parent) i.parent.removeChild(i)\n      if (i[isClean]) markDirtyUp(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.proxyOf\n      return i\n    })\n\n    return processed\n  }\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.proxyOf.nodes.unshift(node)\n      for (let id in this.indexes) {\n        this.indexes[id] = this.indexes[id] + nodes.length\n      }\n    }\n\n    this.markDirty()\n\n    return this\n  }\n\n  push(child) {\n    child.parent = this\n    this.proxyOf.nodes.push(child)\n    return this\n  }\n\n  removeAll() {\n    for (let node of this.proxyOf.nodes) node.parent = undefined\n    this.proxyOf.nodes = []\n\n    this.markDirty()\n\n    return this\n  }\n\n  removeChild(child) {\n    child = this.index(child)\n    this.proxyOf.nodes[child].parent = undefined\n    this.proxyOf.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    this.markDirty()\n\n    return this\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.includes(decl.prop)) return\n      if (opts.fast && !decl.value.includes(opts.fast)) return\n\n      decl.value = decl.value.replace(pattern, callback)\n    })\n\n    this.markDirty()\n\n    return this\n  }\n\n  some(condition) {\n    return this.nodes.some(condition)\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        throw child.addToError(e)\n      }\n      if (result !== false && child.walk) {\n        result = child.walk(callback)\n      }\n\n      return result\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    }\n    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    }\n    return this.walk((child, i) => {\n      if (child.type === 'atrule' && child.name === name) {\n        return callback(child, i)\n      }\n    })\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  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    }\n    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    }\n    return this.walk((child, i) => {\n      if (child.type === 'decl' && child.prop === prop) {\n        return callback(child, i)\n      }\n    })\n  }\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    }\n    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    }\n    return this.walk((child, i) => {\n      if (child.type === 'rule' && child.selector === selector) {\n        return callback(child, i)\n      }\n    })\n  }\n\n  get first() {\n    if (!this.proxyOf.nodes) return undefined\n    return this.proxyOf.nodes[0]\n  }\n\n  get last() {\n    if (!this.proxyOf.nodes) return undefined\n    return this.proxyOf.nodes[this.proxyOf.nodes.length - 1]\n  }\n}\n\nContainer.registerParse = dependant => {\n  parse = dependant\n}\n\nContainer.registerRule = dependant => {\n  Rule = dependant\n}\n\nContainer.registerAtRule = dependant => {\n  AtRule = dependant\n}\n\nContainer.registerRoot = dependant => {\n  Root = dependant\n}\n\nmodule.exports = Container\nContainer.default = Container\n\n/* c8 ignore start */\nContainer.rebuild = node => {\n  if (node.type === 'atrule') {\n    Object.setPrototypeOf(node, AtRule.prototype)\n  } else if (node.type === 'rule') {\n    Object.setPrototypeOf(node, Rule.prototype)\n  } else if (node.type === 'decl') {\n    Object.setPrototypeOf(node, Declaration.prototype)\n  } else if (node.type === 'comment') {\n    Object.setPrototypeOf(node, Comment.prototype)\n  } else if (node.type === 'root') {\n    Object.setPrototypeOf(node, Root.prototype)\n  }\n\n  node[my] = true\n\n  if (node.nodes) {\n    node.nodes.forEach(child => {\n      Container.rebuild(child)\n    })\n  }\n}\n/* c8 ignore stop */\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\nlet Container = require('./container')\n\nlet LazyResult, Processor\n\nclass Root extends Container {\n  constructor(defaults) {\n    super(defaults)\n    this.type = 'root'\n    if (!this.nodes) this.nodes = []\n  }\n\n  normalize(child, sample, type) {\n    let nodes = super.normalize(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 (let node of nodes) {\n          node.raws.before = sample.raws.before\n        }\n      }\n    }\n\n    return nodes\n  }\n\n  removeChild(child, ignore) {\n    let 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 super.removeChild(child)\n  }\n\n  toResult(opts = {}) {\n    let lazy = new LazyResult(new Processor(), this, opts)\n    return lazy.stringify()\n  }\n}\n\nRoot.registerLazyResult = dependant => {\n  LazyResult = dependant\n}\n\nRoot.registerProcessor = dependant => {\n  Processor = dependant\n}\n\nmodule.exports = Root\nRoot.default = Root\n\nContainer.registerRoot(Root)\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <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","'use strict'\n\nlet Node = require('./node')\n\nclass Declaration extends Node {\n  constructor(defaults) {\n    if (\n      defaults &&\n      typeof defaults.value !== 'undefined' &&\n      typeof defaults.value !== 'string'\n    ) {\n      defaults = { ...defaults, value: String(defaults.value) }\n    }\n    super(defaults)\n    this.type = 'decl'\n  }\n\n  get variable() {\n    return this.prop.startsWith('--') || this.prop[0] === '$'\n  }\n}\n\nmodule.exports = Declaration\nDeclaration.default = Declaration\n","'use strict'\n\nlet { isClean, my } = require('./symbols')\nlet CssSyntaxError = require('./css-syntax-error')\nlet Stringifier = require('./stringifier')\nlet stringify = require('./stringify')\n\nfunction cloneNode(obj, parent) {\n  let cloned = new obj.constructor()\n\n  for (let i in obj) {\n    if (!Object.prototype.hasOwnProperty.call(obj, i)) {\n      /* c8 ignore next 2 */\n      continue\n    }\n    if (i === 'proxyCache') 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 (Array.isArray(value)) {\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\nclass Node {\n  constructor(defaults = {}) {\n    this.raws = {}\n    this[isClean] = false\n    this[my] = true\n\n    for (let name in defaults) {\n      if (name === 'nodes') {\n        this.nodes = []\n        for (let node of defaults[name]) {\n          if (typeof node.clone === 'function') {\n            this.append(node.clone())\n          } else {\n            this.append(node)\n          }\n        }\n      } else {\n        this[name] = defaults[name]\n      }\n    }\n  }\n\n  addToError(error) {\n    error.postcssNode = this\n    if (error.stack && this.source && /\\n\\s{4}at /.test(error.stack)) {\n      let s = this.source\n      error.stack = error.stack.replace(\n        /\\n\\s{4}at /,\n        `$&${s.input.from}:${s.start.line}:${s.start.column}$&`\n      )\n    }\n    return error\n  }\n\n  after(add) {\n    this.parent.insertAfter(this, add)\n    return this\n  }\n\n  assign(overrides = {}) {\n    for (let name in overrides) {\n      this[name] = overrides[name]\n    }\n    return this\n  }\n\n  before(add) {\n    this.parent.insertBefore(this, add)\n    return this\n  }\n\n  cleanRaws(keepBetween) {\n    delete this.raws.before\n    delete this.raws.after\n    if (!keepBetween) delete this.raws.between\n  }\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  cloneAfter(overrides = {}) {\n    let cloned = this.clone(overrides)\n    this.parent.insertAfter(this, cloned)\n    return cloned\n  }\n\n  cloneBefore(overrides = {}) {\n    let cloned = this.clone(overrides)\n    this.parent.insertBefore(this, cloned)\n    return cloned\n  }\n\n  error(message, opts = {}) {\n    if (this.source) {\n      let { end, start } = this.rangeBy(opts)\n      return this.source.input.error(\n        message,\n        { column: start.column, line: start.line },\n        { column: end.column, line: end.line },\n        opts\n      )\n    }\n    return new CssSyntaxError(message)\n  }\n\n  getProxyProcessor() {\n    return {\n      get(node, prop) {\n        if (prop === 'proxyOf') {\n          return node\n        } else if (prop === 'root') {\n          return () => node.root().toProxy()\n        } else {\n          return node[prop]\n        }\n      },\n\n      set(node, prop, value) {\n        if (node[prop] === value) return true\n        node[prop] = value\n        if (\n          prop === 'prop' ||\n          prop === 'value' ||\n          prop === 'name' ||\n          prop === 'params' ||\n          prop === 'important' ||\n          /* c8 ignore next */\n          prop === 'text'\n        ) {\n          node.markDirty()\n        }\n        return true\n      }\n    }\n  }\n\n  markDirty() {\n    if (this[isClean]) {\n      this[isClean] = false\n      let next = this\n      while ((next = next.parent)) {\n        next[isClean] = false\n      }\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  positionBy(opts, stringRepresentation) {\n    let pos = this.source.start\n    if (opts.index) {\n      pos = this.positionInside(opts.index, stringRepresentation)\n    } else if (opts.word) {\n      stringRepresentation = this.toString()\n      let index = stringRepresentation.indexOf(opts.word)\n      if (index !== -1) pos = this.positionInside(index, stringRepresentation)\n    }\n    return pos\n  }\n\n  positionInside(index, stringRepresentation) {\n    let string = stringRepresentation || 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 { column, line }\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  rangeBy(opts) {\n    let start = {\n      column: this.source.start.column,\n      line: this.source.start.line\n    }\n    let end = this.source.end\n      ? {\n        column: this.source.end.column + 1,\n        line: this.source.end.line\n      }\n      : {\n        column: start.column + 1,\n        line: start.line\n      }\n\n    if (opts.word) {\n      let stringRepresentation = this.toString()\n      let index = stringRepresentation.indexOf(opts.word)\n      if (index !== -1) {\n        start = this.positionInside(index, stringRepresentation)\n        end = this.positionInside(index + opts.word.length, stringRepresentation)\n      }\n    } else {\n      if (opts.start) {\n        start = {\n          column: opts.start.column,\n          line: opts.start.line\n        }\n      } else if (opts.index) {\n        start = this.positionInside(opts.index)\n      }\n\n      if (opts.end) {\n        end = {\n          column: opts.end.column,\n          line: opts.end.line\n        }\n      } else if (opts.endIndex) {\n        end = this.positionInside(opts.endIndex)\n      } else if (opts.index) {\n        end = this.positionInside(opts.index + 1)\n      }\n    }\n\n    if (\n      end.line < start.line ||\n      (end.line === start.line && end.column <= start.column)\n    ) {\n      end = { column: start.column + 1, line: start.line }\n    }\n\n    return { end, start }\n  }\n\n  raw(prop, defaultType) {\n    let str = new Stringifier()\n    return str.raw(this, prop, defaultType)\n  }\n\n  remove() {\n    if (this.parent) {\n      this.parent.removeChild(this)\n    }\n    this.parent = undefined\n    return this\n  }\n\n  replaceWith(...nodes) {\n    if (this.parent) {\n      let bookmark = this\n      let foundSelf = false\n      for (let node of nodes) {\n        if (node === this) {\n          foundSelf = true\n        } else if (foundSelf) {\n          this.parent.insertAfter(bookmark, node)\n          bookmark = node\n        } else {\n          this.parent.insertBefore(bookmark, node)\n        }\n      }\n\n      if (!foundSelf) {\n        this.remove()\n      }\n    }\n\n    return this\n  }\n\n  root() {\n    let result = this\n    while (result.parent && result.parent.type !== 'document') {\n      result = result.parent\n    }\n    return result\n  }\n\n  toJSON(_, inputs) {\n    let fixed = {}\n    let emitInputs = inputs == null\n    inputs = inputs || new Map()\n    let inputsNextIndex = 0\n\n    for (let name in this) {\n      if (!Object.prototype.hasOwnProperty.call(this, name)) {\n        /* c8 ignore next 2 */\n        continue\n      }\n      if (name === 'parent' || name === 'proxyCache') continue\n      let value = this[name]\n\n      if (Array.isArray(value)) {\n        fixed[name] = value.map(i => {\n          if (typeof i === 'object' && i.toJSON) {\n            return i.toJSON(null, inputs)\n          } else {\n            return i\n          }\n        })\n      } else if (typeof value === 'object' && value.toJSON) {\n        fixed[name] = value.toJSON(null, inputs)\n      } else if (name === 'source') {\n        let inputId = inputs.get(value.input)\n        if (inputId == null) {\n          inputId = inputsNextIndex\n          inputs.set(value.input, inputsNextIndex)\n          inputsNextIndex++\n        }\n        fixed[name] = {\n          end: value.end,\n          inputId,\n          start: value.start\n        }\n      } else {\n        fixed[name] = value\n      }\n    }\n\n    if (emitInputs) {\n      fixed.inputs = [...inputs.keys()].map(input => input.toJSON())\n    }\n\n    return fixed\n  }\n\n  toProxy() {\n    if (!this.proxyCache) {\n      this.proxyCache = new Proxy(this, this.getProxyProcessor())\n    }\n    return this.proxyCache\n  }\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  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  get proxyOf() {\n    return this\n  }\n}\n\nmodule.exports = Node\nNode.default = Node\n","'use strict'\n\nlet Stringifier = require('./stringifier')\n\nfunction stringify(node, builder) {\n  let str = new Stringifier(builder)\n  str.stringify(node)\n}\n\nmodule.exports = stringify\nstringify.default = stringify\n","'use strict'\n\nlet { SourceMapConsumer, SourceMapGenerator } = require('source-map-js')\nlet { fileURLToPath, pathToFileURL } = require('url')\nlet { isAbsolute, resolve } = require('path')\nlet { nanoid } = require('nanoid/non-secure')\n\nlet terminalHighlight = require('./terminal-highlight')\nlet CssSyntaxError = require('./css-syntax-error')\nlet PreviousMap = require('./previous-map')\n\nlet fromOffsetCache = Symbol('fromOffsetCache')\n\nlet sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator)\nlet pathAvailable = Boolean(resolve && isAbsolute)\n\nclass Input {\n  constructor(css, opts = {}) {\n    if (\n      css === null ||\n      typeof css === 'undefined' ||\n      (typeof css === 'object' && !css.toString)\n    ) {\n      throw new Error(`PostCSS received ${css} instead of CSS string`)\n    }\n\n    this.css = css.toString()\n\n    if (this.css[0] === '\\uFEFF' || this.css[0] === '\\uFFFE') {\n      this.hasBOM = true\n      this.css = this.css.slice(1)\n    } else {\n      this.hasBOM = false\n    }\n\n    if (opts.from) {\n      if (\n        !pathAvailable ||\n        /^\\w+:\\/\\//.test(opts.from) ||\n        isAbsolute(opts.from)\n      ) {\n        this.file = opts.from\n      } else {\n        this.file = resolve(opts.from)\n      }\n    }\n\n    if (pathAvailable && sourceMapAvailable) {\n      let map = new PreviousMap(this.css, opts)\n      if (map.text) {\n        this.map = map\n        let file = map.consumer().file\n        if (!this.file && file) this.file = this.mapResolve(file)\n      }\n    }\n\n    if (!this.file) {\n      this.id = '<input css ' + nanoid(6) + '>'\n    }\n    if (this.map) this.map.file = this.from\n  }\n\n  error(message, line, column, opts = {}) {\n    let result, endLine, endColumn\n\n    if (line && typeof line === 'object') {\n      let start = line\n      let end = column\n      if (typeof start.offset === 'number') {\n        let pos = this.fromOffset(start.offset)\n        line = pos.line\n        column = pos.col\n      } else {\n        line = start.line\n        column = start.column\n      }\n      if (typeof end.offset === 'number') {\n        let pos = this.fromOffset(end.offset)\n        endLine = pos.line\n        endColumn = pos.col\n      } else {\n        endLine = end.line\n        endColumn = end.column\n      }\n    } else if (!column) {\n      let pos = this.fromOffset(line)\n      line = pos.line\n      column = pos.col\n    }\n\n    let origin = this.origin(line, column, endLine, endColumn)\n    if (origin) {\n      result = new CssSyntaxError(\n        message,\n        origin.endLine === undefined\n          ? origin.line\n          : { column: origin.column, line: origin.line },\n        origin.endLine === undefined\n          ? origin.column\n          : { column: origin.endColumn, line: origin.endLine },\n        origin.source,\n        origin.file,\n        opts.plugin\n      )\n    } else {\n      result = new CssSyntaxError(\n        message,\n        endLine === undefined ? line : { column, line },\n        endLine === undefined ? column : { column: endColumn, line: endLine },\n        this.css,\n        this.file,\n        opts.plugin\n      )\n    }\n\n    result.input = { column, endColumn, endLine, line, source: this.css }\n    if (this.file) {\n      if (pathToFileURL) {\n        result.input.url = pathToFileURL(this.file).toString()\n      }\n      result.input.file = this.file\n    }\n\n    return result\n  }\n\n  fromOffset(offset) {\n    let lastLine, lineToIndex\n    if (!this[fromOffsetCache]) {\n      let lines = this.css.split('\\n')\n      lineToIndex = new Array(lines.length)\n      let prevIndex = 0\n\n      for (let i = 0, l = lines.length; i < l; i++) {\n        lineToIndex[i] = prevIndex\n        prevIndex += lines[i].length + 1\n      }\n\n      this[fromOffsetCache] = lineToIndex\n    } else {\n      lineToIndex = this[fromOffsetCache]\n    }\n    lastLine = lineToIndex[lineToIndex.length - 1]\n\n    let min = 0\n    if (offset >= lastLine) {\n      min = lineToIndex.length - 1\n    } else {\n      let max = lineToIndex.length - 2\n      let mid\n      while (min < max) {\n        mid = min + ((max - min) >> 1)\n        if (offset < lineToIndex[mid]) {\n          max = mid - 1\n        } else if (offset >= lineToIndex[mid + 1]) {\n          min = mid + 1\n        } else {\n          min = mid\n          break\n        }\n      }\n    }\n    return {\n      col: offset - lineToIndex[min] + 1,\n      line: min + 1\n    }\n  }\n\n  mapResolve(file) {\n    if (/^\\w+:\\/\\//.test(file)) {\n      return file\n    }\n    return resolve(this.map.consumer().sourceRoot || this.map.root || '.', file)\n  }\n\n  origin(line, column, endLine, endColumn) {\n    if (!this.map) return false\n    let consumer = this.map.consumer()\n\n    let from = consumer.originalPositionFor({ column, line })\n    if (!from.source) return false\n\n    let to\n    if (typeof endLine === 'number') {\n      to = consumer.originalPositionFor({ column: endColumn, line: endLine })\n    }\n\n    let fromUrl\n\n    if (isAbsolute(from.source)) {\n      fromUrl = pathToFileURL(from.source)\n    } else {\n      fromUrl = new URL(\n        from.source,\n        this.map.consumer().sourceRoot || pathToFileURL(this.map.mapFile)\n      )\n    }\n\n    let result = {\n      column: from.column,\n      endColumn: to && to.column,\n      endLine: to && to.line,\n      line: from.line,\n      url: fromUrl.toString()\n    }\n\n    if (fromUrl.protocol === 'file:') {\n      if (fileURLToPath) {\n        result.file = fileURLToPath(fromUrl)\n      } else {\n        /* c8 ignore next 2 */\n        throw new Error(`file: protocol is not available in this PostCSS build`)\n      }\n    }\n\n    let source = consumer.sourceContentFor(from.source)\n    if (source) result.source = source\n\n    return result\n  }\n\n  toJSON() {\n    let json = {}\n    for (let name of ['hasBOM', 'css', 'file', 'id']) {\n      if (this[name] != null) {\n        json[name] = this[name]\n      }\n    }\n    if (this.map) {\n      json.map = { ...this.map }\n      if (json.map.consumerCache) {\n        json.map.consumerCache = undefined\n      }\n    }\n    return json\n  }\n\n  get from() {\n    return this.file || this.id\n  }\n}\n\nmodule.exports = Input\nInput.default = Input\n\nif (terminalHighlight && terminalHighlight.registerInput) {\n  terminalHighlight.registerInput(Input)\n}\n","'use strict'\n\nlet Node = require('./node')\n\nclass Comment extends Node {\n  constructor(defaults) {\n    super(defaults)\n    this.type = 'comment'\n  }\n}\n\nmodule.exports = Comment\nComment.default = Comment\n","import Node from './node'\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 */\nclass Declaration extends Node {\n  constructor (defaults) {\n    super(defaults)\n    this.type = 'decl'\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\nexport default Declaration\n","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    }\n    return new CssSyntaxError(message)\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","import Stringifier from './stringifier'\n\nfunction stringify (node, builder) {\n  let str = new Stringifier(builder)\n  str.stringify(node)\n}\n\nexport default stringify\n","// .dirname, .basename, and .extname methods are extracted from Node.js v8.11.1,\n// backported and transplited with Babel, with backwards-compat fixes\n\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// resolves . and .. elements in a path array with directory names there\n// must be no slashes, empty elements, or device names (c:\\) in the array\n// (so also no leading and trailing slashes - it does not distinguish\n// relative and absolute paths)\nfunction normalizeArray(parts, allowAboveRoot) {\n  // if the path tries to go above the root, `up` ends up > 0\n  var up = 0;\n  for (var i = parts.length - 1; i >= 0; i--) {\n    var last = parts[i];\n    if (last === '.') {\n      parts.splice(i, 1);\n    } else if (last === '..') {\n      parts.splice(i, 1);\n      up++;\n    } else if (up) {\n      parts.splice(i, 1);\n      up--;\n    }\n  }\n\n  // if the path is allowed to go above the root, restore leading ..s\n  if (allowAboveRoot) {\n    for (; up--; up) {\n      parts.unshift('..');\n    }\n  }\n\n  return parts;\n}\n\n// path.resolve([from ...], to)\n// posix version\nexports.resolve = function() {\n  var resolvedPath = '',\n      resolvedAbsolute = false;\n\n  for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n    var path = (i >= 0) ? arguments[i] : process.cwd();\n\n    // Skip empty and invalid entries\n    if (typeof path !== 'string') {\n      throw new TypeError('Arguments to path.resolve must be strings');\n    } else if (!path) {\n      continue;\n    }\n\n    resolvedPath = path + '/' + resolvedPath;\n    resolvedAbsolute = path.charAt(0) === '/';\n  }\n\n  // At this point the path should be resolved to a full absolute path, but\n  // handle relative paths to be safe (might happen when process.cwd() fails)\n\n  // Normalize the path\n  resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {\n    return !!p;\n  }), !resolvedAbsolute).join('/');\n\n  return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';\n};\n\n// path.normalize(path)\n// posix version\nexports.normalize = function(path) {\n  var isAbsolute = exports.isAbsolute(path),\n      trailingSlash = substr(path, -1) === '/';\n\n  // Normalize the path\n  path = normalizeArray(filter(path.split('/'), function(p) {\n    return !!p;\n  }), !isAbsolute).join('/');\n\n  if (!path && !isAbsolute) {\n    path = '.';\n  }\n  if (path && trailingSlash) {\n    path += '/';\n  }\n\n  return (isAbsolute ? '/' : '') + path;\n};\n\n// posix version\nexports.isAbsolute = function(path) {\n  return path.charAt(0) === '/';\n};\n\n// posix version\nexports.join = function() {\n  var paths = Array.prototype.slice.call(arguments, 0);\n  return exports.normalize(filter(paths, function(p, index) {\n    if (typeof p !== 'string') {\n      throw new TypeError('Arguments to path.join must be strings');\n    }\n    return p;\n  }).join('/'));\n};\n\n\n// path.relative(from, to)\n// posix version\nexports.relative = function(from, to) {\n  from = exports.resolve(from).substr(1);\n  to = exports.resolve(to).substr(1);\n\n  function trim(arr) {\n    var start = 0;\n    for (; start < arr.length; start++) {\n      if (arr[start] !== '') break;\n    }\n\n    var end = arr.length - 1;\n    for (; end >= 0; end--) {\n      if (arr[end] !== '') break;\n    }\n\n    if (start > end) return [];\n    return arr.slice(start, end - start + 1);\n  }\n\n  var fromParts = trim(from.split('/'));\n  var toParts = trim(to.split('/'));\n\n  var length = Math.min(fromParts.length, toParts.length);\n  var samePartsLength = length;\n  for (var i = 0; i < length; i++) {\n    if (fromParts[i] !== toParts[i]) {\n      samePartsLength = i;\n      break;\n    }\n  }\n\n  var outputParts = [];\n  for (var i = samePartsLength; i < fromParts.length; i++) {\n    outputParts.push('..');\n  }\n\n  outputParts = outputParts.concat(toParts.slice(samePartsLength));\n\n  return outputParts.join('/');\n};\n\nexports.sep = '/';\nexports.delimiter = ':';\n\nexports.dirname = function (path) {\n  if (typeof path !== 'string') path = path + '';\n  if (path.length === 0) return '.';\n  var code = path.charCodeAt(0);\n  var hasRoot = code === 47 /*/*/;\n  var end = -1;\n  var matchedSlash = true;\n  for (var i = path.length - 1; i >= 1; --i) {\n    code = path.charCodeAt(i);\n    if (code === 47 /*/*/) {\n        if (!matchedSlash) {\n          end = i;\n          break;\n        }\n      } else {\n      // We saw the first non-path separator\n      matchedSlash = false;\n    }\n  }\n\n  if (end === -1) return hasRoot ? '/' : '.';\n  if (hasRoot && end === 1) {\n    // return '//';\n    // Backwards-compat fix:\n    return '/';\n  }\n  return path.slice(0, end);\n};\n\nfunction basename(path) {\n  if (typeof path !== 'string') path = path + '';\n\n  var start = 0;\n  var end = -1;\n  var matchedSlash = true;\n  var i;\n\n  for (i = path.length - 1; i >= 0; --i) {\n    if (path.charCodeAt(i) === 47 /*/*/) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          start = i + 1;\n          break;\n        }\n      } else if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // path component\n      matchedSlash = false;\n      end = i + 1;\n    }\n  }\n\n  if (end === -1) return '';\n  return path.slice(start, end);\n}\n\n// Uses a mixed approach for backwards-compatibility, as ext behavior changed\n// in new Node.js versions, so only basename() above is backported here\nexports.basename = function (path, ext) {\n  var f = basename(path);\n  if (ext && f.substr(-1 * ext.length) === ext) {\n    f = f.substr(0, f.length - ext.length);\n  }\n  return f;\n};\n\nexports.extname = function (path) {\n  if (typeof path !== 'string') path = path + '';\n  var startDot = -1;\n  var startPart = 0;\n  var end = -1;\n  var matchedSlash = true;\n  // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find\n  var preDotState = 0;\n  for (var i = path.length - 1; i >= 0; --i) {\n    var code = path.charCodeAt(i);\n    if (code === 47 /*/*/) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          startPart = i + 1;\n          break;\n        }\n        continue;\n      }\n    if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension\n      matchedSlash = false;\n      end = i + 1;\n    }\n    if (code === 46 /*.*/) {\n        // If this is our first dot, mark it as the start of our extension\n        if (startDot === -1)\n          startDot = i;\n        else if (preDotState !== 1)\n          preDotState = 1;\n    } else if (startDot !== -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension\n      preDotState = -1;\n    }\n  }\n\n  if (startDot === -1 || end === -1 ||\n      // We saw a non-dot character immediately before the dot\n      preDotState === 0 ||\n      // The (right-most) trimmed path component is exactly '..'\n      preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n    return '';\n  }\n  return path.slice(startDot, end);\n};\n\nfunction filter (xs, f) {\n    if (xs.filter) return xs.filter(f);\n    var res = [];\n    for (var i = 0; i < xs.length; i++) {\n        if (f(xs[i], i, xs)) res.push(xs[i]);\n    }\n    return res;\n}\n\n// String.prototype.substr - negative index don't work in IE8\nvar substr = 'ab'.substr(-1) === 'b'\n    ? function (str, start, len) { return str.substr(start, len) }\n    : function (str, start, len) {\n        if (start < 0) start = str.length + start;\n        return str.substr(start, len);\n    }\n;\n","import Parser from './parser'\nimport Input from './input'\n\nfunction parse (css, opts) {\n  let input = new Input(css, opts)\n  let parser = new Parser(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 ' +\n                       'the standard CSS parser; ' +\n                       'try again with the postcss-scss parser'\n        } else if (/\\.sass/i.test(opts.from)) {\n          e.message += '\\nYou tried to parse Sass with ' +\n                       'the standard CSS parser; ' +\n                       'try again with the postcss-sass parser'\n        } else if (/\\.less$/i.test(opts.from)) {\n          e.message += '\\nYou tried to parse Less with ' +\n                       'the standard CSS parser; ' +\n                       'try again with the postcss-less parser'\n        }\n      }\n    }\n    throw e\n  }\n\n  return parser.root\n}\n\nexport default parse\n","import Node from './node'\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 */\nclass Comment extends Node {\n  constructor (defaults) {\n    super(defaults)\n    this.type = 'comment'\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\nexport default Comment\n","import Container from './container'\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 */\nclass AtRule extends Container {\n  constructor (defaults) {\n    super(defaults)\n    this.type = 'atrule'\n  }\n\n  append (...children) {\n    if (!this.nodes) this.nodes = []\n    return super.append(...children)\n  }\n\n  prepend (...children) {\n    if (!this.nodes) this.nodes = []\n    return super.prepend(...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\nexport default AtRule\n","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    }\n    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    }\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   * 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    }\n    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    }\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   * 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    }\n    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    }\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   * 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    }\n    return this.nodes.indexOf(child)\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","import Container from './container'\nimport list from './list'\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 */\nclass Rule extends Container {\n  constructor (defaults) {\n    super(defaults)\n    this.type = 'rule'\n    if (!this.nodes) this.nodes = []\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  get selectors () {\n    return list.comma(this.selector)\n  }\n\n  set selectors (values) {\n    let match = this.selector ? this.selector.match(/,\\s*/) : null\n    let 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\nexport default Rule\n","'use strict'\n\nlet pico = require('picocolors')\n\nlet terminalHighlight = require('./terminal-highlight')\n\nclass CssSyntaxError extends Error {\n  constructor(message, line, column, source, file, plugin) {\n    super(message)\n    this.name = 'CssSyntaxError'\n    this.reason = message\n\n    if (file) {\n      this.file = file\n    }\n    if (source) {\n      this.source = source\n    }\n    if (plugin) {\n      this.plugin = plugin\n    }\n    if (typeof line !== 'undefined' && typeof column !== 'undefined') {\n      if (typeof line === 'number') {\n        this.line = line\n        this.column = column\n      } else {\n        this.line = line.line\n        this.column = line.column\n        this.endLine = column.line\n        this.endColumn = column.column\n      }\n    }\n\n    this.setMessage()\n\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, CssSyntaxError)\n    }\n  }\n\n  setMessage() {\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  showSourceCode(color) {\n    if (!this.source) return ''\n\n    let css = this.source\n    if (color == null) color = pico.isColorSupported\n    if (terminalHighlight) {\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    let mark, aside\n    if (color) {\n      let { bold, gray, red } = pico.createColors(true)\n      mark = text => bold(red(text))\n      aside = text => gray(text)\n    } else {\n      mark = aside = str => str\n    }\n\n    return lines\n      .slice(start, end)\n      .map((line, index) => {\n        let number = start + 1 + index\n        let gutter = ' ' + (' ' + number).slice(-maxWidth) + ' | '\n        if (number === this.line) {\n          let spacing =\n            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        }\n        return ' ' + aside(gutter) + line\n      })\n      .join('\\n')\n  }\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\nmodule.exports = CssSyntaxError\nCssSyntaxError.default = CssSyntaxError\n","'use strict'\n\nmodule.exports.isClean = Symbol('isClean')\n\nmodule.exports.my = Symbol('my')\n","'use strict'\n\nlet Container = require('./container')\n\nlet LazyResult, Processor\n\nclass Document extends Container {\n  constructor(defaults) {\n    // type needs to be passed to super, otherwise child roots won't be normalized correctly\n    super({ type: 'document', ...defaults })\n\n    if (!this.nodes) {\n      this.nodes = []\n    }\n  }\n\n  toResult(opts = {}) {\n    let lazy = new LazyResult(new Processor(), this, opts)\n\n    return lazy.stringify()\n  }\n}\n\nDocument.registerLazyResult = dependant => {\n  LazyResult = dependant\n}\n\nDocument.registerProcessor = dependant => {\n  Processor = dependant\n}\n\nmodule.exports = Document\nDocument.default = Document\n","'use strict'\n\nlet Warning = require('./warning')\n\nclass Result {\n  constructor(processor, root, opts) {\n    this.processor = processor\n    this.messages = []\n    this.root = root\n    this.opts = opts\n    this.css = undefined\n    this.map = undefined\n  }\n\n  toString() {\n    return this.css\n  }\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  warnings() {\n    return this.messages.filter(i => i.type === 'warning')\n  }\n\n  get content() {\n    return this.css\n  }\n}\n\nmodule.exports = Result\nResult.default = Result\n","'use strict'\n\nlet Container = require('./container')\nlet Parser = require('./parser')\nlet Input = require('./input')\n\nfunction parse(css, opts) {\n  let input = new Input(css, opts)\n  let parser = new Parser(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 +=\n            '\\nYou tried to parse SCSS with ' +\n            'the standard CSS parser; ' +\n            'try again with the postcss-scss parser'\n        } else if (/\\.sass/i.test(opts.from)) {\n          e.message +=\n            '\\nYou tried to parse Sass with ' +\n            'the standard CSS parser; ' +\n            'try again with the postcss-sass parser'\n        } else if (/\\.less$/i.test(opts.from)) {\n          e.message +=\n            '\\nYou tried to parse Less with ' +\n            'the standard CSS parser; ' +\n            'try again with the postcss-less parser'\n        }\n      }\n    }\n    throw e\n  }\n\n  return parser.root\n}\n\nmodule.exports = parse\nparse.default = parse\n\nContainer.registerParse(parse)\n","'use strict'\n\nlet Container = require('./container')\n\nclass AtRule extends Container {\n  constructor(defaults) {\n    super(defaults)\n    this.type = 'atrule'\n  }\n\n  append(...children) {\n    if (!this.proxyOf.nodes) this.nodes = []\n    return super.append(...children)\n  }\n\n  prepend(...children) {\n    if (!this.proxyOf.nodes) this.nodes = []\n    return super.prepend(...children)\n  }\n}\n\nmodule.exports = AtRule\nAtRule.default = AtRule\n\nContainer.registerAtRule(AtRule)\n","'use strict'\n\nlet Container = require('./container')\nlet list = require('./list')\n\nclass Rule extends Container {\n  constructor(defaults) {\n    super(defaults)\n    this.type = 'rule'\n    if (!this.nodes) this.nodes = []\n  }\n\n  get selectors() {\n    return list.comma(this.selector)\n  }\n\n  set selectors(values) {\n    let match = this.selector ? this.selector.match(/,\\s*/) : null\n    let sep = match ? match[0] : ',' + this.raw('between', 'beforeOpen')\n    this.selector = values.join(sep)\n  }\n}\n\nmodule.exports = Rule\nRule.default = Rule\n\nContainer.registerRule(Rule)\n","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 extends Error {\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    super(message)\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  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      }\n      return text\n    }\n    function aside (text) {\n      if (color && chalk.gray) {\n        return chalk.gray(text)\n      }\n      return text\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      }\n      return ' ' + aside(gutter) + line\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","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  semicolon: false\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    }\n\n    return value\n  }\n}\n\nexport default Stringifier\n","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.32'\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 does 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","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([autoprefixer]).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([autoprefixer]).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([autoprefixer]).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([autoprefixer]).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 * 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","// 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","/**\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 */\nlet list = {\n\n  split (string, separators, last) {\n    let array = []\n    let current = ''\n    let split = false\n\n    let func = 0\n    let quote = false\n    let escape = false\n\n    for (let i = 0; i < string.length; i++) {\n      let 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   * 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 (string) {\n    let spaces = [' ', '\\n', '\\t']\n    return list.split(string, spaces)\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 (string) {\n    return list.split(string, [','], true)\n  }\n\n}\n\nexport default list\n","import Container from './container'\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 */\nclass Root extends Container {\n  constructor (defaults) {\n    super(defaults)\n    this.type = 'root'\n    if (!this.nodes) this.nodes = []\n  }\n\n  removeChild (child, ignore) {\n    let 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 super.removeChild(child)\n  }\n\n  normalize (child, sample, type) {\n    let nodes = super.normalize(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 (let node of nodes) {\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  toResult (opts = { }) {\n    let LazyResult = require('./lazy-result')\n    let Processor = require('./processor')\n\n    let 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\nexport default Root\n","'use strict'\n\nconst DEFAULT_RAW = {\n  after: '\\n',\n  beforeClose: '\\n',\n  beforeComment: '\\n',\n  beforeDecl: '\\n',\n  beforeOpen: ' ',\n  beforeRule: '\\n',\n  colon: ': ',\n  commentLeft: ' ',\n  commentRight: ' ',\n  emptyBody: '',\n  indent: '    ',\n  semicolon: false\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  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  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.includes('\\n')) {\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  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  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  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  document(node) {\n    this.body(node)\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    if (detect === 'before') {\n      // Hack for first rule in CSS\n      if (!parent || (parent.type === 'root' && parent.first === node)) {\n        return ''\n      }\n\n      // `root` nodes in `document` should use only their own raws\n      if (parent && parent.type === 'document') {\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  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.includes('\\n')) {\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  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.includes('\\n')) {\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.includes('\\n')) {\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  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  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.includes('\\n')) {\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  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  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  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  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    }\n\n    return value\n  }\n\n  root(node) {\n    this.body(node)\n    if (node.raws.after) this.builder(node.raws.after)\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  stringify(node, semicolon) {\n    /* c8 ignore start */\n    if (!this[node.type]) {\n      throw new Error(\n        'Unknown AST node type ' +\n          node.type +\n          '. ' +\n          'Maybe you need to change PostCSS stringifier.'\n      )\n    }\n    /* c8 ignore stop */\n    this[node.type](node, semicolon)\n  }\n}\n\nmodule.exports = Stringifier\nStringifier.default = Stringifier\n","'use strict'\n\nlet { isClean, my } = require('./symbols')\nlet MapGenerator = require('./map-generator')\nlet stringify = require('./stringify')\nlet Container = require('./container')\nlet Document = require('./document')\nlet warnOnce = require('./warn-once')\nlet Result = require('./result')\nlet parse = require('./parse')\nlet Root = require('./root')\n\nconst TYPE_TO_CLASS_NAME = {\n  atrule: 'AtRule',\n  comment: 'Comment',\n  decl: 'Declaration',\n  document: 'Document',\n  root: 'Root',\n  rule: 'Rule'\n}\n\nconst PLUGIN_PROPS = {\n  AtRule: true,\n  AtRuleExit: true,\n  Comment: true,\n  CommentExit: true,\n  Declaration: true,\n  DeclarationExit: true,\n  Document: true,\n  DocumentExit: true,\n  Once: true,\n  OnceExit: true,\n  postcssPlugin: true,\n  prepare: true,\n  Root: true,\n  RootExit: true,\n  Rule: true,\n  RuleExit: true\n}\n\nconst NOT_VISITORS = {\n  Once: true,\n  postcssPlugin: true,\n  prepare: true\n}\n\nconst CHILDREN = 0\n\nfunction isPromise(obj) {\n  return typeof obj === 'object' && typeof obj.then === 'function'\n}\n\nfunction getEvents(node) {\n  let key = false\n  let type = TYPE_TO_CLASS_NAME[node.type]\n  if (node.type === 'decl') {\n    key = node.prop.toLowerCase()\n  } else if (node.type === 'atrule') {\n    key = node.name.toLowerCase()\n  }\n\n  if (key && node.append) {\n    return [\n      type,\n      type + '-' + key,\n      CHILDREN,\n      type + 'Exit',\n      type + 'Exit-' + key\n    ]\n  } else if (key) {\n    return [type, type + '-' + key, type + 'Exit', type + 'Exit-' + key]\n  } else if (node.append) {\n    return [type, CHILDREN, type + 'Exit']\n  } else {\n    return [type, type + 'Exit']\n  }\n}\n\nfunction toStack(node) {\n  let events\n  if (node.type === 'document') {\n    events = ['Document', CHILDREN, 'DocumentExit']\n  } else if (node.type === 'root') {\n    events = ['Root', CHILDREN, 'RootExit']\n  } else {\n    events = getEvents(node)\n  }\n\n  return {\n    eventIndex: 0,\n    events,\n    iterator: 0,\n    node,\n    visitorIndex: 0,\n    visitors: []\n  }\n}\n\nfunction cleanMarks(node) {\n  node[isClean] = false\n  if (node.nodes) node.nodes.forEach(i => cleanMarks(i))\n  return node\n}\n\nlet postcss = {}\n\nclass LazyResult {\n  constructor(processor, css, opts) {\n    this.stringified = false\n    this.processed = false\n\n    let root\n    if (\n      typeof css === 'object' &&\n      css !== null &&\n      (css.type === 'root' || css.type === 'document')\n    ) {\n      root = cleanMarks(css)\n    } else if (css instanceof LazyResult || css instanceof Result) {\n      root = cleanMarks(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.processed = true\n        this.error = error\n      }\n\n      if (root && !root[my]) {\n        /* c8 ignore next 2 */\n        Container.rebuild(root)\n      }\n    }\n\n    this.result = new Result(processor, root, opts)\n    this.helpers = { ...postcss, postcss, result: this.result }\n    this.plugins = this.processor.plugins.map(plugin => {\n      if (typeof plugin === 'object' && plugin.prepare) {\n        return { ...plugin, ...plugin.prepare(this.result) }\n      } else {\n        return plugin\n      }\n    })\n  }\n\n  async() {\n    if (this.error) return Promise.reject(this.error)\n    if (this.processed) return Promise.resolve(this.result)\n    if (!this.processing) {\n      this.processing = this.runAsync()\n    }\n    return this.processing\n  }\n\n  catch(onRejected) {\n    return this.async().catch(onRejected)\n  }\n\n  finally(onFinally) {\n    return this.async().then(onFinally, onFinally)\n  }\n\n  getAsyncError() {\n    throw new Error('Use process(css).then(cb) to work with async plugins')\n  }\n\n  handleError(error, node) {\n    let plugin = this.result.lastPlugin\n    try {\n      if (node) node.addToError(error)\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            // eslint-disable-next-line no-console\n            console.error(\n              'Unknown error from PostCSS plugin. Your current PostCSS ' +\n                'version is ' +\n                runtimeVer +\n                ', but ' +\n                pluginName +\n                ' uses ' +\n                pluginVer +\n                '. Perhaps this is the source of the error below.'\n            )\n          }\n        }\n      }\n    } catch (err) {\n      /* c8 ignore next 3 */\n      // eslint-disable-next-line no-console\n      if (console && console.error) console.error(err)\n    }\n    return error\n  }\n\n  prepareVisitors() {\n    this.listeners = {}\n    let add = (plugin, type, cb) => {\n      if (!this.listeners[type]) this.listeners[type] = []\n      this.listeners[type].push([plugin, cb])\n    }\n    for (let plugin of this.plugins) {\n      if (typeof plugin === 'object') {\n        for (let event in plugin) {\n          if (!PLUGIN_PROPS[event] && /^[A-Z]/.test(event)) {\n            throw new Error(\n              `Unknown event ${event} in ${plugin.postcssPlugin}. ` +\n                `Try to update PostCSS (${this.processor.version} now).`\n            )\n          }\n          if (!NOT_VISITORS[event]) {\n            if (typeof plugin[event] === 'object') {\n              for (let filter in plugin[event]) {\n                if (filter === '*') {\n                  add(plugin, event, plugin[event][filter])\n                } else {\n                  add(\n                    plugin,\n                    event + '-' + filter.toLowerCase(),\n                    plugin[event][filter]\n                  )\n                }\n              }\n            } else if (typeof plugin[event] === 'function') {\n              add(plugin, event, plugin[event])\n            }\n          }\n        }\n      }\n    }\n    this.hasListener = Object.keys(this.listeners).length > 0\n  }\n\n  async runAsync() {\n    this.plugin = 0\n    for (let i = 0; i < this.plugins.length; i++) {\n      let plugin = this.plugins[i]\n      let promise = this.runOnRoot(plugin)\n      if (isPromise(promise)) {\n        try {\n          await promise\n        } catch (error) {\n          throw this.handleError(error)\n        }\n      }\n    }\n\n    this.prepareVisitors()\n    if (this.hasListener) {\n      let root = this.result.root\n      while (!root[isClean]) {\n        root[isClean] = true\n        let stack = [toStack(root)]\n        while (stack.length > 0) {\n          let promise = this.visitTick(stack)\n          if (isPromise(promise)) {\n            try {\n              await promise\n            } catch (e) {\n              let node = stack[stack.length - 1].node\n              throw this.handleError(e, node)\n            }\n          }\n        }\n      }\n\n      if (this.listeners.OnceExit) {\n        for (let [plugin, visitor] of this.listeners.OnceExit) {\n          this.result.lastPlugin = plugin\n          try {\n            if (root.type === 'document') {\n              let roots = root.nodes.map(subRoot =>\n                visitor(subRoot, this.helpers)\n              )\n\n              await Promise.all(roots)\n            } else {\n              await visitor(root, this.helpers)\n            }\n          } catch (e) {\n            throw this.handleError(e)\n          }\n        }\n      }\n    }\n\n    this.processed = true\n    return this.stringify()\n  }\n\n  runOnRoot(plugin) {\n    this.result.lastPlugin = plugin\n    try {\n      if (typeof plugin === 'object' && plugin.Once) {\n        if (this.result.root.type === 'document') {\n          let roots = this.result.root.nodes.map(root =>\n            plugin.Once(root, this.helpers)\n          )\n\n          if (isPromise(roots[0])) {\n            return Promise.all(roots)\n          }\n\n          return roots\n        }\n\n        return plugin.Once(this.result.root, this.helpers)\n      } else if (typeof plugin === 'function') {\n        return plugin(this.result.root, this.result)\n      }\n    } catch (error) {\n      throw this.handleError(error)\n    }\n  }\n\n  stringify() {\n    if (this.error) throw this.error\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  sync() {\n    if (this.error) throw this.error\n    if (this.processed) return this.result\n    this.processed = true\n\n    if (this.processing) {\n      throw this.getAsyncError()\n    }\n\n    for (let plugin of this.plugins) {\n      let promise = this.runOnRoot(plugin)\n      if (isPromise(promise)) {\n        throw this.getAsyncError()\n      }\n    }\n\n    this.prepareVisitors()\n    if (this.hasListener) {\n      let root = this.result.root\n      while (!root[isClean]) {\n        root[isClean] = true\n        this.walkSync(root)\n      }\n      if (this.listeners.OnceExit) {\n        if (root.type === 'document') {\n          for (let subRoot of root.nodes) {\n            this.visitSync(this.listeners.OnceExit, subRoot)\n          }\n        } else {\n          this.visitSync(this.listeners.OnceExit, root)\n        }\n      }\n    }\n\n    return this.result\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  toString() {\n    return this.css\n  }\n\n  visitSync(visitors, node) {\n    for (let [plugin, visitor] of visitors) {\n      this.result.lastPlugin = plugin\n      let promise\n      try {\n        promise = visitor(node, this.helpers)\n      } catch (e) {\n        throw this.handleError(e, node.proxyOf)\n      }\n      if (node.type !== 'root' && node.type !== 'document' && !node.parent) {\n        return true\n      }\n      if (isPromise(promise)) {\n        throw this.getAsyncError()\n      }\n    }\n  }\n\n  visitTick(stack) {\n    let visit = stack[stack.length - 1]\n    let { node, visitors } = visit\n\n    if (node.type !== 'root' && node.type !== 'document' && !node.parent) {\n      stack.pop()\n      return\n    }\n\n    if (visitors.length > 0 && visit.visitorIndex < visitors.length) {\n      let [plugin, visitor] = visitors[visit.visitorIndex]\n      visit.visitorIndex += 1\n      if (visit.visitorIndex === visitors.length) {\n        visit.visitors = []\n        visit.visitorIndex = 0\n      }\n      this.result.lastPlugin = plugin\n      try {\n        return visitor(node.toProxy(), this.helpers)\n      } catch (e) {\n        throw this.handleError(e, node)\n      }\n    }\n\n    if (visit.iterator !== 0) {\n      let iterator = visit.iterator\n      let child\n      while ((child = node.nodes[node.indexes[iterator]])) {\n        node.indexes[iterator] += 1\n        if (!child[isClean]) {\n          child[isClean] = true\n          stack.push(toStack(child))\n          return\n        }\n      }\n      visit.iterator = 0\n      delete node.indexes[iterator]\n    }\n\n    let events = visit.events\n    while (visit.eventIndex < events.length) {\n      let event = events[visit.eventIndex]\n      visit.eventIndex += 1\n      if (event === CHILDREN) {\n        if (node.nodes && node.nodes.length) {\n          node[isClean] = true\n          visit.iterator = node.getIterator()\n        }\n        return\n      } else if (this.listeners[event]) {\n        visit.visitors = this.listeners[event]\n        return\n      }\n    }\n    stack.pop()\n  }\n\n  walkSync(node) {\n    node[isClean] = true\n    let events = getEvents(node)\n    for (let event of events) {\n      if (event === CHILDREN) {\n        if (node.nodes) {\n          node.each(child => {\n            if (!child[isClean]) this.walkSync(child)\n          })\n        }\n      } else {\n        let visitors = this.listeners[event]\n        if (visitors) {\n          if (this.visitSync(visitors, node.toProxy())) return\n        }\n      }\n    }\n  }\n\n  warnings() {\n    return this.sync().warnings()\n  }\n\n  get content() {\n    return this.stringify().content\n  }\n\n  get css() {\n    return this.stringify().css\n  }\n\n  get map() {\n    return this.stringify().map\n  }\n\n  get messages() {\n    return this.sync().messages\n  }\n\n  get opts() {\n    return this.result.opts\n  }\n\n  get processor() {\n    return this.result.processor\n  }\n\n  get root() {\n    return this.sync().root\n  }\n\n  get [Symbol.toStringTag]() {\n    return 'LazyResult'\n  }\n}\n\nLazyResult.registerPostcss = dependant => {\n  postcss = dependant\n}\n\nmodule.exports = LazyResult\nLazyResult.default = LazyResult\n\nRoot.registerLazyResult(LazyResult)\nDocument.registerLazyResult(LazyResult)\n","'use strict'\n\nlet { SourceMapConsumer, SourceMapGenerator } = require('source-map-js')\nlet { dirname, relative, resolve, sep } = require('path')\nlet { pathToFileURL } = require('url')\n\nlet Input = require('./input')\n\nlet sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator)\nlet pathAvailable = Boolean(dirname && resolve && relative && sep)\n\nclass MapGenerator {\n  constructor(stringify, root, opts, cssString) {\n    this.stringify = stringify\n    this.mapOpts = opts.map || {}\n    this.root = root\n    this.opts = opts\n    this.css = cssString\n    this.usesFileUrls = !this.mapOpts.from && this.mapOpts.absolute\n\n    this.memoizedFileURLs = new Map()\n    this.memoizedPaths = new Map()\n    this.memoizedURLs = new Map()\n  }\n\n  addAnnotation() {\n    let content\n\n    if (this.isInline()) {\n      content =\n        'data:application/json;base64,' + this.toBase64(this.map.toString())\n    } else if (typeof this.mapOpts.annotation === 'string') {\n      content = this.mapOpts.annotation\n    } else if (typeof this.mapOpts.annotation === 'function') {\n      content = this.mapOpts.annotation(this.opts.to, this.root)\n    } else {\n      content = this.outputFile() + '.map'\n    }\n    let eol = '\\n'\n    if (this.css.includes('\\r\\n')) eol = '\\r\\n'\n\n    this.css += eol + '/*# sourceMappingURL=' + content + ' */'\n  }\n\n  applyPrevMaps() {\n    for (let prev of this.previous()) {\n      let from = this.toUrl(this.path(prev.file))\n      let root = prev.root || dirname(prev.file)\n      let map\n\n      if (this.mapOpts.sourcesContent === false) {\n        map = new 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.toUrl(this.path(root)))\n    }\n  }\n\n  clearAnnotation() {\n    if (this.mapOpts.annotation === false) return\n\n    if (this.root) {\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    } else if (this.css) {\n      this.css = this.css.replace(/(\\n)?\\/\\*#[\\S\\s]*?\\*\\/$/gm, '')\n    }\n  }\n\n  generate() {\n    this.clearAnnotation()\n    if (pathAvailable && sourceMapAvailable && 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  generateMap() {\n    if (this.root) {\n      this.generateString()\n    } else if (this.previous().length === 1) {\n      let prev = this.previous()[0].consumer()\n      prev.file = this.outputFile()\n      this.map = SourceMapGenerator.fromSourceMap(prev)\n    } else {\n      this.map = new SourceMapGenerator({ file: this.outputFile() })\n      this.map.addMapping({\n        generated: { column: 0, line: 1 },\n        original: { column: 0, line: 1 },\n        source: this.opts.from\n          ? this.toUrl(this.path(this.opts.from))\n          : '<no source>'\n      })\n    }\n\n    if (this.isSourcesContent()) this.setSourcesContent()\n    if (this.root && 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  generateString() {\n    this.css = ''\n    this.map = new SourceMapGenerator({ file: this.outputFile() })\n\n    let line = 1\n    let column = 1\n\n    let noSource = '<no source>'\n    let mapping = {\n      generated: { column: 0, line: 0 },\n      original: { column: 0, line: 0 },\n      source: ''\n    }\n\n    let lines, last\n    this.stringify(this.root, (str, node, type) => {\n      this.css += str\n\n      if (node && type !== 'end') {\n        mapping.generated.line = line\n        mapping.generated.column = column - 1\n        if (node.source && node.source.start) {\n          mapping.source = this.sourcePath(node)\n          mapping.original.line = node.source.start.line\n          mapping.original.column = node.source.start.column - 1\n          this.map.addMapping(mapping)\n        } else {\n          mapping.source = noSource\n          mapping.original.line = 1\n          mapping.original.column = 0\n          this.map.addMapping(mapping)\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        let p = node.parent || { raws: {} }\n        let childless =\n          node.type === 'decl' || (node.type === 'atrule' && !node.nodes)\n        if (!childless || node !== p.last || p.raws.semicolon) {\n          if (node.source && node.source.end) {\n            mapping.source = this.sourcePath(node)\n            mapping.original.line = node.source.end.line\n            mapping.original.column = node.source.end.column - 1\n            mapping.generated.line = line\n            mapping.generated.column = column - 2\n            this.map.addMapping(mapping)\n          } else {\n            mapping.source = noSource\n            mapping.original.line = 1\n            mapping.original.column = 0\n            mapping.generated.line = line\n            mapping.generated.column = column - 1\n            this.map.addMapping(mapping)\n          }\n        }\n      }\n    })\n  }\n\n  isAnnotation() {\n    if (this.isInline()) {\n      return true\n    }\n    if (typeof this.mapOpts.annotation !== 'undefined') {\n      return this.mapOpts.annotation\n    }\n    if (this.previous().length) {\n      return this.previous().some(i => i.annotation)\n    }\n    return true\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    }\n    return true\n  }\n\n  isMap() {\n    if (typeof this.opts.map !== 'undefined') {\n      return !!this.opts.map\n    }\n    return this.previous().length > 0\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    }\n    return true\n  }\n\n  outputFile() {\n    if (this.opts.to) {\n      return this.path(this.opts.to)\n    } else if (this.opts.from) {\n      return this.path(this.opts.from)\n    } else {\n      return 'to.css'\n    }\n  }\n\n  path(file) {\n    if (this.mapOpts.absolute) return file\n    if (file.charCodeAt(0) === 60 /* `<` */) return file\n    if (/^\\w+:\\/\\//.test(file)) return file\n    let cached = this.memoizedPaths.get(file)\n    if (cached) return cached\n\n    let from = this.opts.to ? dirname(this.opts.to) : '.'\n\n    if (typeof this.mapOpts.annotation === 'string') {\n      from = dirname(resolve(from, this.mapOpts.annotation))\n    }\n\n    let path = relative(from, file)\n    this.memoizedPaths.set(file, path)\n\n    return path\n  }\n\n  previous() {\n    if (!this.previousMaps) {\n      this.previousMaps = []\n      if (this.root) {\n        this.root.walk(node => {\n          if (node.source && node.source.input.map) {\n            let map = node.source.input.map\n            if (!this.previousMaps.includes(map)) {\n              this.previousMaps.push(map)\n            }\n          }\n        })\n      } else {\n        let input = new Input(this.css, this.opts)\n        if (input.map) this.previousMaps.push(input.map)\n      }\n    }\n\n    return this.previousMaps\n  }\n\n  setSourcesContent() {\n    let already = {}\n    if (this.root) {\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 fromUrl = this.usesFileUrls\n              ? this.toFileUrl(from)\n              : this.toUrl(this.path(from))\n            this.map.setSourceContent(fromUrl, node.source.input.css)\n          }\n        }\n      })\n    } else if (this.css) {\n      let from = this.opts.from\n        ? this.toUrl(this.path(this.opts.from))\n        : '<no source>'\n      this.map.setSourceContent(from, this.css)\n    }\n  }\n\n  sourcePath(node) {\n    if (this.mapOpts.from) {\n      return this.toUrl(this.mapOpts.from)\n    } else if (this.usesFileUrls) {\n      return this.toFileUrl(node.source.input.from)\n    } else {\n      return this.toUrl(this.path(node.source.input.from))\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  toFileUrl(path) {\n    let cached = this.memoizedFileURLs.get(path)\n    if (cached) return cached\n\n    if (pathToFileURL) {\n      let fileURL = pathToFileURL(path).toString()\n      this.memoizedFileURLs.set(path, fileURL)\n\n      return fileURL\n    } else {\n      throw new Error(\n        '`map.absolute` option is not available in this PostCSS build'\n      )\n    }\n  }\n\n  toUrl(path) {\n    let cached = this.memoizedURLs.get(path)\n    if (cached) return cached\n\n    if (sep === '\\\\') {\n      path = path.replace(/\\\\/g, '/')\n    }\n\n    let url = encodeURI(path).replace(/[#?]/g, encodeURIComponent)\n    this.memoizedURLs.set(path, url)\n\n    return url\n  }\n}\n\nmodule.exports = MapGenerator\n","'use strict'\n\nlet { SourceMapConsumer, SourceMapGenerator } = require('source-map-js')\nlet { existsSync, readFileSync } = require('fs')\nlet { dirname, join } = require('path')\n\nfunction fromBase64(str) {\n  if (Buffer) {\n    return Buffer.from(str, 'base64').toString()\n  } else {\n    /* c8 ignore next 2 */\n    return window.atob(str)\n  }\n}\n\nclass PreviousMap {\n  constructor(css, opts) {\n    if (opts.map === false) return\n    this.loadAnnotation(css)\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 (!this.mapFile && opts.from) {\n      this.mapFile = opts.from\n    }\n    if (this.mapFile) this.root = dirname(this.mapFile)\n    if (text) this.text = text\n  }\n\n  consumer() {\n    if (!this.consumerCache) {\n      this.consumerCache = new SourceMapConsumer(this.text)\n    }\n    return this.consumerCache\n  }\n\n  decodeInline(text) {\n    let baseCharsetUri = /^data:application\\/json;charset=utf-?8;base64,/\n    let baseUri = /^data:application\\/json;base64,/\n    let charsetUri = /^data:application\\/json;charset=utf-?8,/\n    let uri = /^data:application\\/json,/\n\n    if (charsetUri.test(text) || uri.test(text)) {\n      return decodeURIComponent(text.substr(RegExp.lastMatch.length))\n    }\n\n    if (baseCharsetUri.test(text) || baseUri.test(text)) {\n      return fromBase64(text.substr(RegExp.lastMatch.length))\n    }\n\n    let encoding = text.match(/data:application\\/json;([^,]+),/)[1]\n    throw new Error('Unsupported source map encoding ' + encoding)\n  }\n\n  getAnnotationURL(sourceMapString) {\n    return sourceMapString.replace(/^\\/\\*\\s*# sourceMappingURL=/, '').trim()\n  }\n\n  isMap(map) {\n    if (typeof map !== 'object') return false\n    return (\n      typeof map.mappings === 'string' ||\n      typeof map._mappings === 'string' ||\n      Array.isArray(map.sections)\n    )\n  }\n\n  loadAnnotation(css) {\n    let comments = css.match(/\\/\\*\\s*# sourceMappingURL=/gm)\n    if (!comments) return\n\n    // sourceMappingURLs from comments, strings, etc.\n    let start = css.lastIndexOf(comments.pop())\n    let end = css.indexOf('*/', start)\n\n    if (start > -1 && end > -1) {\n      // Locate the last sourceMappingURL to avoid pickin\n      this.annotation = this.getAnnotationURL(css.substring(start, end))\n    }\n  }\n\n  loadFile(path) {\n    this.root = dirname(path)\n    if (existsSync(path)) {\n      this.mapFile = path\n      return readFileSync(path, 'utf-8').toString().trim()\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) {\n          let map = this.loadFile(prevPath)\n          if (!map) {\n            throw new Error(\n              'Unable to load previous source map: ' + prevPath.toString()\n            )\n          }\n          return map\n        }\n      } else if (prev instanceof SourceMapConsumer) {\n        return SourceMapGenerator.fromSourceMap(prev).toString()\n      } else if (prev instanceof 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      }\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 = join(dirname(file), map)\n      return this.loadFile(map)\n    }\n  }\n\n  startWith(string, start) {\n    if (!string) return false\n    return string.substr(0, start.length) === start\n  }\n\n  withContent() {\n    return !!(\n      this.consumer().sourcesContent &&\n      this.consumer().sourcesContent.length > 0\n    )\n  }\n}\n\nmodule.exports = PreviousMap\nPreviousMap.default = PreviousMap\n","/* eslint-disable no-console */\n'use strict'\n\nlet printed = {}\n\nmodule.exports = function 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}\n","'use strict'\n\nclass Warning {\n  constructor(text, opts = {}) {\n    this.type = 'warning'\n    this.text = text\n\n    if (opts.node && opts.node.source) {\n      let range = opts.node.rangeBy(opts)\n      this.line = range.start.line\n      this.column = range.start.column\n      this.endLine = range.end.line\n      this.endColumn = range.end.column\n    }\n\n    for (let opt in opts) this[opt] = opts[opt]\n  }\n\n  toString() {\n    if (this.node) {\n      return this.node.error(this.text, {\n        index: this.index,\n        plugin: this.plugin,\n        word: this.word\n      }).message\n    }\n\n    if (this.plugin) {\n      return this.plugin + ': ' + this.text\n    }\n\n    return this.text\n  }\n}\n\nmodule.exports = Warning\nWarning.default = Warning\n","'use strict'\n\nlet list = {\n  comma(string) {\n    return list.split(string, [','], true)\n  },\n\n  space(string) {\n    let spaces = [' ', '\\n', '\\t']\n    return list.split(string, spaces)\n  },\n\n  split(string, separators, last) {\n    let array = []\n    let current = ''\n    let split = false\n\n    let func = 0\n    let inQuote = false\n    let prevQuote = ''\n    let escape = false\n\n    for (let letter of string) {\n      if (escape) {\n        escape = false\n      } else if (letter === '\\\\') {\n        escape = true\n      } else if (inQuote) {\n        if (letter === prevQuote) {\n          inQuote = false\n        }\n      } else if (letter === '\"' || letter === \"'\") {\n        inQuote = true\n        prevQuote = 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.includes(letter)) 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\nmodule.exports = list\nlist.default = list\n","\r\nvar postcssValueParser = require(\"postcss-value-parser\");\r\nvar Helpers = require(\"./Helpers\");\r\nvar ApiRequest = require(\"./ApiRequest\");\r\nvar Promise = require(\"./Promise\");\r\nvar ClientTracingConstants = require(\"./ClientTracingConstants\");\r\n\r\nvar doc = document;\r\nvar head = doc.head;\r\nvar ArrayHelpers = Helpers.Array;\r\nvar fixCustomCssRemoval = window.ServerData.fRemoveCustomCss;\r\nvar postcss;\r\n\r\n\r\nif (__IS_OLD_WEBPACK__ || __IS_MSA__ || window.ServerData.fUsePostCssHotfix)\r\n{\r\n    postcss = require(\"postcss-hotfix\");\r\n}\r\nelse\r\n{\r\n    postcss = require(\"postcss\");\r\n}\r\n\r\n\r\nfunction CustomCssLoader()\r\n{\r\n    var _this = this;\r\n\r\n    var c_AllowedCssAtRules =\r\n        [\r\n            \"font-face\",\r\n            \"media\"\r\n        ];\r\n\r\n    var c_AllowedCssSelectors =\r\n        [\r\n            \"body\",\r\n            \"a\",\r\n            \".ext-header\",\r\n            \".ext-header-logo\",\r\n            \".ext-header-description\",\r\n            \".ext-background-image\",\r\n            \".ext-background-overlay\",\r\n            \".ext-sign-in-box\",\r\n            \".ext-title\",\r\n            \".ext-subtitle\",\r\n            \".ext-button.ext-primary\",\r\n            \".ext-button.ext-secondary\",\r\n            \".ext-error\",\r\n            \".ext-input.ext-text-box\",\r\n            \".ext-input.ext-text-box.ext-has-error\",\r\n            \".ext-banner-logo\",\r\n            \".ext-password-reset-links-container\",\r\n            \".ext-button-field-container\",\r\n            \".ext-button-item\",\r\n            \".ext-boilerplate-text\",\r\n            \".ext-vertical-split-main-section\",\r\n            \".ext-vertical-split-background-image-container\",\r\n            \".ext-middle\",\r\n            \".ext-promoted-fed-cred-box\",\r\n            \".ext-footer\",\r\n            \".ext-footer.ext-has-background\",\r\n            \".ext-footer.ext-has-background.ext-background-always-visible\",\r\n            \".ext-footer-links\",\r\n            \".ext-footer-content.ext-footer-item\",\r\n            \".ext-footer-content.ext-footer-item.ext-has-background\",\r\n            \".ext-footer-content.ext-footer-item.ext-has-background.ext-background-always-visible\",\r\n            \".ext-footer-content.ext-footer-item.ext-debug-item\",\r\n            \".ext-footer-content.ext-footer-item.ext-debug-item.ext-has-background\",\r\n            \".ext-footer-content.ext-footer-item.ext-debug-item.ext-has-background.ext-background-always-visible\"\r\n        ];\r\n\r\n    var c_DisallowedCssProperties =\r\n        [\r\n            \"behavior\",\r\n            \"content\",\r\n            \"-moz-binding\",\r\n            \"-o-link\"\r\n        ];\r\n\r\n    \r\n    var c_AllowedCssCharactersRegex = /^[\\x0A\\x0D\\x20-\\x7E]*$/;\r\n    var c_AllowedCssPseudoSelectorRegex = /(:active|:focus|:focus-within|:hover|:link|:visited|:dir\\((ltr|rtl)\\))$/i;\r\n    var c_AllowedCssUrlSchemesRegex = /^https:\\/\\//i;\r\n\r\n    var _customCssNode = null;\r\n\r\n    \r\n    _this.loadAsync = function (customCssUrl)\r\n    {\r\n        return _loadInternalAsync(customCssUrl)\r\n            .then(_sanitizeCss)\r\n            .then(\r\n                function (sanitizedCss)\r\n                {\r\n                    _unload();\r\n\r\n                    _customCssNode = doc.createElement(\"style\");\r\n                    _customCssNode.type = \"text/css\";\r\n                    _customCssNode.innerHTML = sanitizedCss;\r\n                    if (fixCustomCssRemoval)\r\n                    {\r\n                        _customCssNode.id = \"customCssStyle\";\r\n                    }\r\n                    head.appendChild(_customCssNode);\r\n                });\r\n    };\r\n\r\n    function _unload()\r\n    {\r\n        if (_customCssNode)\r\n        {\r\n            head.removeChild(_customCssNode);\r\n            _customCssNode = null;\r\n        }\r\n    }\r\n\r\n    function _loadInternalAsync(customCssUrl)\r\n    {\r\n        return new Promise(\r\n            function (resolve)\r\n            {\r\n                var apiRequest = new ApiRequest({ checkApiCanary: false });\r\n                apiRequest.Get(\r\n                    {\r\n                        url: customCssUrl,\r\n                        eventId: ClientTracingConstants.EventIds.Api_GetCustomCss\r\n                    },\r\n                    null,\r\n                    function (event, customCss)\r\n                    {\r\n                        resolve(customCss);\r\n                    });\r\n            });\r\n    }\r\n\r\n    function _sanitizeCss(css)\r\n    {\r\n        var parsedCss = postcss.parse(css);\r\n        parsedCss.walk(\r\n            function (node)\r\n            {\r\n                switch (node.type)\r\n                {\r\n                    case \"atrule\":\r\n                        _sanitizeAtRule(node);\r\n                        break;\r\n\r\n                    case \"rule\":\r\n                        _sanitizeRule(node);\r\n                        break;\r\n\r\n                    case \"decl\":\r\n                        _sanitizeProperty(node);\r\n                        break;\r\n\r\n                    default:\r\n                        node.remove();\r\n                        break;\r\n                }\r\n            });\r\n\r\n        return parsedCss.toString();\r\n    }\r\n\r\n    function _sanitizeAtRule(node)\r\n    {\r\n        if (!c_AllowedCssCharactersRegex.test(node.name)\r\n            || !c_AllowedCssCharactersRegex.test(node.params)\r\n            || c_AllowedCssAtRules.indexOf(node.name.toLowerCase()) === -1)\r\n        {\r\n            node.remove();\r\n        }\r\n    }\r\n\r\n    function _sanitizeRule(node)\r\n    {\r\n        if (!c_AllowedCssCharactersRegex.test(node.selector))\r\n        {\r\n            node.remove();\r\n            return;\r\n        }\r\n\r\n        var filteredSelectors = ArrayHelpers.arrayFilter(\r\n            node.selectors,\r\n            function (selector)\r\n            {\r\n                while (c_AllowedCssPseudoSelectorRegex.test(selector))\r\n                {\r\n                    selector = selector.replace(c_AllowedCssPseudoSelectorRegex, \"\");\r\n                }\r\n\r\n                return c_AllowedCssSelectors.indexOf(selector) !== -1;\r\n            });\r\n\r\n        if (filteredSelectors.length > 0)\r\n        {\r\n            node.selectors = filteredSelectors;\r\n        }\r\n        else\r\n        {\r\n            node.remove();\r\n        }\r\n    }\r\n\r\n    function _sanitizeProperty(node)\r\n    {\r\n        if (!c_AllowedCssCharactersRegex.test(node.prop)\r\n            || c_DisallowedCssProperties.indexOf(node.prop.toLowerCase()) !== -1)\r\n        {\r\n            node.remove();\r\n            return;\r\n        }\r\n\r\n        _sanitizePropertyValue(node, node.value);\r\n    }\r\n\r\n    function _sanitizePropertyValue(node, propertyValue)\r\n    {\r\n        if (!c_AllowedCssCharactersRegex.test(propertyValue))\r\n        {\r\n            node.remove();\r\n            return;\r\n        }\r\n\r\n        var parsedNodes = postcssValueParser(propertyValue).nodes || [];\r\n\r\n        for (var i = 0, len = parsedNodes.length; i < len; ++i)\r\n        {\r\n            var parsedNode = parsedNodes[i];\r\n\r\n            if (parsedNode.type === \"function\")\r\n            {\r\n                switch (parsedNode.value.toLowerCase())\r\n                {\r\n                    case \"expression\":\r\n                        node.remove();\r\n                        return;\r\n\r\n                    case \"url\":\r\n                        if (!c_AllowedCssUrlSchemesRegex.test(parsedNode.nodes[0].value))\r\n                        {\r\n                            node.remove();\r\n                            return;\r\n                        }\r\n\r\n                        break;\r\n\r\n                    default:\r\n                        break;\r\n                }\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\nmodule.exports = CustomCssLoader;","var parse = require(\"./parse\");\nvar walk = require(\"./walk\");\nvar stringify = require(\"./stringify\");\n\nfunction ValueParser(value) {\n  if (this instanceof ValueParser) {\n    this.nodes = parse(value);\n    return this;\n  }\n  return new ValueParser(value);\n}\n\nValueParser.prototype.toString = function() {\n  return Array.isArray(this.nodes) ? stringify(this.nodes) : \"\";\n};\n\nValueParser.prototype.walk = function(cb, bubble) {\n  walk(this.nodes, cb, bubble);\n  return this;\n};\n\nValueParser.unit = require(\"./unit\");\n\nValueParser.walk = walk;\n\nValueParser.stringify = stringify;\n\nmodule.exports = ValueParser;\n","var openParentheses = \"(\".charCodeAt(0);\nvar closeParentheses = \")\".charCodeAt(0);\nvar singleQuote = \"'\".charCodeAt(0);\nvar doubleQuote = '\"'.charCodeAt(0);\nvar backslash = \"\\\\\".charCodeAt(0);\nvar slash = \"/\".charCodeAt(0);\nvar comma = \",\".charCodeAt(0);\nvar colon = \":\".charCodeAt(0);\nvar star = \"*\".charCodeAt(0);\nvar uLower = \"u\".charCodeAt(0);\nvar uUpper = \"U\".charCodeAt(0);\nvar plus = \"+\".charCodeAt(0);\nvar isUnicodeRange = /^[a-f0-9?-]+$/i;\n\nmodule.exports = function(input) {\n  var tokens = [];\n  var value = input;\n\n  var next,\n    quote,\n    prev,\n    token,\n    escape,\n    escapePos,\n    whitespacePos,\n    parenthesesOpenPos;\n  var pos = 0;\n  var code = value.charCodeAt(pos);\n  var max = value.length;\n  var stack = [{ nodes: tokens }];\n  var balanced = 0;\n  var parent;\n\n  var name = \"\";\n  var before = \"\";\n  var after = \"\";\n\n  while (pos < max) {\n    // Whitespaces\n    if (code <= 32) {\n      next = pos;\n      do {\n        next += 1;\n        code = value.charCodeAt(next);\n      } while (code <= 32);\n      token = value.slice(pos, next);\n\n      prev = tokens[tokens.length - 1];\n      if (code === closeParentheses && balanced) {\n        after = token;\n      } else if (prev && prev.type === \"div\") {\n        prev.after = token;\n      } else if (\n        code === comma ||\n        code === colon ||\n        (code === slash &&\n          value.charCodeAt(next + 1) !== star &&\n          (!parent ||\n            (parent && parent.type === \"function\" && parent.value !== \"calc\")))\n      ) {\n        before = token;\n      } else {\n        tokens.push({\n          type: \"space\",\n          sourceIndex: pos,\n          value: token\n        });\n      }\n\n      pos = next;\n\n      // Quotes\n    } else if (code === singleQuote || code === doubleQuote) {\n      next = pos;\n      quote = code === singleQuote ? \"'\" : '\"';\n      token = {\n        type: \"string\",\n        sourceIndex: pos,\n        quote: quote\n      };\n      do {\n        escape = false;\n        next = value.indexOf(quote, next + 1);\n        if (~next) {\n          escapePos = next;\n          while (value.charCodeAt(escapePos - 1) === backslash) {\n            escapePos -= 1;\n            escape = !escape;\n          }\n        } else {\n          value += quote;\n          next = value.length - 1;\n          token.unclosed = true;\n        }\n      } while (escape);\n      token.value = value.slice(pos + 1, next);\n\n      tokens.push(token);\n      pos = next + 1;\n      code = value.charCodeAt(pos);\n\n      // Comments\n    } else if (code === slash && value.charCodeAt(pos + 1) === star) {\n      token = {\n        type: \"comment\",\n        sourceIndex: pos\n      };\n\n      next = value.indexOf(\"*/\", pos);\n      if (next === -1) {\n        token.unclosed = true;\n        next = value.length;\n      }\n\n      token.value = value.slice(pos + 2, next);\n      tokens.push(token);\n\n      pos = next + 2;\n      code = value.charCodeAt(pos);\n\n      // Operation within calc\n    } else if (\n      (code === slash || code === star) &&\n      parent &&\n      parent.type === \"function\" &&\n      parent.value === \"calc\"\n    ) {\n      token = value[pos];\n      tokens.push({\n        type: \"word\",\n        sourceIndex: pos - before.length,\n        value: token\n      });\n      pos += 1;\n      code = value.charCodeAt(pos);\n\n      // Dividers\n    } else if (code === slash || code === comma || code === colon) {\n      token = value[pos];\n\n      tokens.push({\n        type: \"div\",\n        sourceIndex: pos - before.length,\n        value: token,\n        before: before,\n        after: \"\"\n      });\n      before = \"\";\n\n      pos += 1;\n      code = value.charCodeAt(pos);\n\n      // Open parentheses\n    } else if (openParentheses === code) {\n      // Whitespaces after open parentheses\n      next = pos;\n      do {\n        next += 1;\n        code = value.charCodeAt(next);\n      } while (code <= 32);\n      parenthesesOpenPos = pos;\n      token = {\n        type: \"function\",\n        sourceIndex: pos - name.length,\n        value: name,\n        before: value.slice(parenthesesOpenPos + 1, next)\n      };\n      pos = next;\n\n      if (name === \"url\" && code !== singleQuote && code !== doubleQuote) {\n        next -= 1;\n        do {\n          escape = false;\n          next = value.indexOf(\")\", next + 1);\n          if (~next) {\n            escapePos = next;\n            while (value.charCodeAt(escapePos - 1) === backslash) {\n              escapePos -= 1;\n              escape = !escape;\n            }\n          } else {\n            value += \")\";\n            next = value.length - 1;\n            token.unclosed = true;\n          }\n        } while (escape);\n        // Whitespaces before closed\n        whitespacePos = next;\n        do {\n          whitespacePos -= 1;\n          code = value.charCodeAt(whitespacePos);\n        } while (code <= 32);\n        if (parenthesesOpenPos < whitespacePos) {\n          if (pos !== whitespacePos + 1) {\n            token.nodes = [\n              {\n                type: \"word\",\n                sourceIndex: pos,\n                value: value.slice(pos, whitespacePos + 1)\n              }\n            ];\n          } else {\n            token.nodes = [];\n          }\n          if (token.unclosed && whitespacePos + 1 !== next) {\n            token.after = \"\";\n            token.nodes.push({\n              type: \"space\",\n              sourceIndex: whitespacePos + 1,\n              value: value.slice(whitespacePos + 1, next)\n            });\n          } else {\n            token.after = value.slice(whitespacePos + 1, next);\n          }\n        } else {\n          token.after = \"\";\n          token.nodes = [];\n        }\n        pos = next + 1;\n        code = value.charCodeAt(pos);\n        tokens.push(token);\n      } else {\n        balanced += 1;\n        token.after = \"\";\n        tokens.push(token);\n        stack.push(token);\n        tokens = token.nodes = [];\n        parent = token;\n      }\n      name = \"\";\n\n      // Close parentheses\n    } else if (closeParentheses === code && balanced) {\n      pos += 1;\n      code = value.charCodeAt(pos);\n\n      parent.after = after;\n      after = \"\";\n      balanced -= 1;\n      stack.pop();\n      parent = stack[balanced];\n      tokens = parent.nodes;\n\n      // Words\n    } else {\n      next = pos;\n      do {\n        if (code === backslash) {\n          next += 1;\n        }\n        next += 1;\n        code = value.charCodeAt(next);\n      } while (\n        next < max &&\n        !(\n          code <= 32 ||\n          code === singleQuote ||\n          code === doubleQuote ||\n          code === comma ||\n          code === colon ||\n          code === slash ||\n          code === openParentheses ||\n          (code === star &&\n            parent &&\n            parent.type === \"function\" &&\n            parent.value === \"calc\") ||\n          (code === slash &&\n            parent.type === \"function\" &&\n            parent.value === \"calc\") ||\n          (code === closeParentheses && balanced)\n        )\n      );\n      token = value.slice(pos, next);\n\n      if (openParentheses === code) {\n        name = token;\n      } else if (\n        (uLower === token.charCodeAt(0) || uUpper === token.charCodeAt(0)) &&\n        plus === token.charCodeAt(1) &&\n        isUnicodeRange.test(token.slice(2))\n      ) {\n        tokens.push({\n          type: \"unicode-range\",\n          sourceIndex: pos,\n          value: token\n        });\n      } else {\n        tokens.push({\n          type: \"word\",\n          sourceIndex: pos,\n          value: token\n        });\n      }\n\n      pos = next;\n    }\n  }\n\n  for (pos = stack.length - 1; pos; pos -= 1) {\n    stack[pos].unclosed = true;\n  }\n\n  return stack[0].nodes;\n};\n","module.exports = function walk(nodes, cb, bubble) {\n  var i, max, node, result;\n\n  for (i = 0, max = nodes.length; i < max; i += 1) {\n    node = nodes[i];\n    if (!bubble) {\n      result = cb(node, i, nodes);\n    }\n\n    if (\n      result !== false &&\n      node.type === \"function\" &&\n      Array.isArray(node.nodes)\n    ) {\n      walk(node.nodes, cb, bubble);\n    }\n\n    if (bubble) {\n      cb(node, i, nodes);\n    }\n  }\n};\n","function stringifyNode(node, custom) {\n  var type = node.type;\n  var value = node.value;\n  var buf;\n  var customResult;\n\n  if (custom && (customResult = custom(node)) !== undefined) {\n    return customResult;\n  } else if (type === \"word\" || type === \"space\") {\n    return value;\n  } else if (type === \"string\") {\n    buf = node.quote || \"\";\n    return buf + value + (node.unclosed ? \"\" : buf);\n  } else if (type === \"comment\") {\n    return \"/*\" + value + (node.unclosed ? \"\" : \"*/\");\n  } else if (type === \"div\") {\n    return (node.before || \"\") + value + (node.after || \"\");\n  } else if (Array.isArray(node.nodes)) {\n    buf = stringify(node.nodes, custom);\n    if (type !== \"function\") {\n      return buf;\n    }\n    return (\n      value +\n      \"(\" +\n      (node.before || \"\") +\n      buf +\n      (node.after || \"\") +\n      (node.unclosed ? \"\" : \")\")\n    );\n  }\n  return value;\n}\n\nfunction stringify(nodes, custom) {\n  var result, i;\n\n  if (Array.isArray(nodes)) {\n    result = \"\";\n    for (i = nodes.length - 1; ~i; i -= 1) {\n      result = stringifyNode(nodes[i], custom) + result;\n    }\n    return result;\n  }\n  return stringifyNode(nodes, custom);\n}\n\nmodule.exports = stringify;\n","var minus = \"-\".charCodeAt(0);\nvar plus = \"+\".charCodeAt(0);\nvar dot = \".\".charCodeAt(0);\nvar exp = \"e\".charCodeAt(0);\nvar EXP = \"E\".charCodeAt(0);\n\n// Check if three code points would start a number\n// https://www.w3.org/TR/css-syntax-3/#starts-with-a-number\nfunction likeNumber(value) {\n  var code = value.charCodeAt(0);\n  var nextCode;\n\n  if (code === plus || code === minus) {\n    nextCode = value.charCodeAt(1);\n\n    if (nextCode >= 48 && nextCode <= 57) {\n      return true;\n    }\n\n    var nextNextCode = value.charCodeAt(2);\n\n    if (nextCode === dot && nextNextCode >= 48 && nextNextCode <= 57) {\n      return true;\n    }\n\n    return false;\n  }\n\n  if (code === dot) {\n    nextCode = value.charCodeAt(1);\n\n    if (nextCode >= 48 && nextCode <= 57) {\n      return true;\n    }\n\n    return false;\n  }\n\n  if (code >= 48 && code <= 57) {\n    return true;\n  }\n\n  return false;\n}\n\n// Consume a number\n// https://www.w3.org/TR/css-syntax-3/#consume-number\nmodule.exports = function(value) {\n  var pos = 0;\n  var length = value.length;\n  var code;\n  var nextCode;\n  var nextNextCode;\n\n  if (length === 0 || !likeNumber(value)) {\n    return false;\n  }\n\n  code = value.charCodeAt(pos);\n\n  if (code === plus || code === minus) {\n    pos++;\n  }\n\n  while (pos < length) {\n    code = value.charCodeAt(pos);\n\n    if (code < 48 || code > 57) {\n      break;\n    }\n\n    pos += 1;\n  }\n\n  code = value.charCodeAt(pos);\n  nextCode = value.charCodeAt(pos + 1);\n\n  if (code === dot && nextCode >= 48 && nextCode <= 57) {\n    pos += 2;\n\n    while (pos < length) {\n      code = value.charCodeAt(pos);\n\n      if (code < 48 || code > 57) {\n        break;\n      }\n\n      pos += 1;\n    }\n  }\n\n  code = value.charCodeAt(pos);\n  nextCode = value.charCodeAt(pos + 1);\n  nextNextCode = value.charCodeAt(pos + 2);\n\n  if (\n    (code === exp || code === EXP) &&\n    ((nextCode >= 48 && nextCode <= 57) ||\n      ((nextCode === plus || nextCode === minus) &&\n        nextNextCode >= 48 &&\n        nextNextCode <= 57))\n  ) {\n    pos += nextCode === plus || nextCode === minus ? 3 : 2;\n\n    while (pos < length) {\n      code = value.charCodeAt(pos);\n\n      if (code < 48 || code > 57) {\n        break;\n      }\n\n      pos += 1;\n    }\n  }\n\n  return {\n    number: value.slice(0, pos),\n    unit: value.slice(pos)\n  };\n};\n","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","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    }\n    return this.previous().length > 0\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    }\n    return true\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    }\n    return true\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    }\n    if (typeof this.mapOpts.annotation !== 'undefined') {\n      return this.mapOpts.annotation\n    }\n    if (this.previous().length) {\n      return this.previous().some(i => i.annotation)\n    }\n    return true\n  }\n\n  toBase64 (str) {\n    if (Buffer) {\n      return Buffer.from(str).toString('base64')\n    }\n    return window.btoa(unescape(encodeURIComponent(str)))\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    }\n    if (this.opts.from) {\n      return this.relative(this.opts.from)\n    }\n    return 'to.css'\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    }\n    return [this.css, this.map]\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    }\n    return file\n  }\n\n  sourcePath (node) {\n    if (this.mapOpts.from) {\n      return this.mapOpts.from\n    }\n    return this.relative(node.source.input.from)\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        let p = node.parent || { raws: { } }\n        if (node.type !== 'decl' || node !== p.last || p.raws.semicolon) {\n          if (node.source && node.source.end) {\n            this.map.addMapping({\n              source: this.sourcePath(node),\n              generated: { line, column: column - 2 },\n              original: {\n                line: node.source.end.line,\n                column: node.source.end.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    })\n  }\n\n  generate () {\n    this.clearAnnotation()\n\n    if (this.isMap()) {\n      return this.generateMap()\n    }\n\n    let result = ''\n    this.stringify(this.root, i => {\n      result += i\n    })\n    return [result]\n  }\n}\n\nexport default MapGenerator\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  var i\n  for (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","let printed = { }\n\nexport default function 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}\n","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([autoprefixer]).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 * 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 */\nclass Warning {\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  constructor (text, opts = { }) {\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      let 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 (let opt in opts) this[opt] = opts[opt]\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  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    }\n\n    if (this.plugin) {\n      return this.plugin + ': ' + this.text\n    }\n\n    return this.text\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\nexport default Warning\n","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        if (token[0] === 'word' && /\\w/.test(token[1])) {\n          this.unknownWord([token])\n        }\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      }\n      if (type === ')') {\n        brackets -= 1\n      }\n      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","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 position () {\n    return pos\n  }\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 (opts) {\n    if (returned.length) return returned.pop()\n    if (pos >= length) return\n\n    let ignoreUnclosed = opts ? opts.ignoreUnclosed : false\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      case CLOSE_SQUARE:\n      case OPEN_CURLY:\n      case CLOSE_CURLY:\n      case COLON:\n      case SEMICOLON:\n      case CLOSE_PARENTHESES:\n        let controlChar = String.fromCharCode(code)\n        currentToken = [controlChar, controlChar, 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 || ignoreUnclosed) {\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 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 || ignoreUnclosed) {\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 || ignoreUnclosed) {\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    position\n  }\n}\n","import path from 'path'\n\nimport CssSyntaxError from './css-syntax-error'\nimport PreviousMap from './previous-map'\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 (\n      css === null ||\n      typeof css === 'undefined' ||\n      (typeof css === 'object' && !css.toString)\n    ) {\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.hasBOM = true\n      this.css = this.css.slice(1)\n    } else {\n      this.hasBOM = false\n    }\n\n    if (opts.from) {\n      if (/^\\w+:\\/\\//.test(opts.from) || path.isAbsolute(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    }\n    return path.resolve(this.map.consumer().sourceRoot || '.', file)\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","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  getAnnotationURL (sourceMapString) {\n    return sourceMapString\n      .match(/\\/\\*\\s*# sourceMappingURL=(.*)\\s*\\*\\//)[1]\n      .trim()\n  }\n\n  loadAnnotation (css) {\n    let annotations = css.match(/\\/\\*\\s*# sourceMappingURL=(.*)\\s*\\*\\//mg)\n\n    if (annotations && annotations.length > 0) {\n      // Locate the last sourceMappingURL to avoid picking up\n      // sourceMappingURLs from comments, strings, etc.\n      let lastAnnotation = annotations[annotations.length - 1]\n      if (lastAnnotation) {\n        this.annotation = this.getAnnotationURL(lastAnnotation)\n      }\n    }\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    }\n\n    if (baseCharsetUri.test(text) || baseUri.test(text)) {\n      return fromBase64(text.substr(RegExp.lastMatch.length))\n    }\n\n    let encoding = text.match(/data:application\\/json;([^,]+),/)[1]\n    throw new Error('Unsupported source map encoding ' + encoding)\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 * Contains helpers for working with vendor prefixes.\n *\n * @example\n * const vendor = postcss.vendor\n *\n * @namespace vendor\n */\nlet 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 (prop) {\n    let match = prop.match(/^(-\\w+-)/)\n    if (match) {\n      return match[0]\n    }\n\n    return ''\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 (prop) {\n    return prop.replace(/^-\\w+-/, '')\n  }\n\n}\n\nexport default vendor\n","'use strict'\n\nlet CssSyntaxError = require('./css-syntax-error')\nlet Declaration = require('./declaration')\nlet LazyResult = require('./lazy-result')\nlet Container = require('./container')\nlet Processor = require('./processor')\nlet stringify = require('./stringify')\nlet fromJSON = require('./fromJSON')\nlet Document = require('./document')\nlet Warning = require('./warning')\nlet Comment = require('./comment')\nlet AtRule = require('./at-rule')\nlet Result = require('./result.js')\nlet Input = require('./input')\nlet parse = require('./parse')\nlet list = require('./list')\nlet Rule = require('./rule')\nlet Root = require('./root')\nlet Node = require('./node')\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\npostcss.plugin = function plugin(name, initializer) {\n  let warningPrinted = false\n  function creator(...args) {\n    // eslint-disable-next-line no-console\n    if (console && console.warn && !warningPrinted) {\n      warningPrinted = true\n      // eslint-disable-next-line no-console\n      console.warn(\n        name +\n          ': postcss.plugin was deprecated. Migration guide:\\n' +\n          'https://evilmartians.com/chronicles/postcss-8-plugin-migration'\n      )\n      if (process.env.LANG && process.env.LANG.startsWith('cn')) {\n        /* c8 ignore next 7 */\n        // eslint-disable-next-line no-console\n        console.warn(\n          name +\n            ': 里面 postcss.plugin 被弃用. 迁移指南:\\n' +\n            'https://www.w3ctech.com/topic/2226'\n        )\n      }\n    }\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\npostcss.stringify = stringify\npostcss.parse = parse\npostcss.fromJSON = fromJSON\npostcss.list = list\n\npostcss.comment = defaults => new Comment(defaults)\npostcss.atRule = defaults => new AtRule(defaults)\npostcss.decl = defaults => new Declaration(defaults)\npostcss.rule = defaults => new Rule(defaults)\npostcss.root = defaults => new Root(defaults)\npostcss.document = defaults => new Document(defaults)\n\npostcss.CssSyntaxError = CssSyntaxError\npostcss.Declaration = Declaration\npostcss.Container = Container\npostcss.Processor = Processor\npostcss.Document = Document\npostcss.Comment = Comment\npostcss.Warning = Warning\npostcss.AtRule = AtRule\npostcss.Result = Result\npostcss.Input = Input\npostcss.Rule = Rule\npostcss.Root = Root\npostcss.Node = Node\n\nLazyResult.registerPostcss(postcss)\n\nmodule.exports = postcss\npostcss.default = postcss\n","var x=String;\nvar create=function() {return {isColorSupported:false,reset:x,bold:x,dim:x,italic:x,underline:x,inverse:x,hidden:x,strikethrough:x,black:x,red:x,green:x,yellow:x,blue:x,magenta:x,cyan:x,white:x,gray:x,bgBlack:x,bgRed:x,bgGreen:x,bgYellow:x,bgBlue:x,bgMagenta:x,bgCyan:x,bgWhite:x}};\nmodule.exports=create();\nmodule.exports.createColors = create;\n","let urlAlphabet =\n  'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'\nlet customAlphabet = (alphabet, defaultSize = 21) => {\n  return (size = defaultSize) => {\n    let id = ''\n    let i = size\n    while (i--) {\n      id += alphabet[(Math.random() * alphabet.length) | 0]\n    }\n    return id\n  }\n}\nlet nanoid = (size = 21) => {\n  let id = ''\n  let i = size\n  while (i--) {\n    id += urlAlphabet[(Math.random() * 64) | 0]\n  }\n  return id\n}\nexport { nanoid, customAlphabet }\n","'use strict'\n\nlet Declaration = require('./declaration')\nlet tokenizer = require('./tokenize')\nlet Comment = require('./comment')\nlet AtRule = require('./at-rule')\nlet Root = require('./root')\nlet Rule = require('./rule')\n\nconst SAFE_COMMENT_NEIGHBOR = {\n  empty: true,\n  space: true\n}\n\nfunction findLastWithPosition(tokens) {\n  for (let i = tokens.length - 1; i >= 0; i--) {\n    let token = tokens[i]\n    let pos = token[3] || token[2]\n    if (pos) return pos\n  }\n}\n\nclass 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    this.customProperty = false\n\n    this.createTokenizer()\n    this.root.source = { input, start: { column: 1, line: 1, offset: 0 } }\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])\n\n    let type\n    let prev\n    let shift\n    let last = false\n    let open = false\n    let params = []\n    let brackets = []\n\n    while (!this.tokenizer.endOfFile()) {\n      token = this.tokenizer.nextToken()\n      type = token[0]\n\n      if (type === '(' || type === '[') {\n        brackets.push(type === '(' ? ')' : ']')\n      } else if (type === '{' && brackets.length > 0) {\n        brackets.push('}')\n      } else if (type === brackets[brackets.length - 1]) {\n        brackets.pop()\n      }\n\n      if (brackets.length === 0) {\n        if (type === ';') {\n          node.source.end = this.getPosition(token[2])\n          node.source.end.offset++\n          this.semicolon = true\n          break\n        } else if (type === '{') {\n          open = true\n          break\n        } else if (type === '}') {\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 = this.getPosition(prev[3] || prev[2])\n              node.source.end.offset++\n            }\n          }\n          this.end(token)\n          break\n        } else {\n          params.push(token)\n        }\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 = this.getPosition(token[3] || token[2])\n        node.source.end.offset++\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  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    // If the token is a word, e.g. `!important`, `red` or any other valid property's value.\n    // Then we need to return the colon after that word token. [3] is the \"end\" colon of that word.\n    // And because we need it after that one we do +1 to get the next one.\n    throw this.input.error(\n      'Missed semicolon',\n      token[0] === 'word' ? token[3] + 1 : token[2]\n    )\n  }\n\n  colon(tokens) {\n    let brackets = 0\n    let token, type, prev\n    for (let [i, element] of tokens.entries()) {\n      token = element\n      type = token[0]\n\n      if (type === '(') {\n        brackets += 1\n      }\n      if (type === ')') {\n        brackets -= 1\n      }\n      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  comment(token) {\n    let node = new Comment()\n    this.init(node, token[2])\n    node.source.end = this.getPosition(token[3] || token[2])\n    node.source.end.offset++\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  createTokenizer() {\n    this.tokenizer = tokenizer(this.input)\n  }\n\n  decl(tokens, customProperty) {\n    let node = new Declaration()\n    this.init(node, tokens[0][2])\n\n    let last = tokens[tokens.length - 1]\n    if (last[0] === ';') {\n      this.semicolon = true\n      tokens.pop()\n    }\n\n    node.source.end = this.getPosition(\n      last[3] || last[2] || findLastWithPosition(tokens)\n    )\n    node.source.end.offset++\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 = this.getPosition(tokens[0][2])\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        if (token[0] === 'word' && /\\w/.test(token[1])) {\n          this.unknownWord([token])\n        }\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\n    let firstSpaces = []\n    let next\n    while (tokens.length) {\n      next = tokens[0][0]\n      if (next !== 'space' && next !== 'comment') break\n      firstSpaces.push(tokens.shift())\n    }\n\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    let hasWord = tokens.some(i => i[0] !== 'space' && i[0] !== 'comment')\n\n    if (hasWord) {\n      node.raws.between += firstSpaces.map(i => i[1]).join('')\n      firstSpaces = []\n    }\n    this.raw(node, 'value', firstSpaces.concat(tokens), customProperty)\n\n    if (node.value.includes(':') && !customProperty) {\n      this.checkMissedSemicolon(tokens)\n    }\n  }\n\n  doubleColon(token) {\n    throw this.input.error(\n      'Double colon',\n      { offset: token[2] },\n      { offset: token[2] + token[1].length }\n    )\n  }\n\n  emptyRule(token) {\n    let node = new Rule()\n    this.init(node, token[2])\n    node.selector = ''\n    node.raws.between = ''\n    this.current = node\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 = this.getPosition(token[2])\n      this.current.source.end.offset++\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    this.root.source.end = this.getPosition(this.tokenizer.position())\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  getPosition(offset) {\n    let pos = this.input.fromOffset(offset)\n    return {\n      column: pos.col,\n      line: pos.line,\n      offset\n    }\n  }\n\n  init(node, offset) {\n    this.current.push(node)\n    node.source = {\n      input: this.input,\n      start: this.getPosition(offset)\n    }\n    node.raws.before = this.spaces\n    this.spaces = ''\n    if (node.type !== 'comment') this.semicolon = false\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    let customProperty = start[1].startsWith('--')\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 (customProperty && colon && type === '{') {\n        if (!bracket) bracket = token\n        brackets.push('}')\n      } else if (brackets.length === 0) {\n        if (type === ';') {\n          if (colon) {\n            this.decl(tokens, customProperty)\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      if (!customProperty) {\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      }\n      this.decl(tokens, customProperty)\n    } else {\n      this.unknownWord(tokens)\n    }\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  precheckMissedSemicolon(/* tokens */) {\n    // Hook for Safe Parser\n  }\n\n  raw(node, prop, tokens, customProperty) {\n    let token, type\n    let length = tokens.length\n    let value = ''\n    let clean = true\n    let next, prev\n\n    for (let i = 0; i < length; i += 1) {\n      token = tokens[i]\n      type = token[0]\n      if (type === 'space' && i === length - 1 && !customProperty) {\n        clean = false\n      } else if (type === 'comment') {\n        prev = tokens[i - 1] ? tokens[i - 1][0] : 'empty'\n        next = tokens[i + 1] ? tokens[i + 1][0] : 'empty'\n        if (!SAFE_COMMENT_NEIGHBOR[prev] && !SAFE_COMMENT_NEIGHBOR[next]) {\n          if (value.slice(-1) === ',') {\n            clean = false\n          } else {\n            value += token[1]\n          }\n        } else {\n          clean = false\n        }\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] = { raw, value }\n    }\n    node[prop] = value\n  }\n\n  rule(tokens) {\n    tokens.pop()\n\n    let node = new Rule()\n    this.init(node, tokens[0][2])\n\n    node.raws.between = this.spacesAndCommentsFromEnd(tokens)\n    this.raw(node, 'selector', tokens)\n    this.current = node\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  // Errors\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  unclosedBlock() {\n    let pos = this.current.source.start\n    throw this.input.error('Unclosed block', pos.line, pos.column)\n  }\n\n  unclosedBracket(bracket) {\n    throw this.input.error(\n      'Unclosed bracket',\n      { offset: bracket[2] },\n      { offset: bracket[2] + 1 }\n    )\n  }\n\n  unexpectedClose(token) {\n    throw this.input.error(\n      'Unexpected }',\n      { offset: token[2] },\n      { offset: token[2] + 1 }\n    )\n  }\n\n  unknownWord(tokens) {\n    throw this.input.error(\n      'Unknown word',\n      { offset: tokens[0][2] },\n      { offset: tokens[0][2] + tokens[0][1].length }\n    )\n  }\n\n  unnamedAtrule(node, token) {\n    throw this.input.error(\n      'At-rule without name',\n      { offset: token[2] },\n      { offset: token[2] + token[1].length }\n    )\n  }\n}\n\nmodule.exports = Parser\n","'use strict'\n\nconst 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 = /[\\t\\n\\f\\r \"#'()/;[\\\\\\]{}]/g\nconst RE_WORD_END = /[\\t\\n\\f\\r !\"#'():;@[\\\\\\]{}]|\\/(?=\\*)/g\nconst RE_BAD_BRACKET = /.[\\r\\n\"'(/\\\\]/\nconst RE_HEX_ESCAPE = /[\\da-f]/i\n\nmodule.exports = function tokenizer(input, options = {}) {\n  let css = input.css.valueOf()\n  let ignore = options.ignoreErrors\n\n  let code, next, quote, content, escape\n  let escaped, escapePos, prev, n, currentToken\n\n  let length = css.length\n  let pos = 0\n  let buffer = []\n  let returned = []\n\n  function position() {\n    return pos\n  }\n\n  function unclosed(what) {\n    throw input.error('Unclosed ' + what, pos)\n  }\n\n  function endOfFile() {\n    return returned.length === 0 && pos >= length\n  }\n\n  function nextToken(opts) {\n    if (returned.length) return returned.pop()\n    if (pos >= length) return\n\n    let ignoreUnclosed = opts ? opts.ignoreUnclosed : false\n\n    code = css.charCodeAt(pos)\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        } 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\n      case OPEN_SQUARE:\n      case CLOSE_SQUARE:\n      case OPEN_CURLY:\n      case CLOSE_CURLY:\n      case COLON:\n      case SEMICOLON:\n      case CLOSE_PARENTHESES: {\n        let controlChar = String.fromCharCode(code)\n        currentToken = [controlChar, controlChar, pos]\n        break\n      }\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          n !== DOUBLE_QUOTE &&\n          n !== SPACE &&\n          n !== NEWLINE &&\n          n !== TAB &&\n          n !== FEED &&\n          n !== CR\n        ) {\n          next = pos\n          do {\n            escaped = false\n            next = css.indexOf(')', next + 1)\n            if (next === -1) {\n              if (ignore || ignoreUnclosed) {\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), pos, next]\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 = ['(', '(', pos]\n          } else {\n            currentToken = ['brackets', content, pos, next]\n            pos = next\n          }\n        }\n\n        break\n      }\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 || ignoreUnclosed) {\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        currentToken = ['string', css.slice(pos, next + 1), pos, next]\n        pos = next\n        break\n      }\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), pos, next]\n\n        pos = next\n        break\n      }\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), pos, next]\n\n        pos = next\n        break\n      }\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 || ignoreUnclosed) {\n              next = css.length\n            } else {\n              unclosed('comment')\n            }\n          }\n\n          currentToken = ['comment', css.slice(pos, next + 1), pos, next]\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), pos, next]\n          buffer.push(currentToken)\n          pos = next\n        }\n\n        break\n      }\n    }\n\n    pos++\n    return currentToken\n  }\n\n  function back(token) {\n    returned.push(token)\n  }\n\n  return {\n    back,\n    endOfFile,\n    nextToken,\n    position\n  }\n}\n","'use strict'\n\nlet NoWorkResult = require('./no-work-result')\nlet LazyResult = require('./lazy-result')\nlet Document = require('./document')\nlet Root = require('./root')\n\nclass Processor {\n  constructor(plugins = []) {\n    this.version = '8.4.31'\n    this.plugins = this.normalize(plugins)\n  }\n\n  normalize(plugins) {\n    let normalized = []\n    for (let i of plugins) {\n      if (i.postcss === true) {\n        i = i()\n      } else if (i.postcss) {\n        i = i.postcss\n      }\n\n      if (typeof i === 'object' && Array.isArray(i.plugins)) {\n        normalized = normalized.concat(i.plugins)\n      } else if (typeof i === 'object' && i.postcssPlugin) {\n        normalized.push(i)\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  process(css, opts = {}) {\n    if (\n      this.plugins.length === 0 &&\n      typeof opts.parser === 'undefined' &&\n      typeof opts.stringifier === 'undefined' &&\n      typeof opts.syntax === 'undefined'\n    ) {\n      return new NoWorkResult(this, css, opts)\n    } else {\n      return new LazyResult(this, css, opts)\n    }\n  }\n\n  use(plugin) {\n    this.plugins = this.plugins.concat(this.normalize([plugin]))\n    return this\n  }\n}\n\nmodule.exports = Processor\nProcessor.default = Processor\n\nRoot.registerProcessor(Processor)\nDocument.registerProcessor(Processor)\n","'use strict'\n\nlet MapGenerator = require('./map-generator')\nlet stringify = require('./stringify')\nlet warnOnce = require('./warn-once')\nlet parse = require('./parse')\nconst Result = require('./result')\n\nclass NoWorkResult {\n  constructor(processor, css, opts) {\n    css = css.toString()\n    this.stringified = false\n\n    this._processor = processor\n    this._css = css\n    this._opts = opts\n    this._map = undefined\n    let root\n\n    let str = stringify\n    this.result = new Result(this._processor, root, this._opts)\n    this.result.css = css\n\n    let self = this\n    Object.defineProperty(this.result, 'root', {\n      get() {\n        return self.root\n      }\n    })\n\n    let map = new MapGenerator(str, root, this._opts, css)\n    if (map.isMap()) {\n      let [generatedCSS, generatedMap] = map.generate()\n      if (generatedCSS) {\n        this.result.css = generatedCSS\n      }\n      if (generatedMap) {\n        this.result.map = generatedMap\n      }\n    }\n  }\n\n  async() {\n    if (this.error) return Promise.reject(this.error)\n    return Promise.resolve(this.result)\n  }\n\n  catch(onRejected) {\n    return this.async().catch(onRejected)\n  }\n\n  finally(onFinally) {\n    return this.async().then(onFinally, onFinally)\n  }\n\n  sync() {\n    if (this.error) throw this.error\n    return this.result\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\n    return this.async().then(onFulfilled, onRejected)\n  }\n\n  toString() {\n    return this._css\n  }\n\n  warnings() {\n    return []\n  }\n\n  get content() {\n    return this.result.css\n  }\n\n  get css() {\n    return this.result.css\n  }\n\n  get map() {\n    return this.result.map\n  }\n\n  get messages() {\n    return []\n  }\n\n  get opts() {\n    return this.result.opts\n  }\n\n  get processor() {\n    return this.result.processor\n  }\n\n  get root() {\n    if (this._root) {\n      return this._root\n    }\n\n    let root\n    let parser = parse\n\n    try {\n      root = parser(this._css, this._opts)\n    } catch (error) {\n      this.error = error\n    }\n\n    if (this.error) {\n      throw this.error\n    } else {\n      this._root = root\n      return root\n    }\n  }\n\n  get [Symbol.toStringTag]() {\n    return 'NoWorkResult'\n  }\n}\n\nmodule.exports = NoWorkResult\nNoWorkResult.default = NoWorkResult\n","'use strict'\n\nlet Declaration = require('./declaration')\nlet PreviousMap = require('./previous-map')\nlet Comment = require('./comment')\nlet AtRule = require('./at-rule')\nlet Input = require('./input')\nlet Root = require('./root')\nlet Rule = require('./rule')\n\nfunction fromJSON(json, inputs) {\n  if (Array.isArray(json)) return json.map(n => fromJSON(n))\n\n  let { inputs: ownInputs, ...defaults } = json\n  if (ownInputs) {\n    inputs = []\n    for (let input of ownInputs) {\n      let inputHydrated = { ...input, __proto__: Input.prototype }\n      if (inputHydrated.map) {\n        inputHydrated.map = {\n          ...inputHydrated.map,\n          __proto__: PreviousMap.prototype\n        }\n      }\n      inputs.push(inputHydrated)\n    }\n  }\n  if (defaults.nodes) {\n    defaults.nodes = json.nodes.map(n => fromJSON(n, inputs))\n  }\n  if (defaults.source) {\n    let { inputId, ...source } = defaults.source\n    defaults.source = source\n    if (inputId != null) {\n      defaults.source.input = inputs[inputId]\n    }\n  }\n  if (defaults.type === 'root') {\n    return new Root(defaults)\n  } else if (defaults.type === 'decl') {\n    return new Declaration(defaults)\n  } else if (defaults.type === 'rule') {\n    return new Rule(defaults)\n  } else if (defaults.type === 'comment') {\n    return new Comment(defaults)\n  } else if (defaults.type === 'atrule') {\n    return new AtRule(defaults)\n  } else {\n    throw new Error('Unknown node type: ' + json.type)\n  }\n}\n\nmodule.exports = fromJSON\nfromJSON.default = fromJSON\n"],"sourceRoot":""}