{"version":3,"sources":["webpack:///./node_modules/sanitize-html/node_modules/postcss/lib/lazy-result.js","webpack:///./node_modules/string-convert/camel2hyphen.js","webpack:///./node_modules/sanitize-html/node_modules/postcss/lib/rule.js","webpack:///./node_modules/sanitize-html/node_modules/postcss/lib/postcss.js","webpack:///./node_modules/shallowequal/index.js","webpack:///./node_modules/tsml/tsml.js","webpack:///./node_modules/sanitize-html/node_modules/postcss/lib/css-syntax-error.js","webpack:///./node_modules/sanitize-html/node_modules/postcss/lib/parser.js","webpack:///./node_modules/sanitize-html/node_modules/postcss/lib/list.js","webpack:///./node_modules/sanitize-html/node_modules/postcss/lib/result.js","webpack:///./node_modules/sanitize-html/index.js","webpack:///./node_modules/sanitize-html/node_modules/postcss/lib/stringifier.js","webpack:///./node_modules/sanitize-html/node_modules/postcss/lib/comment.js","webpack:///./node_modules/sanitize-html/node_modules/postcss/lib/parse.js","webpack:///./node_modules/sanitize-html/node_modules/postcss/lib/warning.js","webpack:///./node_modules/resize-observer-polyfill/dist/ResizeObserver.es.js","webpack:///./node_modules/sanitize-html/node_modules/postcss/lib/declaration.js","webpack:///./node_modules/sanitize-html/node_modules/postcss/lib/document.js","webpack:///./node_modules/sanitize-html/node_modules/is-plain-object/dist/is-plain-object.mjs","webpack:///./node_modules/safe-json-parse/tuple.js","webpack:///./node_modules/sanitize-html/node_modules/postcss/lib/processor.js","webpack:///./node_modules/tinycolor2/cjs/tinycolor.js","webpack:///./node_modules/tslib/tslib.es6.js","webpack:///./node_modules/scrypt-js/scrypt.js","webpack:///./node_modules/skeleton-loader-vue/dist/skeleton-loader-vue.esm.js","webpack:///./node_modules/sanitize-html/node_modules/escape-string-regexp/index.js","webpack:///./node_modules/sanitize-html/node_modules/postcss/lib/input.js","webpack:///./node_modules/sanitize-html/node_modules/postcss/lib/tokenize.js","webpack:///./node_modules/sanitize-html/node_modules/postcss/lib/root.js","webpack:///./node_modules/sanitize-html/node_modules/postcss/lib/warn-once.js","webpack:///./node_modules/sanitize-html/node_modules/postcss/lib/map-generator.js","webpack:///./node_modules/sanitize-html/node_modules/postcss/lib/node.js","webpack:///./node_modules/shallow-equal/arrays/index.js","webpack:///./node_modules/sanitize-html/node_modules/postcss/lib/no-work-result.js","webpack:///./node_modules/safe-json-utils/dist/cjs/index.js","webpack:///./node_modules/sanitize-html/node_modules/postcss/lib/symbols.js","webpack:///./node_modules/sanitize-html/node_modules/postcss/lib/previous-map.js","webpack:///./node_modules/sanitize-html/node_modules/postcss/lib/stringify.js","webpack:///./node_modules/sanitize-html/node_modules/postcss/lib/fromJSON.js","webpack:///./node_modules/sanitize-html/node_modules/postcss/lib/at-rule.js","webpack:///./node_modules/split-on-first/index.js","webpack:///./node_modules/sanitize-html/node_modules/postcss/lib/container.js"],"names":["isClean","my","r","MapGenerator","stringify","Container","Document","Result","parse","Root","TYPE_TO_CLASS_NAME","document","root","atrule","rule","decl","comment","PLUGIN_PROPS","postcssPlugin","prepare","Once","Declaration","Rule","AtRule","Comment","DeclarationExit","RuleExit","AtRuleExit","CommentExit","RootExit","DocumentExit","OnceExit","NOT_VISITORS","CHILDREN","isPromise","obj","then","getEvents","node","key","type","prop","toLowerCase","name","append","toStack","events","eventIndex","visitors","visitorIndex","iterator","cleanMarks","nodes","forEach","i","postcss","LazyResult","constructor","processor","css","opts","this","stringified","processed","map","inline","prev","parser","syntax","error","rebuild","result","helpers","plugins","plugin","toStringTag","Symbol","content","sync","messages","warnings","toString","onFulfilled","onRejected","async","catch","finally","onFinally","Promise","reject","resolve","processing","runAsync","getAsyncError","runOnRoot","prepareVisitors","hasListener","walkSync","listeners","subRoot","visitSync","str","stringifier","data","generate","event","each","child","toProxy","visitor","promise","lastPlugin","e","handleError","proxyOf","parent","roots","all","Error","addToError","postcssVersion","setMessage","err","console","length","stack","visitTick","add","cb","push","test","version","filter","Object","keys","visit","pop","indexes","getIterator","registerPostcss","dependant","module","exports","default","registerLazyResult","replace","match","camel2hyphen","list","defaults","super","selectors","comma","selector","values","sep","raw","join","registerRule","CssSyntaxError","Processor","fromJSON","Warning","Input","Node","Array","isArray","initializer","cache","warningPrinted","creator","args","warn","LANG","startsWith","transformer","defineProperty","get","process","processOpts","pluginOpts","atRule","objA","objB","compare","compareContext","ret","call","keysA","keysB","bHasOwnProperty","prototype","hasOwnProperty","bind","idx","valueA","valueB","clean","s","sa","arguments","pico","terminalHighlight","message","line","column","source","file","reason","endLine","endColumn","captureStackTrace","showSourceCode","color","isColorSupported","mark","aside","lines","split","start","Math","max","end","min","maxWidth","String","bold","red","gray","createColors","text","slice","index","number","gutter","spacing","code","tokenizer","SAFE_COMMENT_NEIGHBOR","empty","space","input","current","spaces","semicolon","customProperty","createTokenizer","offset","token","endOfFile","nextToken","freeSemicolon","emptyRule","other","endFile","init","getPosition","raws","left","right","between","colon","bracket","brackets","tokens","back","unclosedBracket","unknownWord","spacesAndCommentsFromEnd","last","pos","findLastWithPosition","before","shift","next","firstSpaces","precheckMissedSemicolon","important","string","stringFrom","spacesFromEnd","j","trim","indexOf","some","concat","value","includes","checkMissedSemicolon","unnamedAtrule","open","params","afterName","spacesAndCommentsFromStart","after","unexpectedClose","unclosedBlock","ownSemicolon","fromOffset","col","reduce","lastTokenType","from","splice","element","entries","doubleColon","founded","Parser","separators","array","func","inQuote","prevQuote","escape","letter","undefined","warning","escapeStringRegexp","isPlainObject","deepmerge","parseSrcset","postcssParse","mediaTags","vulnerableTags","has","a","n","v","sanitizeHtml","VALID_HTML_ATTRIBUTE_NAME","html","options","_recursing","tempResult","Frame","tag","attribs","that","tagPosition","mediaChildren","updateParentNodeText","updateParentNodeMediaChildren","assign","htmlParserDefaults","allowedTags","allowVulnerableTags","nonTextTagsArray","nonTextTags","allowedAttributesMap","allowedAttributesGlobMap","allowedAttributes","attributes","globRegex","RegExp","allowedClassesMap","allowedClassesGlobMap","allowedClassesRegexMap","allowedClasses","classes","transformTagsMap","transformTagsAll","depth","skipMap","transformMap","skipText","skipTextDepth","transformTags","transform","transFun","simpleTransform","addedText","initializeState","htmlparser","onopentag","enforceHtmlBoundary","frame","skip","hasText","transformedTag","innerText","tagName","disallowedTagsMode","isEmptyObject","nestingLimit","allowedScriptHostnames","allowedScriptDomains","passedAllowedAttributesMapCheck","o","newValue","multiple","splitStrArray","allowedSchemesAppliedToAttributes","naughtyHref","allowed","parsed","parseUrl","allowedHostname","find","hostname","url","allowedDomain","domain","endsWith","isRelativeUrl","allowIframeRelativeUrls","allowedIframeHostnames","allowedIframeDomains","evil","parsedSrcset","part","w","h","d","stringifySrcset","allowedSpecificClasses","allowedWildcardClasses","allowedSpecificClassesGlob","allowedSpecificClassesRegex","allowedClassesGlobs","t","allowedGlobs","clss","glob","filterClasses","abstractSyntaxTree","filteredAST","extractedAttributes","attrObject","stringifyStyleAttributes","filterCss","allowedStyles","escapeHtml","selfClosing","textFilter","ontext","lastFrame","escaped","onclosetag","exclusiveFilter","substr","write","quote","decodeEntities","href","firstIndex","lastIndex","substring","matches","allowProtocolRelative","scheme","allowedSchemesByTag","allowedSchemes","base","URL","protocol","astRules","selectedRule","allowedDeclarationsList","attributeObject","matchesRegex","regularExpression","filterDeclarations","img","newTagName","newAttribs","merge","attrib","DEFAULT_RAW","indent","beforeDecl","beforeRule","beforeOpen","beforeClose","beforeComment","emptyBody","commentLeft","commentRight","Stringifier","builder","body","rawValue","block","own","detect","first","rawCache","beforeAfter","method","toUpperCase","capitalize","walk","rawSemicolon","rawEmptyBody","rawIndent","p","parts","rawBeforeComment","walkComments","rawBeforeDecl","walkDecls","rawBeforeRule","rawBeforeClose","rawBeforeOpen","rawColon","buf","step","registerParse","range","rangeBy","opt","word","MapShim","Map","getIndex","arr","entry","class_1","__entries__","enumerable","configurable","set","delete","clear","callback","ctx","_i","_a","isBrowser","window","global$1","global","self","Function","requestAnimationFrame$1","requestAnimationFrame","setTimeout","Date","now","transitionKeys","mutationObserverSupported","MutationObserver","ResizeObserverController","connected_","mutationEventsAdded_","mutationsObserver_","observers_","onTransitionEnd_","refresh","delay","leadingCall","trailingCall","lastCallTime","resolvePending","proxy","timeoutCallback","timeStamp","throttle","REFRESH_DELAY","addObserver","observer","connect_","removeObserver","observers","disconnect_","updateObservers_","activeObservers","gatherActive","hasActive","broadcastActive","addEventListener","observe","childList","characterData","subtree","removeEventListener","disconnect","_b","propertyName","isReflowProperty","getInstance","instance_","defineConfigurable","target","props","writable","getWindowOf","ownerDocument","defaultView","emptyRect","createRectInit","toFloat","parseFloat","getBordersSize","styles","positions","size","position","getHTMLElementContentRect","clientWidth","clientHeight","getComputedStyle","paddings","positions_1","getPaddings","horizPad","vertPad","top","bottom","width","height","boxSizing","round","documentElement","isDocumentElement","vertScrollbar","horizScrollbar","abs","isSVGGraphicsElement","SVGGraphicsElement","SVGElement","getBBox","getContentRect","bbox","getSVGContentRect","x","y","ResizeObservation","broadcastWidth","broadcastHeight","contentRect_","isActive","rect","broadcastRect","ResizeObserverEntry","rectInit","contentRect","Constr","DOMRectReadOnly","create","createReadOnlyRect","ResizeObserverSPI","controller","callbackCtx","activeObservations_","observations_","TypeError","callback_","controller_","callbackCtx_","Element","observations","unobserve","clearActive","_this","observation","WeakMap","ResizeObserver","apply","variable","toResult","registerProcessor","isObject","ctor","prot","reviver","json","JSON","SafeParseTuple","NoWorkResult","normalize","use","normalized","_typeof","trimLeft","trimRight","tinycolor","rgb","inputToRGB","_originalInput","_r","_g","g","b","_roundA","_format","format","_gradientType","gradientType","_ok","ok","l","stringInputToObject","isValidCSSUnit","rgbToRgb","convertToPercentage","hsvToRgb","hslToRgb","boundAlpha","bound01","rgbToHsl","hue2rgb","q","rgbToHsv","floor","f","mod","rgbToHex","allow3Char","hex","pad2","charAt","rgbaToHex","allow4Char","convertDecimalToHex","rgbaToArgbHex","_desaturate","amount","hsl","toHsl","clamp01","_saturate","_greyscale","desaturate","_lighten","_brighten","toRgb","_darken","_spin","hue","_complement","polyad","isNaN","_splitcomplement","_analogous","results","slices","_monochromatic","hsv","toHsv","modification","isDark","getBrightness","isLight","isValid","getOriginalInput","getFormat","getAlpha","getLuminance","RsRGB","GsRGB","BsRGB","pow","B","setAlpha","toHsvString","toHslString","toHex","toHexString","toHex8","toHex8String","toRgbString","toPercentageRgb","toPercentageRgbString","toName","hexNames","toFilter","secondColor","hex8String","secondHex8String","formatSet","formattedString","hasAlpha","clone","_applyModification","fn","lighten","brighten","darken","saturate","greyscale","spin","_applyCombination","analogous","complement","monochromatic","splitcomplement","triad","tetrad","fromRatio","newColor","equals","color1","color2","random","mix","rgb1","rgb2","rgba","readability","c1","c2","isReadable","wcag2","wcag2Parms","out","validateWCAG2Parms","level","mostReadable","baseColor","colorList","includeFallbackColors","bestColor","bestScore","names","aliceblue","antiquewhite","aqua","aquamarine","azure","beige","bisque","black","blanchedalmond","blue","blueviolet","brown","burlywood","burntsienna","cadetblue","chartreuse","chocolate","coral","cornflowerblue","cornsilk","crimson","cyan","darkblue","darkcyan","darkgoldenrod","darkgray","darkgreen","darkgrey","darkkhaki","darkmagenta","darkolivegreen","darkorange","darkorchid","darkred","darksalmon","darkseagreen","darkslateblue","darkslategray","darkslategrey","darkturquoise","darkviolet","deeppink","deepskyblue","dimgray","dimgrey","dodgerblue","firebrick","floralwhite","forestgreen","fuchsia","gainsboro","ghostwhite","gold","goldenrod","green","greenyellow","grey","honeydew","hotpink","indianred","indigo","ivory","khaki","lavender","lavenderblush","lawngreen","lemonchiffon","lightblue","lightcoral","lightcyan","lightgoldenrodyellow","lightgray","lightgreen","lightgrey","lightpink","lightsalmon","lightseagreen","lightskyblue","lightslategray","lightslategrey","lightsteelblue","lightyellow","lime","limegreen","linen","magenta","maroon","mediumaquamarine","mediumblue","mediumorchid","mediumpurple","mediumseagreen","mediumslateblue","mediumspringgreen","mediumturquoise","mediumvioletred","midnightblue","mintcream","mistyrose","moccasin","navajowhite","navy","oldlace","olive","olivedrab","orange","orangered","orchid","palegoldenrod","palegreen","paleturquoise","palevioletred","papayawhip","peachpuff","peru","pink","plum","powderblue","purple","rebeccapurple","rosybrown","royalblue","saddlebrown","salmon","sandybrown","seagreen","seashell","sienna","silver","skyblue","slateblue","slategray","slategrey","snow","springgreen","steelblue","tan","teal","thistle","tomato","turquoise","violet","wheat","white","whitesmoke","yellow","yellowgreen","flip","flipped","isOnePointZero","processPercent","isPercentage","parseInt","val","parseIntFromHex","c","convertHexToDecimal","matchers","CSS_UNIT","PERMISSIVE_MATCH3","PERMISSIVE_MATCH4","hsla","hsva","hex3","hex6","hex4","hex8","exec","named","parms","factory","extendStatics","setPrototypeOf","__proto__","__extends","__","__assign","__rest","getOwnPropertySymbols","propertyIsEnumerable","__decorate","decorators","desc","getOwnPropertyDescriptor","Reflect","decorate","__param","paramIndex","decorator","__metadata","metadataKey","metadataValue","metadata","__awaiter","thisArg","_arguments","P","generator","adopt","fulfilled","rejected","done","__generator","_","label","sent","trys","ops","verb","op","__createBinding","m","k","k2","__exportStar","__values","__read","ar","__spread","__spreadArrays","il","jl","__await","__asyncGenerator","asyncIterator","resume","fulfill","settle","__asyncDelegator","__asyncValues","__makeTemplateObject","cooked","__importStar","__esModule","__importDefault","__classPrivateFieldGet","receiver","privateMap","__classPrivateFieldSet","MAX_VALUE","SHA256","K","Uint32Array","h0","h1","h2","h3","h4","h5","h6","h7","blocks","off","len","u","t1","t2","bytesLeft","bitLenHi","bitLenLo","numZeros","PBKDF2_HMAC_SHA256_OneIter","password","salt","dkLen","innerLen","inner","outerKey","dk","incrementCounter","blockmix_salsa8","BY","Yi","_X","arraycopy","blockxor","salsa20_8","R","S","Si","D","src","srcPos","dest","destPos","checkBufferish","ensureInteger","_scrypt","N","XY","V","totalOps","i1","Bi","currentOp","lastPercent10","stop","state","i0","limit","nextTick","setImmediate","incrementalSMix","steps","percent10","derivedKey","lib","scrypt","progressCallback","lastProgress","progress","Uint8Array","syncScrypt","script","Number","animation","computed","bindClass","mounted","background","loader","$el","style","setProperty","normalizeComponent","template","scopeId","isFunctionalTemplate","moduleIdentifier","shadowMode","createInjector","createInjectorSSR","createInjectorShadow","hook","render","staticRenderFns","_compiled","functional","_scopeId","context","$vnode","ssrContext","__VUE_SSR_CONTEXT__","_registeredComponents","_ssrRegister","$root","$options","shadowRoot","originalRender","existing","beforeCreate","isOldIE","navigator","userAgent","id","group","media","ids","Set","sources","btoa","unescape","encodeURIComponent","createElement","setAttribute","HEAD","head","getElementsByTagName","appendChild","styleSheet","cssText","Boolean","textNode","createTextNode","childNodes","removeChild","insertBefore","addStyle","__vue_component__","_vm","_h","$createElement","_self","_c","staticClass","class","inject","__vue_is_functional_template__","__vue_module_identifier__","script$1","rounded","radius","borderRadius","__vue_component__$1","__vue_is_functional_template__$1","__vue_module_identifier__$1","__vue_component__$2","attrs","loaderWidth","loaderHeight","components","CircleLoader","SquareLoader","waveColor","__vue_scope_id__$2","__vue_is_functional_template__$2","__vue_module_identifier__$2","install","Vue","installed","component","SourceMapConsumer","SourceMapGenerator","fileURLToPath","pathToFileURL","isAbsolute","nanoid","PreviousMap","fromOffsetCache","sourceMapAvailable","pathAvailable","hasBOM","consumer","mapResolve","lastLine","lineToIndex","prevIndex","mid","origin","to","fromUrl","originalPositionFor","sourceRoot","mapFile","sourceContentFor","toJSON","consumerCache","registerInput","SINGLE_QUOTE","charCodeAt","DOUBLE_QUOTE","BACKSLASH","SLASH","NEWLINE","SPACE","FEED","TAB","CR","OPEN_SQUARE","CLOSE_SQUARE","OPEN_PARENTHESES","CLOSE_PARENTHESES","OPEN_CURLY","CLOSE_CURLY","SEMICOLON","ASTERISK","COLON","AT","RE_AT_END","RE_WORD_END","RE_BAD_BRACKET","RE_HEX_ESCAPE","escapePos","currentToken","valueOf","ignore","ignoreErrors","buffer","returned","unclosed","what","ignoreUnclosed","controlChar","fromCharCode","sample","registerRoot","printed","dirname","relative","cssString","mapOpts","usesFileUrls","absolute","isMap","previous","previousMaps","isInline","annotation","isSourcesContent","sourcesContent","withContent","clearAnnotation","setSourcesContent","already","toFileUrl","toUrl","path","setSourceContent","applyPrevMaps","applySourceMap","isAnnotation","toBase64","Buffer","addAnnotation","outputFile","eol","generateMap","generateString","fromSourceMap","addMapping","generated","original","encodeURI","sourcePath","noSource","mapping","lastIndexOf","cloneNode","cloned","remove","overrides","cloneBefore","cloneAfter","insertAfter","replaceWith","bookmark","foundSelf","defaultType","cleanRaws","keepBetween","inputs","fixed","emitInputs","inputsNextIndex","inputId","positionInside","positionBy","endIndex","getProxyProcessor","markDirty","proxyCache","Proxy","postcssNode","arrA","arrB","shallowEqualArrays","_processor","_css","_opts","_map","generatedCSS","generatedMap","_root","safeJsonParse","safeJsonStringify","existsSync","readFileSync","fromBase64","atob","loadAnnotation","startWith","loadMap","getAnnotationURL","sourceMapString","comments","decodeInline","decodeURIComponent","lastMatch","encoding","loadFile","prevPath","mappings","_mappings","sections","ownInputs","inputHydrated","children","prepend","registerAtRule","separator","separatorIndex","cleanSource","markDirtyUp","walkRules","walkAtRules","reverse","unshift","exist","existIndex","removeAll","replaceValues","pattern","fast","every","condition","lastEach"],"mappings":"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","file":"js/chunk-vendors~678f84af.ca585dbd.js","sourcesContent":["'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  document: 'Document',\n  root: 'Root',\n  atrule: 'AtRule',\n  rule: 'Rule',\n  decl: 'Declaration',\n  comment: 'Comment'\n}\n\nconst PLUGIN_PROPS = {\n  postcssPlugin: true,\n  prepare: true,\n  Once: true,\n  Document: true,\n  Root: true,\n  Declaration: true,\n  Rule: true,\n  AtRule: true,\n  Comment: true,\n  DeclarationExit: true,\n  RuleExit: true,\n  AtRuleExit: true,\n  CommentExit: true,\n  RootExit: true,\n  DocumentExit: true,\n  OnceExit: true\n}\n\nconst NOT_VISITORS = {\n  postcssPlugin: true,\n  prepare: true,\n  Once: 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    node,\n    events,\n    eventIndex: 0,\n    visitors: [],\n    visitorIndex: 0,\n    iterator: 0\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, result: this.result, postcss }\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  get [Symbol.toStringTag]() {\n    return 'LazyResult'\n  }\n\n  get processor() {\n    return this.result.processor\n  }\n\n  get opts() {\n    return this.result.opts\n  }\n\n  get css() {\n    return this.stringify().css\n  }\n\n  get content() {\n    return this.stringify().content\n  }\n\n  get map() {\n    return this.stringify().map\n  }\n\n  get root() {\n    return this.sync().root\n  }\n\n  get messages() {\n    return this.sync().messages\n  }\n\n  warnings() {\n    return this.sync().warnings()\n  }\n\n  toString() {\n    return this.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  catch(onRejected) {\n    return this.async().catch(onRejected)\n  }\n\n  finally(onFinally) {\n    return this.async().then(onFinally, onFinally)\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  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  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  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  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  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  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  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  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  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\nLazyResult.registerPostcss = dependant => {\n  postcss = dependant\n}\n\nmodule.exports = LazyResult\nLazyResult.default = LazyResult\n\nRoot.registerLazyResult(LazyResult)\nDocument.registerLazyResult(LazyResult)\n","var camel2hyphen = function (str) {\n  return str\n          .replace(/[A-Z]/g, function (match) {\n            return '-' + match.toLowerCase();\n          })\n          .toLowerCase();\n};\n\nmodule.exports = camel2hyphen;","'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","'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","//\n\nmodule.exports = function shallowEqual(objA, objB, compare, compareContext) {\n  var ret = compare ? compare.call(compareContext, objA, objB) : void 0;\n\n  if (ret !== void 0) {\n    return !!ret;\n  }\n\n  if (objA === objB) {\n    return true;\n  }\n\n  if (typeof objA !== \"object\" || !objA || typeof objB !== \"object\" || !objB) {\n    return false;\n  }\n\n  var keysA = Object.keys(objA);\n  var keysB = Object.keys(objB);\n\n  if (keysA.length !== keysB.length) {\n    return false;\n  }\n\n  var bHasOwnProperty = Object.prototype.hasOwnProperty.bind(objB);\n\n  // Test for A's keys different from B.\n  for (var idx = 0; idx < keysA.length; idx++) {\n    var key = keysA[idx];\n\n    if (!bHasOwnProperty(key)) {\n      return false;\n    }\n\n    var valueA = objA[key];\n    var valueB = objB[key];\n\n    ret = compare ? compare.call(compareContext, valueA, valueB, key) : void 0;\n\n    if (ret === false || (ret === void 0 && valueA !== valueB)) {\n      return false;\n    }\n  }\n\n  return true;\n};\n","function clean (s) {\n  return s.replace(/\\n\\r?\\s*/g, '')\n}\n\n\nmodule.exports = function tsml (sa) {\n  var s = ''\n    , i = 0\n\n  for (; i < arguments.length; i++)\n    s += clean(sa[i]) + (arguments[i + 1] || '')\n\n  return s\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, red, gray } = 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\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: { offset: 0, 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])\n    node.source.end = this.getPosition(token[3] || token[2])\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])\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    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  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  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\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  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          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            }\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        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 = this.getPosition(token[2])\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  getPosition(offset) {\n    let pos = this.input.fromOffset(offset)\n    return {\n      offset,\n      line: pos.line,\n      column: pos.col\n    }\n  }\n\n  init(node, offset) {\n    this.current.push(node)\n    node.source = {\n      start: this.getPosition(offset),\n      input: this.input\n    }\n    node.raws.before = this.spaces\n    this.spaces = ''\n    if (node.type !== 'comment') this.semicolon = false\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] = { 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, 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  // Errors\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  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  unexpectedClose(token) {\n    throw this.input.error(\n      'Unexpected }',\n      { offset: token[2] },\n      { offset: token[2] + 1 }\n    )\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(\n      'Double colon',\n      { offset: token[2] },\n      { offset: token[2] + token[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  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    // 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\nmodule.exports = Parser\n","'use strict'\n\nlet list = {\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  space(string) {\n    let spaces = [' ', '\\n', '\\t']\n    return list.split(string, spaces)\n  },\n\n  comma(string) {\n    return list.split(string, [','], true)\n  }\n}\n\nmodule.exports = list\nlist.default = list\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","const htmlparser = require('htmlparser2');\nconst escapeStringRegexp = require('escape-string-regexp');\nconst { isPlainObject } = require('is-plain-object');\nconst deepmerge = require('deepmerge');\nconst parseSrcset = require('parse-srcset');\nconst { parse: postcssParse } = require('postcss');\n// Tags that can conceivably represent stand-alone media.\nconst mediaTags = [\n  'img', 'audio', 'video', 'picture', 'svg',\n  'object', 'map', 'iframe', 'embed'\n];\n// Tags that are inherently vulnerable to being used in XSS attacks.\nconst vulnerableTags = [ 'script', 'style' ];\n\nfunction each(obj, cb) {\n  if (obj) {\n    Object.keys(obj).forEach(function (key) {\n      cb(obj[key], key);\n    });\n  }\n}\n\n// Avoid false positives with .__proto__, .hasOwnProperty, etc.\nfunction has(obj, key) {\n  return ({}).hasOwnProperty.call(obj, key);\n}\n\n// Returns those elements of `a` for which `cb(a)` returns truthy\nfunction filter(a, cb) {\n  const n = [];\n  each(a, function(v) {\n    if (cb(v)) {\n      n.push(v);\n    }\n  });\n  return n;\n}\n\nfunction isEmptyObject(obj) {\n  for (const key in obj) {\n    if (has(obj, key)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nfunction stringifySrcset(parsedSrcset) {\n  return parsedSrcset.map(function(part) {\n    if (!part.url) {\n      throw new Error('URL missing');\n    }\n\n    return (\n      part.url +\n      (part.w ? ` ${part.w}w` : '') +\n      (part.h ? ` ${part.h}h` : '') +\n      (part.d ? ` ${part.d}x` : '')\n    );\n  }).join(', ');\n}\n\nmodule.exports = sanitizeHtml;\n\n// A valid attribute name.\n// We use a tolerant definition based on the set of strings defined by\n// html.spec.whatwg.org/multipage/parsing.html#before-attribute-name-state\n// and html.spec.whatwg.org/multipage/parsing.html#attribute-name-state .\n// The characters accepted are ones which can be appended to the attribute\n// name buffer without triggering a parse error:\n//   * unexpected-equals-sign-before-attribute-name\n//   * unexpected-null-character\n//   * unexpected-character-in-attribute-name\n// We exclude the empty string because it's impossible to get to the after\n// attribute name state with an empty attribute name buffer.\nconst VALID_HTML_ATTRIBUTE_NAME = /^[^\\0\\t\\n\\f\\r /<=>]+$/;\n\n// Ignore the _recursing flag; it's there for recursive\n// invocation as a guard against this exploit:\n// https://github.com/fb55/htmlparser2/issues/105\n\nfunction sanitizeHtml(html, options, _recursing) {\n  if (html == null) {\n    return '';\n  }\n\n  let result = '';\n  // Used for hot swapping the result variable with an empty string in order to \"capture\" the text written to it.\n  let tempResult = '';\n\n  function Frame(tag, attribs) {\n    const that = this;\n    this.tag = tag;\n    this.attribs = attribs || {};\n    this.tagPosition = result.length;\n    this.text = ''; // Node inner text\n    this.mediaChildren = [];\n\n    this.updateParentNodeText = function() {\n      if (stack.length) {\n        const parentFrame = stack[stack.length - 1];\n        parentFrame.text += that.text;\n      }\n    };\n\n    this.updateParentNodeMediaChildren = function() {\n      if (stack.length && mediaTags.includes(this.tag)) {\n        const parentFrame = stack[stack.length - 1];\n        parentFrame.mediaChildren.push(this.tag);\n      }\n    };\n  }\n\n  options = Object.assign({}, sanitizeHtml.defaults, options);\n  options.parser = Object.assign({}, htmlParserDefaults, options.parser);\n\n  // vulnerableTags\n  vulnerableTags.forEach(function (tag) {\n    if (\n      options.allowedTags !== false && (options.allowedTags || []).indexOf(tag) > -1 &&\n      !options.allowVulnerableTags\n    ) {\n      console.warn(`\\n\\n⚠️ Your \\`allowedTags\\` option includes, \\`${tag}\\`, which is inherently\\nvulnerable to XSS attacks. Please remove it from \\`allowedTags\\`.\\nOr, to disable this warning, add the \\`allowVulnerableTags\\` option\\nand ensure you are accounting for this risk.\\n\\n`);\n    }\n  });\n\n  // Tags that contain something other than HTML, or where discarding\n  // the text when the tag is disallowed makes sense for other reasons.\n  // If we are not allowing these tags, we should drop their content too.\n  // For other tags you would drop the tag but keep its content.\n  const nonTextTagsArray = options.nonTextTags || [\n    'script',\n    'style',\n    'textarea',\n    'option'\n  ];\n  let allowedAttributesMap;\n  let allowedAttributesGlobMap;\n  if (options.allowedAttributes) {\n    allowedAttributesMap = {};\n    allowedAttributesGlobMap = {};\n    each(options.allowedAttributes, function(attributes, tag) {\n      allowedAttributesMap[tag] = [];\n      const globRegex = [];\n      attributes.forEach(function(obj) {\n        if (typeof obj === 'string' && obj.indexOf('*') >= 0) {\n          globRegex.push(escapeStringRegexp(obj).replace(/\\\\\\*/g, '.*'));\n        } else {\n          allowedAttributesMap[tag].push(obj);\n        }\n      });\n      if (globRegex.length) {\n        allowedAttributesGlobMap[tag] = new RegExp('^(' + globRegex.join('|') + ')$');\n      }\n    });\n  }\n  const allowedClassesMap = {};\n  const allowedClassesGlobMap = {};\n  const allowedClassesRegexMap = {};\n  each(options.allowedClasses, function(classes, tag) {\n    // Implicitly allows the class attribute\n    if (allowedAttributesMap) {\n      if (!has(allowedAttributesMap, tag)) {\n        allowedAttributesMap[tag] = [];\n      }\n      allowedAttributesMap[tag].push('class');\n    }\n\n    allowedClassesMap[tag] = [];\n    allowedClassesRegexMap[tag] = [];\n    const globRegex = [];\n    classes.forEach(function(obj) {\n      if (typeof obj === 'string' && obj.indexOf('*') >= 0) {\n        globRegex.push(escapeStringRegexp(obj).replace(/\\\\\\*/g, '.*'));\n      } else if (obj instanceof RegExp) {\n        allowedClassesRegexMap[tag].push(obj);\n      } else {\n        allowedClassesMap[tag].push(obj);\n      }\n    });\n    if (globRegex.length) {\n      allowedClassesGlobMap[tag] = new RegExp('^(' + globRegex.join('|') + ')$');\n    }\n  });\n\n  const transformTagsMap = {};\n  let transformTagsAll;\n  each(options.transformTags, function(transform, tag) {\n    let transFun;\n    if (typeof transform === 'function') {\n      transFun = transform;\n    } else if (typeof transform === 'string') {\n      transFun = sanitizeHtml.simpleTransform(transform);\n    }\n    if (tag === '*') {\n      transformTagsAll = transFun;\n    } else {\n      transformTagsMap[tag] = transFun;\n    }\n  });\n\n  let depth;\n  let stack;\n  let skipMap;\n  let transformMap;\n  let skipText;\n  let skipTextDepth;\n  let addedText = false;\n\n  initializeState();\n\n  const parser = new htmlparser.Parser({\n    onopentag: function(name, attribs) {\n      // If `enforceHtmlBoundary` is `true` and this has found the opening\n      // `html` tag, reset the state.\n      if (options.enforceHtmlBoundary && name === 'html') {\n        initializeState();\n      }\n\n      if (skipText) {\n        skipTextDepth++;\n        return;\n      }\n      const frame = new Frame(name, attribs);\n      stack.push(frame);\n\n      let skip = false;\n      const hasText = !!frame.text;\n      let transformedTag;\n      if (has(transformTagsMap, name)) {\n        transformedTag = transformTagsMap[name](name, attribs);\n\n        frame.attribs = attribs = transformedTag.attribs;\n\n        if (transformedTag.text !== undefined) {\n          frame.innerText = transformedTag.text;\n        }\n\n        if (name !== transformedTag.tagName) {\n          frame.name = name = transformedTag.tagName;\n          transformMap[depth] = transformedTag.tagName;\n        }\n      }\n      if (transformTagsAll) {\n        transformedTag = transformTagsAll(name, attribs);\n\n        frame.attribs = attribs = transformedTag.attribs;\n        if (name !== transformedTag.tagName) {\n          frame.name = name = transformedTag.tagName;\n          transformMap[depth] = transformedTag.tagName;\n        }\n      }\n\n      if ((options.allowedTags !== false && (options.allowedTags || []).indexOf(name) === -1) || (options.disallowedTagsMode === 'recursiveEscape' && !isEmptyObject(skipMap)) || (options.nestingLimit != null && depth >= options.nestingLimit)) {\n        skip = true;\n        skipMap[depth] = true;\n        if (options.disallowedTagsMode === 'discard') {\n          if (nonTextTagsArray.indexOf(name) !== -1) {\n            skipText = true;\n            skipTextDepth = 1;\n          }\n        }\n        skipMap[depth] = true;\n      }\n      depth++;\n      if (skip) {\n        if (options.disallowedTagsMode === 'discard') {\n          // We want the contents but not this tag\n          return;\n        }\n        tempResult = result;\n        result = '';\n      }\n      result += '<' + name;\n\n      if (name === 'script') {\n        if (options.allowedScriptHostnames || options.allowedScriptDomains) {\n          frame.innerText = '';\n        }\n      }\n\n      if (!allowedAttributesMap || has(allowedAttributesMap, name) || allowedAttributesMap['*']) {\n        each(attribs, function(value, a) {\n          if (!VALID_HTML_ATTRIBUTE_NAME.test(a)) {\n            // This prevents part of an attribute name in the output from being\n            // interpreted as the end of an attribute, or end of a tag.\n            delete frame.attribs[a];\n            return;\n          }\n          // check allowedAttributesMap for the element and attribute and modify the value\n          // as necessary if there are specific values defined.\n          let passedAllowedAttributesMapCheck = false;\n          if (!allowedAttributesMap ||\n            (has(allowedAttributesMap, name) && allowedAttributesMap[name].indexOf(a) !== -1) ||\n            (allowedAttributesMap['*'] && allowedAttributesMap['*'].indexOf(a) !== -1) ||\n            (has(allowedAttributesGlobMap, name) && allowedAttributesGlobMap[name].test(a)) ||\n            (allowedAttributesGlobMap['*'] && allowedAttributesGlobMap['*'].test(a))) {\n            passedAllowedAttributesMapCheck = true;\n          } else if (allowedAttributesMap && allowedAttributesMap[name]) {\n            for (const o of allowedAttributesMap[name]) {\n              if (isPlainObject(o) && o.name && (o.name === a)) {\n                passedAllowedAttributesMapCheck = true;\n                let newValue = '';\n                if (o.multiple === true) {\n                  // verify the values that are allowed\n                  const splitStrArray = value.split(' ');\n                  for (const s of splitStrArray) {\n                    if (o.values.indexOf(s) !== -1) {\n                      if (newValue === '') {\n                        newValue = s;\n                      } else {\n                        newValue += ' ' + s;\n                      }\n                    }\n                  }\n                } else if (o.values.indexOf(value) >= 0) {\n                  // verified an allowed value matches the entire attribute value\n                  newValue = value;\n                }\n                value = newValue;\n              }\n            }\n          }\n          if (passedAllowedAttributesMapCheck) {\n            if (options.allowedSchemesAppliedToAttributes.indexOf(a) !== -1) {\n              if (naughtyHref(name, value)) {\n                delete frame.attribs[a];\n                return;\n              }\n            }\n\n            if (name === 'script' && a === 'src') {\n\n              let allowed = true;\n\n              try {\n                const parsed = parseUrl(value);\n\n                if (options.allowedScriptHostnames || options.allowedScriptDomains) {\n                  const allowedHostname = (options.allowedScriptHostnames || []).find(function (hostname) {\n                    return hostname === parsed.url.hostname;\n                  });\n                  const allowedDomain = (options.allowedScriptDomains || []).find(function(domain) {\n                    return parsed.url.hostname === domain || parsed.url.hostname.endsWith(`.${domain}`);\n                  });\n                  allowed = allowedHostname || allowedDomain;\n                }\n              } catch (e) {\n                allowed = false;\n              }\n\n              if (!allowed) {\n                delete frame.attribs[a];\n                return;\n              }\n            }\n\n            if (name === 'iframe' && a === 'src') {\n              let allowed = true;\n              try {\n                const parsed = parseUrl(value);\n\n                if (parsed.isRelativeUrl) {\n                  // default value of allowIframeRelativeUrls is true\n                  // unless allowedIframeHostnames or allowedIframeDomains specified\n                  allowed = has(options, 'allowIframeRelativeUrls')\n                    ? options.allowIframeRelativeUrls\n                    : (!options.allowedIframeHostnames && !options.allowedIframeDomains);\n                } else if (options.allowedIframeHostnames || options.allowedIframeDomains) {\n                  const allowedHostname = (options.allowedIframeHostnames || []).find(function (hostname) {\n                    return hostname === parsed.url.hostname;\n                  });\n                  const allowedDomain = (options.allowedIframeDomains || []).find(function(domain) {\n                    return parsed.url.hostname === domain || parsed.url.hostname.endsWith(`.${domain}`);\n                  });\n                  allowed = allowedHostname || allowedDomain;\n                }\n              } catch (e) {\n                // Unparseable iframe src\n                allowed = false;\n              }\n              if (!allowed) {\n                delete frame.attribs[a];\n                return;\n              }\n            }\n            if (a === 'srcset') {\n              try {\n                let parsed = parseSrcset(value);\n                parsed.forEach(function(value) {\n                  if (naughtyHref('srcset', value.url)) {\n                    value.evil = true;\n                  }\n                });\n                parsed = filter(parsed, function(v) {\n                  return !v.evil;\n                });\n                if (!parsed.length) {\n                  delete frame.attribs[a];\n                  return;\n                } else {\n                  value = stringifySrcset(filter(parsed, function(v) {\n                    return !v.evil;\n                  }));\n                  frame.attribs[a] = value;\n                }\n              } catch (e) {\n                // Unparseable srcset\n                delete frame.attribs[a];\n                return;\n              }\n            }\n            if (a === 'class') {\n              const allowedSpecificClasses = allowedClassesMap[name];\n              const allowedWildcardClasses = allowedClassesMap['*'];\n              const allowedSpecificClassesGlob = allowedClassesGlobMap[name];\n              const allowedSpecificClassesRegex = allowedClassesRegexMap[name];\n              const allowedWildcardClassesGlob = allowedClassesGlobMap['*'];\n              const allowedClassesGlobs = [\n                allowedSpecificClassesGlob,\n                allowedWildcardClassesGlob\n              ]\n                .concat(allowedSpecificClassesRegex)\n                .filter(function (t) {\n                  return t;\n                });\n              if (allowedSpecificClasses && allowedWildcardClasses) {\n                value = filterClasses(value, deepmerge(allowedSpecificClasses, allowedWildcardClasses), allowedClassesGlobs);\n              } else {\n                value = filterClasses(value, allowedSpecificClasses || allowedWildcardClasses, allowedClassesGlobs);\n              }\n              if (!value.length) {\n                delete frame.attribs[a];\n                return;\n              }\n            }\n            if (a === 'style') {\n              try {\n                const abstractSyntaxTree = postcssParse(name + ' {' + value + '}');\n                const filteredAST = filterCss(abstractSyntaxTree, options.allowedStyles);\n\n                value = stringifyStyleAttributes(filteredAST);\n\n                if (value.length === 0) {\n                  delete frame.attribs[a];\n                  return;\n                }\n              } catch (e) {\n                delete frame.attribs[a];\n                return;\n              }\n            }\n            result += ' ' + a;\n            if (value && value.length) {\n              result += '=\"' + escapeHtml(value, true) + '\"';\n            }\n          } else {\n            delete frame.attribs[a];\n          }\n        });\n      }\n      if (options.selfClosing.indexOf(name) !== -1) {\n        result += ' />';\n      } else {\n        result += '>';\n        if (frame.innerText && !hasText && !options.textFilter) {\n          result += escapeHtml(frame.innerText);\n          addedText = true;\n        }\n      }\n      if (skip) {\n        result = tempResult + escapeHtml(result);\n        tempResult = '';\n      }\n    },\n    ontext: function(text) {\n      if (skipText) {\n        return;\n      }\n      const lastFrame = stack[stack.length - 1];\n      let tag;\n\n      if (lastFrame) {\n        tag = lastFrame.tag;\n        // If inner text was set by transform function then let's use it\n        text = lastFrame.innerText !== undefined ? lastFrame.innerText : text;\n      }\n\n      if (options.disallowedTagsMode === 'discard' && ((tag === 'script') || (tag === 'style'))) {\n        // htmlparser2 gives us these as-is. Escaping them ruins the content. Allowing\n        // script tags is, by definition, game over for XSS protection, so if that's\n        // your concern, don't allow them. The same is essentially true for style tags\n        // which have their own collection of XSS vectors.\n        result += text;\n      } else {\n        const escaped = escapeHtml(text, false);\n        if (options.textFilter && !addedText) {\n          result += options.textFilter(escaped, tag);\n        } else if (!addedText) {\n          result += escaped;\n        }\n      }\n      if (stack.length) {\n        const frame = stack[stack.length - 1];\n        frame.text += text;\n      }\n    },\n    onclosetag: function(name) {\n\n      if (skipText) {\n        skipTextDepth--;\n        if (!skipTextDepth) {\n          skipText = false;\n        } else {\n          return;\n        }\n      }\n\n      const frame = stack.pop();\n      if (!frame) {\n        // Do not crash on bad markup\n        return;\n      }\n\n      if (frame.tag !== name) {\n        // Another case of bad markup.\n        // Push to stack, so that it will be used in future closing tags.\n        stack.push(frame);\n        return;\n      }\n\n      skipText = options.enforceHtmlBoundary ? name === 'html' : false;\n      depth--;\n      const skip = skipMap[depth];\n      if (skip) {\n        delete skipMap[depth];\n        if (options.disallowedTagsMode === 'discard') {\n          frame.updateParentNodeText();\n          return;\n        }\n        tempResult = result;\n        result = '';\n      }\n\n      if (transformMap[depth]) {\n        name = transformMap[depth];\n        delete transformMap[depth];\n      }\n\n      if (options.exclusiveFilter && options.exclusiveFilter(frame)) {\n        result = result.substr(0, frame.tagPosition);\n        return;\n      }\n\n      frame.updateParentNodeMediaChildren();\n      frame.updateParentNodeText();\n\n      if (options.selfClosing.indexOf(name) !== -1) {\n        // Already output />\n        if (skip) {\n          result = tempResult;\n          tempResult = '';\n        }\n        return;\n      }\n\n      result += '</' + name + '>';\n      if (skip) {\n        result = tempResult + escapeHtml(result);\n        tempResult = '';\n      }\n      addedText = false;\n    }\n  }, options.parser);\n  parser.write(html);\n  parser.end();\n\n  return result;\n\n  function initializeState() {\n    result = '';\n    depth = 0;\n    stack = [];\n    skipMap = {};\n    transformMap = {};\n    skipText = false;\n    skipTextDepth = 0;\n  }\n\n  function escapeHtml(s, quote) {\n    if (typeof (s) !== 'string') {\n      s = s + '';\n    }\n    if (options.parser.decodeEntities) {\n      s = s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');\n      if (quote) {\n        s = s.replace(/\"/g, '&quot;');\n      }\n    }\n    // TODO: this is inadequate because it will pass `&0;`. This approach\n    // will not work, each & must be considered with regard to whether it\n    // is followed by a 100% syntactically valid entity or not, and escaped\n    // if it is not. If this bothers you, don't set parser.decodeEntities\n    // to false. (The default is true.)\n    s = s.replace(/&(?![a-zA-Z0-9#]{1,20};)/g, '&amp;') // Match ampersands not part of existing HTML entity\n      .replace(/</g, '&lt;')\n      .replace(/>/g, '&gt;');\n    if (quote) {\n      s = s.replace(/\"/g, '&quot;');\n    }\n    return s;\n  }\n\n  function naughtyHref(name, href) {\n    // Browsers ignore character codes of 32 (space) and below in a surprising\n    // number of situations. Start reading here:\n    // https://www.owasp.org/index.php/XSS_Filter_Evasion_Cheat_Sheet#Embedded_tab\n    // eslint-disable-next-line no-control-regex\n    href = href.replace(/[\\x00-\\x20]+/g, '');\n    // Clobber any comments in URLs, which the browser might\n    // interpret inside an XML data island, allowing\n    // a javascript: URL to be snuck through\n    while (true) {\n      const firstIndex = href.indexOf('<!--');\n      if (firstIndex === -1) {\n        break;\n      }\n      const lastIndex = href.indexOf('-->', firstIndex + 4);\n      if (lastIndex === -1) {\n        break;\n      }\n      href = href.substring(0, firstIndex) + href.substring(lastIndex + 3);\n    }\n    // Case insensitive so we don't get faked out by JAVASCRIPT #1\n    // Allow more characters after the first so we don't get faked\n    // out by certain schemes browsers accept\n    const matches = href.match(/^([a-zA-Z][a-zA-Z0-9.\\-+]*):/);\n    if (!matches) {\n      // Protocol-relative URL starting with any combination of '/' and '\\'\n      if (href.match(/^[/\\\\]{2}/)) {\n        return !options.allowProtocolRelative;\n      }\n\n      // No scheme\n      return false;\n    }\n    const scheme = matches[1].toLowerCase();\n\n    if (has(options.allowedSchemesByTag, name)) {\n      return options.allowedSchemesByTag[name].indexOf(scheme) === -1;\n    }\n\n    return !options.allowedSchemes || options.allowedSchemes.indexOf(scheme) === -1;\n  }\n\n  function parseUrl(value) {\n    value = value.replace(/^(\\w+:)?\\s*[\\\\/]\\s*[\\\\/]/, '$1//');\n    if (value.startsWith('relative:')) {\n      // An attempt to exploit our workaround for base URLs being\n      // mandatory for relative URL validation in the WHATWG\n      // URL parser, reject it\n      throw new Error('relative: exploit attempt');\n    }\n    // naughtyHref is in charge of whether protocol relative URLs\n    // are cool. Here we are concerned just with allowed hostnames and\n    // whether to allow relative URLs.\n    //\n    // Build a placeholder \"base URL\" against which any reasonable\n    // relative URL may be parsed successfully\n    let base = 'relative://relative-site';\n    for (let i = 0; (i < 100); i++) {\n      base += `/${i}`;\n    }\n\n    const parsed = new URL(value, base);\n\n    const isRelativeUrl = parsed && parsed.hostname === 'relative-site' && parsed.protocol === 'relative:';\n    return {\n      isRelativeUrl,\n      url: parsed\n    };\n  }\n  /**\n   * Filters user input css properties by allowlisted regex attributes.\n   * Modifies the abstractSyntaxTree object.\n   *\n   * @param {object} abstractSyntaxTree  - Object representation of CSS attributes.\n   * @property {array[Declaration]} abstractSyntaxTree.nodes[0] - Each object cointains prop and value key, i.e { prop: 'color', value: 'red' }.\n   * @param {object} allowedStyles       - Keys are properties (i.e color), value is list of permitted regex rules (i.e /green/i).\n   * @return {object}                    - The modified tree.\n   */\n  function filterCss(abstractSyntaxTree, allowedStyles) {\n    if (!allowedStyles) {\n      return abstractSyntaxTree;\n    }\n\n    const astRules = abstractSyntaxTree.nodes[0];\n    let selectedRule;\n\n    // Merge global and tag-specific styles into new AST.\n    if (allowedStyles[astRules.selector] && allowedStyles['*']) {\n      selectedRule = deepmerge(\n        allowedStyles[astRules.selector],\n        allowedStyles['*']\n      );\n    } else {\n      selectedRule = allowedStyles[astRules.selector] || allowedStyles['*'];\n    }\n\n    if (selectedRule) {\n      abstractSyntaxTree.nodes[0].nodes = astRules.nodes.reduce(filterDeclarations(selectedRule), []);\n    }\n\n    return abstractSyntaxTree;\n  }\n\n  /**\n   * Extracts the style attributes from an AbstractSyntaxTree and formats those\n   * values in the inline style attribute format.\n   *\n   * @param  {AbstractSyntaxTree} filteredAST\n   * @return {string}             - Example: \"color:yellow;text-align:center !important;font-family:helvetica;\"\n   */\n  function stringifyStyleAttributes(filteredAST) {\n    return filteredAST.nodes[0].nodes\n      .reduce(function(extractedAttributes, attrObject) {\n        extractedAttributes.push(\n          `${attrObject.prop}:${attrObject.value}${attrObject.important ? ' !important' : ''}`\n        );\n        return extractedAttributes;\n      }, [])\n      .join(';');\n  }\n\n  /**\n    * Filters the existing attributes for the given property. Discards any attributes\n    * which don't match the allowlist.\n    *\n    * @param  {object} selectedRule             - Example: { color: red, font-family: helvetica }\n    * @param  {array} allowedDeclarationsList   - List of declarations which pass the allowlist.\n    * @param  {object} attributeObject          - Object representing the current css property.\n    * @property {string} attributeObject.type   - Typically 'declaration'.\n    * @property {string} attributeObject.prop   - The CSS property, i.e 'color'.\n    * @property {string} attributeObject.value  - The corresponding value to the css property, i.e 'red'.\n    * @return {function}                        - When used in Array.reduce, will return an array of Declaration objects\n    */\n  function filterDeclarations(selectedRule) {\n    return function (allowedDeclarationsList, attributeObject) {\n      // If this property is allowlisted...\n      if (has(selectedRule, attributeObject.prop)) {\n        const matchesRegex = selectedRule[attributeObject.prop].some(function(regularExpression) {\n          return regularExpression.test(attributeObject.value);\n        });\n\n        if (matchesRegex) {\n          allowedDeclarationsList.push(attributeObject);\n        }\n      }\n      return allowedDeclarationsList;\n    };\n  }\n\n  function filterClasses(classes, allowed, allowedGlobs) {\n    if (!allowed) {\n      // The class attribute is allowed without filtering on this tag\n      return classes;\n    }\n    classes = classes.split(/\\s+/);\n    return classes.filter(function(clss) {\n      return allowed.indexOf(clss) !== -1 || allowedGlobs.some(function(glob) {\n        return glob.test(clss);\n      });\n    }).join(' ');\n  }\n}\n\n// Defaults are accessible to you so that you can use them as a starting point\n// programmatically if you wish\n\nconst htmlParserDefaults = {\n  decodeEntities: true\n};\nsanitizeHtml.defaults = {\n  allowedTags: [\n    // Sections derived from MDN element categories and limited to the more\n    // benign categories.\n    // https://developer.mozilla.org/en-US/docs/Web/HTML/Element\n    // Content sectioning\n    'address', 'article', 'aside', 'footer', 'header',\n    'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'hgroup',\n    'main', 'nav', 'section',\n    // Text content\n    'blockquote', 'dd', 'div', 'dl', 'dt', 'figcaption', 'figure',\n    'hr', 'li', 'main', 'ol', 'p', 'pre', 'ul',\n    // Inline text semantics\n    'a', 'abbr', 'b', 'bdi', 'bdo', 'br', 'cite', 'code', 'data', 'dfn',\n    'em', 'i', 'kbd', 'mark', 'q',\n    'rb', 'rp', 'rt', 'rtc', 'ruby',\n    's', 'samp', 'small', 'span', 'strong', 'sub', 'sup', 'time', 'u', 'var', 'wbr',\n    // Table content\n    'caption', 'col', 'colgroup', 'table', 'tbody', 'td', 'tfoot', 'th',\n    'thead', 'tr'\n  ],\n  disallowedTagsMode: 'discard',\n  allowedAttributes: {\n    a: [ 'href', 'name', 'target' ],\n    // We don't currently allow img itself by default, but\n    // these attributes would make sense if we did.\n    img: [ 'src', 'srcset', 'alt', 'title', 'width', 'height', 'loading' ]\n  },\n  // Lots of these won't come up by default because we don't allow them\n  selfClosing: [ 'img', 'br', 'hr', 'area', 'base', 'basefont', 'input', 'link', 'meta' ],\n  // URL schemes we permit\n  allowedSchemes: [ 'http', 'https', 'ftp', 'mailto', 'tel' ],\n  allowedSchemesByTag: {},\n  allowedSchemesAppliedToAttributes: [ 'href', 'src', 'cite' ],\n  allowProtocolRelative: true,\n  enforceHtmlBoundary: false\n};\n\nsanitizeHtml.simpleTransform = function(newTagName, newAttribs, merge) {\n  merge = (merge === undefined) ? true : merge;\n  newAttribs = newAttribs || {};\n\n  return function(tagName, attribs) {\n    let attrib;\n    if (merge) {\n      for (attrib in newAttribs) {\n        attribs[attrib] = newAttribs[attrib];\n      }\n    } else {\n      attribs = newAttribs;\n    }\n\n    return {\n      tagName: newTagName,\n      attribs: attribs\n    };\n  };\n};\n","'use strict'\n\nconst 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    /* 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  document(node) {\n    this.body(node)\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    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  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.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  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  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  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.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  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\nmodule.exports = Stringifier\nStringifier.default = Stringifier\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","'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\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        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\nmodule.exports = Warning\nWarning.default = Warning\n","/**\r\n * A collection of shims that provide minimal functionality of the ES6 collections.\r\n *\r\n * These implementations are not meant to be used outside of the ResizeObserver\r\n * modules as they cover only a limited range of use cases.\r\n */\r\n/* eslint-disable require-jsdoc, valid-jsdoc */\r\nvar MapShim = (function () {\r\n    if (typeof Map !== 'undefined') {\r\n        return Map;\r\n    }\r\n    /**\r\n     * Returns index in provided array that matches the specified key.\r\n     *\r\n     * @param {Array<Array>} arr\r\n     * @param {*} key\r\n     * @returns {number}\r\n     */\r\n    function getIndex(arr, key) {\r\n        var result = -1;\r\n        arr.some(function (entry, index) {\r\n            if (entry[0] === key) {\r\n                result = index;\r\n                return true;\r\n            }\r\n            return false;\r\n        });\r\n        return result;\r\n    }\r\n    return /** @class */ (function () {\r\n        function class_1() {\r\n            this.__entries__ = [];\r\n        }\r\n        Object.defineProperty(class_1.prototype, \"size\", {\r\n            /**\r\n             * @returns {boolean}\r\n             */\r\n            get: function () {\r\n                return this.__entries__.length;\r\n            },\r\n            enumerable: true,\r\n            configurable: true\r\n        });\r\n        /**\r\n         * @param {*} key\r\n         * @returns {*}\r\n         */\r\n        class_1.prototype.get = function (key) {\r\n            var index = getIndex(this.__entries__, key);\r\n            var entry = this.__entries__[index];\r\n            return entry && entry[1];\r\n        };\r\n        /**\r\n         * @param {*} key\r\n         * @param {*} value\r\n         * @returns {void}\r\n         */\r\n        class_1.prototype.set = function (key, value) {\r\n            var index = getIndex(this.__entries__, key);\r\n            if (~index) {\r\n                this.__entries__[index][1] = value;\r\n            }\r\n            else {\r\n                this.__entries__.push([key, value]);\r\n            }\r\n        };\r\n        /**\r\n         * @param {*} key\r\n         * @returns {void}\r\n         */\r\n        class_1.prototype.delete = function (key) {\r\n            var entries = this.__entries__;\r\n            var index = getIndex(entries, key);\r\n            if (~index) {\r\n                entries.splice(index, 1);\r\n            }\r\n        };\r\n        /**\r\n         * @param {*} key\r\n         * @returns {void}\r\n         */\r\n        class_1.prototype.has = function (key) {\r\n            return !!~getIndex(this.__entries__, key);\r\n        };\r\n        /**\r\n         * @returns {void}\r\n         */\r\n        class_1.prototype.clear = function () {\r\n            this.__entries__.splice(0);\r\n        };\r\n        /**\r\n         * @param {Function} callback\r\n         * @param {*} [ctx=null]\r\n         * @returns {void}\r\n         */\r\n        class_1.prototype.forEach = function (callback, ctx) {\r\n            if (ctx === void 0) { ctx = null; }\r\n            for (var _i = 0, _a = this.__entries__; _i < _a.length; _i++) {\r\n                var entry = _a[_i];\r\n                callback.call(ctx, entry[1], entry[0]);\r\n            }\r\n        };\r\n        return class_1;\r\n    }());\r\n})();\n\n/**\r\n * Detects whether window and document objects are available in current environment.\r\n */\r\nvar isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined' && window.document === document;\n\n// Returns global object of a current environment.\r\nvar global$1 = (function () {\r\n    if (typeof global !== 'undefined' && global.Math === Math) {\r\n        return global;\r\n    }\r\n    if (typeof self !== 'undefined' && self.Math === Math) {\r\n        return self;\r\n    }\r\n    if (typeof window !== 'undefined' && window.Math === Math) {\r\n        return window;\r\n    }\r\n    // eslint-disable-next-line no-new-func\r\n    return Function('return this')();\r\n})();\n\n/**\r\n * A shim for the requestAnimationFrame which falls back to the setTimeout if\r\n * first one is not supported.\r\n *\r\n * @returns {number} Requests' identifier.\r\n */\r\nvar requestAnimationFrame$1 = (function () {\r\n    if (typeof requestAnimationFrame === 'function') {\r\n        // It's required to use a bounded function because IE sometimes throws\r\n        // an \"Invalid calling object\" error if rAF is invoked without the global\r\n        // object on the left hand side.\r\n        return requestAnimationFrame.bind(global$1);\r\n    }\r\n    return function (callback) { return setTimeout(function () { return callback(Date.now()); }, 1000 / 60); };\r\n})();\n\n// Defines minimum timeout before adding a trailing call.\r\nvar trailingTimeout = 2;\r\n/**\r\n * Creates a wrapper function which ensures that provided callback will be\r\n * invoked only once during the specified delay period.\r\n *\r\n * @param {Function} callback - Function to be invoked after the delay period.\r\n * @param {number} delay - Delay after which to invoke callback.\r\n * @returns {Function}\r\n */\r\nfunction throttle (callback, delay) {\r\n    var leadingCall = false, trailingCall = false, lastCallTime = 0;\r\n    /**\r\n     * Invokes the original callback function and schedules new invocation if\r\n     * the \"proxy\" was called during current request.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    function resolvePending() {\r\n        if (leadingCall) {\r\n            leadingCall = false;\r\n            callback();\r\n        }\r\n        if (trailingCall) {\r\n            proxy();\r\n        }\r\n    }\r\n    /**\r\n     * Callback invoked after the specified delay. It will further postpone\r\n     * invocation of the original function delegating it to the\r\n     * requestAnimationFrame.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    function timeoutCallback() {\r\n        requestAnimationFrame$1(resolvePending);\r\n    }\r\n    /**\r\n     * Schedules invocation of the original function.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    function proxy() {\r\n        var timeStamp = Date.now();\r\n        if (leadingCall) {\r\n            // Reject immediately following calls.\r\n            if (timeStamp - lastCallTime < trailingTimeout) {\r\n                return;\r\n            }\r\n            // Schedule new call to be in invoked when the pending one is resolved.\r\n            // This is important for \"transitions\" which never actually start\r\n            // immediately so there is a chance that we might miss one if change\r\n            // happens amids the pending invocation.\r\n            trailingCall = true;\r\n        }\r\n        else {\r\n            leadingCall = true;\r\n            trailingCall = false;\r\n            setTimeout(timeoutCallback, delay);\r\n        }\r\n        lastCallTime = timeStamp;\r\n    }\r\n    return proxy;\r\n}\n\n// Minimum delay before invoking the update of observers.\r\nvar REFRESH_DELAY = 20;\r\n// A list of substrings of CSS properties used to find transition events that\r\n// might affect dimensions of observed elements.\r\nvar transitionKeys = ['top', 'right', 'bottom', 'left', 'width', 'height', 'size', 'weight'];\r\n// Check if MutationObserver is available.\r\nvar mutationObserverSupported = typeof MutationObserver !== 'undefined';\r\n/**\r\n * Singleton controller class which handles updates of ResizeObserver instances.\r\n */\r\nvar ResizeObserverController = /** @class */ (function () {\r\n    /**\r\n     * Creates a new instance of ResizeObserverController.\r\n     *\r\n     * @private\r\n     */\r\n    function ResizeObserverController() {\r\n        /**\r\n         * Indicates whether DOM listeners have been added.\r\n         *\r\n         * @private {boolean}\r\n         */\r\n        this.connected_ = false;\r\n        /**\r\n         * Tells that controller has subscribed for Mutation Events.\r\n         *\r\n         * @private {boolean}\r\n         */\r\n        this.mutationEventsAdded_ = false;\r\n        /**\r\n         * Keeps reference to the instance of MutationObserver.\r\n         *\r\n         * @private {MutationObserver}\r\n         */\r\n        this.mutationsObserver_ = null;\r\n        /**\r\n         * A list of connected observers.\r\n         *\r\n         * @private {Array<ResizeObserverSPI>}\r\n         */\r\n        this.observers_ = [];\r\n        this.onTransitionEnd_ = this.onTransitionEnd_.bind(this);\r\n        this.refresh = throttle(this.refresh.bind(this), REFRESH_DELAY);\r\n    }\r\n    /**\r\n     * Adds observer to observers list.\r\n     *\r\n     * @param {ResizeObserverSPI} observer - Observer to be added.\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.addObserver = function (observer) {\r\n        if (!~this.observers_.indexOf(observer)) {\r\n            this.observers_.push(observer);\r\n        }\r\n        // Add listeners if they haven't been added yet.\r\n        if (!this.connected_) {\r\n            this.connect_();\r\n        }\r\n    };\r\n    /**\r\n     * Removes observer from observers list.\r\n     *\r\n     * @param {ResizeObserverSPI} observer - Observer to be removed.\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.removeObserver = function (observer) {\r\n        var observers = this.observers_;\r\n        var index = observers.indexOf(observer);\r\n        // Remove observer if it's present in registry.\r\n        if (~index) {\r\n            observers.splice(index, 1);\r\n        }\r\n        // Remove listeners if controller has no connected observers.\r\n        if (!observers.length && this.connected_) {\r\n            this.disconnect_();\r\n        }\r\n    };\r\n    /**\r\n     * Invokes the update of observers. It will continue running updates insofar\r\n     * it detects changes.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.refresh = function () {\r\n        var changesDetected = this.updateObservers_();\r\n        // Continue running updates if changes have been detected as there might\r\n        // be future ones caused by CSS transitions.\r\n        if (changesDetected) {\r\n            this.refresh();\r\n        }\r\n    };\r\n    /**\r\n     * Updates every observer from observers list and notifies them of queued\r\n     * entries.\r\n     *\r\n     * @private\r\n     * @returns {boolean} Returns \"true\" if any observer has detected changes in\r\n     *      dimensions of it's elements.\r\n     */\r\n    ResizeObserverController.prototype.updateObservers_ = function () {\r\n        // Collect observers that have active observations.\r\n        var activeObservers = this.observers_.filter(function (observer) {\r\n            return observer.gatherActive(), observer.hasActive();\r\n        });\r\n        // Deliver notifications in a separate cycle in order to avoid any\r\n        // collisions between observers, e.g. when multiple instances of\r\n        // ResizeObserver are tracking the same element and the callback of one\r\n        // of them changes content dimensions of the observed target. Sometimes\r\n        // this may result in notifications being blocked for the rest of observers.\r\n        activeObservers.forEach(function (observer) { return observer.broadcastActive(); });\r\n        return activeObservers.length > 0;\r\n    };\r\n    /**\r\n     * Initializes DOM listeners.\r\n     *\r\n     * @private\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.connect_ = function () {\r\n        // Do nothing if running in a non-browser environment or if listeners\r\n        // have been already added.\r\n        if (!isBrowser || this.connected_) {\r\n            return;\r\n        }\r\n        // Subscription to the \"Transitionend\" event is used as a workaround for\r\n        // delayed transitions. This way it's possible to capture at least the\r\n        // final state of an element.\r\n        document.addEventListener('transitionend', this.onTransitionEnd_);\r\n        window.addEventListener('resize', this.refresh);\r\n        if (mutationObserverSupported) {\r\n            this.mutationsObserver_ = new MutationObserver(this.refresh);\r\n            this.mutationsObserver_.observe(document, {\r\n                attributes: true,\r\n                childList: true,\r\n                characterData: true,\r\n                subtree: true\r\n            });\r\n        }\r\n        else {\r\n            document.addEventListener('DOMSubtreeModified', this.refresh);\r\n            this.mutationEventsAdded_ = true;\r\n        }\r\n        this.connected_ = true;\r\n    };\r\n    /**\r\n     * Removes DOM listeners.\r\n     *\r\n     * @private\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.disconnect_ = function () {\r\n        // Do nothing if running in a non-browser environment or if listeners\r\n        // have been already removed.\r\n        if (!isBrowser || !this.connected_) {\r\n            return;\r\n        }\r\n        document.removeEventListener('transitionend', this.onTransitionEnd_);\r\n        window.removeEventListener('resize', this.refresh);\r\n        if (this.mutationsObserver_) {\r\n            this.mutationsObserver_.disconnect();\r\n        }\r\n        if (this.mutationEventsAdded_) {\r\n            document.removeEventListener('DOMSubtreeModified', this.refresh);\r\n        }\r\n        this.mutationsObserver_ = null;\r\n        this.mutationEventsAdded_ = false;\r\n        this.connected_ = false;\r\n    };\r\n    /**\r\n     * \"Transitionend\" event handler.\r\n     *\r\n     * @private\r\n     * @param {TransitionEvent} event\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.onTransitionEnd_ = function (_a) {\r\n        var _b = _a.propertyName, propertyName = _b === void 0 ? '' : _b;\r\n        // Detect whether transition may affect dimensions of an element.\r\n        var isReflowProperty = transitionKeys.some(function (key) {\r\n            return !!~propertyName.indexOf(key);\r\n        });\r\n        if (isReflowProperty) {\r\n            this.refresh();\r\n        }\r\n    };\r\n    /**\r\n     * Returns instance of the ResizeObserverController.\r\n     *\r\n     * @returns {ResizeObserverController}\r\n     */\r\n    ResizeObserverController.getInstance = function () {\r\n        if (!this.instance_) {\r\n            this.instance_ = new ResizeObserverController();\r\n        }\r\n        return this.instance_;\r\n    };\r\n    /**\r\n     * Holds reference to the controller's instance.\r\n     *\r\n     * @private {ResizeObserverController}\r\n     */\r\n    ResizeObserverController.instance_ = null;\r\n    return ResizeObserverController;\r\n}());\n\n/**\r\n * Defines non-writable/enumerable properties of the provided target object.\r\n *\r\n * @param {Object} target - Object for which to define properties.\r\n * @param {Object} props - Properties to be defined.\r\n * @returns {Object} Target object.\r\n */\r\nvar defineConfigurable = (function (target, props) {\r\n    for (var _i = 0, _a = Object.keys(props); _i < _a.length; _i++) {\r\n        var key = _a[_i];\r\n        Object.defineProperty(target, key, {\r\n            value: props[key],\r\n            enumerable: false,\r\n            writable: false,\r\n            configurable: true\r\n        });\r\n    }\r\n    return target;\r\n});\n\n/**\r\n * Returns the global object associated with provided element.\r\n *\r\n * @param {Object} target\r\n * @returns {Object}\r\n */\r\nvar getWindowOf = (function (target) {\r\n    // Assume that the element is an instance of Node, which means that it\r\n    // has the \"ownerDocument\" property from which we can retrieve a\r\n    // corresponding global object.\r\n    var ownerGlobal = target && target.ownerDocument && target.ownerDocument.defaultView;\r\n    // Return the local global object if it's not possible extract one from\r\n    // provided element.\r\n    return ownerGlobal || global$1;\r\n});\n\n// Placeholder of an empty content rectangle.\r\nvar emptyRect = createRectInit(0, 0, 0, 0);\r\n/**\r\n * Converts provided string to a number.\r\n *\r\n * @param {number|string} value\r\n * @returns {number}\r\n */\r\nfunction toFloat(value) {\r\n    return parseFloat(value) || 0;\r\n}\r\n/**\r\n * Extracts borders size from provided styles.\r\n *\r\n * @param {CSSStyleDeclaration} styles\r\n * @param {...string} positions - Borders positions (top, right, ...)\r\n * @returns {number}\r\n */\r\nfunction getBordersSize(styles) {\r\n    var positions = [];\r\n    for (var _i = 1; _i < arguments.length; _i++) {\r\n        positions[_i - 1] = arguments[_i];\r\n    }\r\n    return positions.reduce(function (size, position) {\r\n        var value = styles['border-' + position + '-width'];\r\n        return size + toFloat(value);\r\n    }, 0);\r\n}\r\n/**\r\n * Extracts paddings sizes from provided styles.\r\n *\r\n * @param {CSSStyleDeclaration} styles\r\n * @returns {Object} Paddings box.\r\n */\r\nfunction getPaddings(styles) {\r\n    var positions = ['top', 'right', 'bottom', 'left'];\r\n    var paddings = {};\r\n    for (var _i = 0, positions_1 = positions; _i < positions_1.length; _i++) {\r\n        var position = positions_1[_i];\r\n        var value = styles['padding-' + position];\r\n        paddings[position] = toFloat(value);\r\n    }\r\n    return paddings;\r\n}\r\n/**\r\n * Calculates content rectangle of provided SVG element.\r\n *\r\n * @param {SVGGraphicsElement} target - Element content rectangle of which needs\r\n *      to be calculated.\r\n * @returns {DOMRectInit}\r\n */\r\nfunction getSVGContentRect(target) {\r\n    var bbox = target.getBBox();\r\n    return createRectInit(0, 0, bbox.width, bbox.height);\r\n}\r\n/**\r\n * Calculates content rectangle of provided HTMLElement.\r\n *\r\n * @param {HTMLElement} target - Element for which to calculate the content rectangle.\r\n * @returns {DOMRectInit}\r\n */\r\nfunction getHTMLElementContentRect(target) {\r\n    // Client width & height properties can't be\r\n    // used exclusively as they provide rounded values.\r\n    var clientWidth = target.clientWidth, clientHeight = target.clientHeight;\r\n    // By this condition we can catch all non-replaced inline, hidden and\r\n    // detached elements. Though elements with width & height properties less\r\n    // than 0.5 will be discarded as well.\r\n    //\r\n    // Without it we would need to implement separate methods for each of\r\n    // those cases and it's not possible to perform a precise and performance\r\n    // effective test for hidden elements. E.g. even jQuery's ':visible' filter\r\n    // gives wrong results for elements with width & height less than 0.5.\r\n    if (!clientWidth && !clientHeight) {\r\n        return emptyRect;\r\n    }\r\n    var styles = getWindowOf(target).getComputedStyle(target);\r\n    var paddings = getPaddings(styles);\r\n    var horizPad = paddings.left + paddings.right;\r\n    var vertPad = paddings.top + paddings.bottom;\r\n    // Computed styles of width & height are being used because they are the\r\n    // only dimensions available to JS that contain non-rounded values. It could\r\n    // be possible to utilize the getBoundingClientRect if only it's data wasn't\r\n    // affected by CSS transformations let alone paddings, borders and scroll bars.\r\n    var width = toFloat(styles.width), height = toFloat(styles.height);\r\n    // Width & height include paddings and borders when the 'border-box' box\r\n    // model is applied (except for IE).\r\n    if (styles.boxSizing === 'border-box') {\r\n        // Following conditions are required to handle Internet Explorer which\r\n        // doesn't include paddings and borders to computed CSS dimensions.\r\n        //\r\n        // We can say that if CSS dimensions + paddings are equal to the \"client\"\r\n        // properties then it's either IE, and thus we don't need to subtract\r\n        // anything, or an element merely doesn't have paddings/borders styles.\r\n        if (Math.round(width + horizPad) !== clientWidth) {\r\n            width -= getBordersSize(styles, 'left', 'right') + horizPad;\r\n        }\r\n        if (Math.round(height + vertPad) !== clientHeight) {\r\n            height -= getBordersSize(styles, 'top', 'bottom') + vertPad;\r\n        }\r\n    }\r\n    // Following steps can't be applied to the document's root element as its\r\n    // client[Width/Height] properties represent viewport area of the window.\r\n    // Besides, it's as well not necessary as the <html> itself neither has\r\n    // rendered scroll bars nor it can be clipped.\r\n    if (!isDocumentElement(target)) {\r\n        // In some browsers (only in Firefox, actually) CSS width & height\r\n        // include scroll bars size which can be removed at this step as scroll\r\n        // bars are the only difference between rounded dimensions + paddings\r\n        // and \"client\" properties, though that is not always true in Chrome.\r\n        var vertScrollbar = Math.round(width + horizPad) - clientWidth;\r\n        var horizScrollbar = Math.round(height + vertPad) - clientHeight;\r\n        // Chrome has a rather weird rounding of \"client\" properties.\r\n        // E.g. for an element with content width of 314.2px it sometimes gives\r\n        // the client width of 315px and for the width of 314.7px it may give\r\n        // 314px. And it doesn't happen all the time. So just ignore this delta\r\n        // as a non-relevant.\r\n        if (Math.abs(vertScrollbar) !== 1) {\r\n            width -= vertScrollbar;\r\n        }\r\n        if (Math.abs(horizScrollbar) !== 1) {\r\n            height -= horizScrollbar;\r\n        }\r\n    }\r\n    return createRectInit(paddings.left, paddings.top, width, height);\r\n}\r\n/**\r\n * Checks whether provided element is an instance of the SVGGraphicsElement.\r\n *\r\n * @param {Element} target - Element to be checked.\r\n * @returns {boolean}\r\n */\r\nvar isSVGGraphicsElement = (function () {\r\n    // Some browsers, namely IE and Edge, don't have the SVGGraphicsElement\r\n    // interface.\r\n    if (typeof SVGGraphicsElement !== 'undefined') {\r\n        return function (target) { return target instanceof getWindowOf(target).SVGGraphicsElement; };\r\n    }\r\n    // If it's so, then check that element is at least an instance of the\r\n    // SVGElement and that it has the \"getBBox\" method.\r\n    // eslint-disable-next-line no-extra-parens\r\n    return function (target) { return (target instanceof getWindowOf(target).SVGElement &&\r\n        typeof target.getBBox === 'function'); };\r\n})();\r\n/**\r\n * Checks whether provided element is a document element (<html>).\r\n *\r\n * @param {Element} target - Element to be checked.\r\n * @returns {boolean}\r\n */\r\nfunction isDocumentElement(target) {\r\n    return target === getWindowOf(target).document.documentElement;\r\n}\r\n/**\r\n * Calculates an appropriate content rectangle for provided html or svg element.\r\n *\r\n * @param {Element} target - Element content rectangle of which needs to be calculated.\r\n * @returns {DOMRectInit}\r\n */\r\nfunction getContentRect(target) {\r\n    if (!isBrowser) {\r\n        return emptyRect;\r\n    }\r\n    if (isSVGGraphicsElement(target)) {\r\n        return getSVGContentRect(target);\r\n    }\r\n    return getHTMLElementContentRect(target);\r\n}\r\n/**\r\n * Creates rectangle with an interface of the DOMRectReadOnly.\r\n * Spec: https://drafts.fxtf.org/geometry/#domrectreadonly\r\n *\r\n * @param {DOMRectInit} rectInit - Object with rectangle's x/y coordinates and dimensions.\r\n * @returns {DOMRectReadOnly}\r\n */\r\nfunction createReadOnlyRect(_a) {\r\n    var x = _a.x, y = _a.y, width = _a.width, height = _a.height;\r\n    // If DOMRectReadOnly is available use it as a prototype for the rectangle.\r\n    var Constr = typeof DOMRectReadOnly !== 'undefined' ? DOMRectReadOnly : Object;\r\n    var rect = Object.create(Constr.prototype);\r\n    // Rectangle's properties are not writable and non-enumerable.\r\n    defineConfigurable(rect, {\r\n        x: x, y: y, width: width, height: height,\r\n        top: y,\r\n        right: x + width,\r\n        bottom: height + y,\r\n        left: x\r\n    });\r\n    return rect;\r\n}\r\n/**\r\n * Creates DOMRectInit object based on the provided dimensions and the x/y coordinates.\r\n * Spec: https://drafts.fxtf.org/geometry/#dictdef-domrectinit\r\n *\r\n * @param {number} x - X coordinate.\r\n * @param {number} y - Y coordinate.\r\n * @param {number} width - Rectangle's width.\r\n * @param {number} height - Rectangle's height.\r\n * @returns {DOMRectInit}\r\n */\r\nfunction createRectInit(x, y, width, height) {\r\n    return { x: x, y: y, width: width, height: height };\r\n}\n\n/**\r\n * Class that is responsible for computations of the content rectangle of\r\n * provided DOM element and for keeping track of it's changes.\r\n */\r\nvar ResizeObservation = /** @class */ (function () {\r\n    /**\r\n     * Creates an instance of ResizeObservation.\r\n     *\r\n     * @param {Element} target - Element to be observed.\r\n     */\r\n    function ResizeObservation(target) {\r\n        /**\r\n         * Broadcasted width of content rectangle.\r\n         *\r\n         * @type {number}\r\n         */\r\n        this.broadcastWidth = 0;\r\n        /**\r\n         * Broadcasted height of content rectangle.\r\n         *\r\n         * @type {number}\r\n         */\r\n        this.broadcastHeight = 0;\r\n        /**\r\n         * Reference to the last observed content rectangle.\r\n         *\r\n         * @private {DOMRectInit}\r\n         */\r\n        this.contentRect_ = createRectInit(0, 0, 0, 0);\r\n        this.target = target;\r\n    }\r\n    /**\r\n     * Updates content rectangle and tells whether it's width or height properties\r\n     * have changed since the last broadcast.\r\n     *\r\n     * @returns {boolean}\r\n     */\r\n    ResizeObservation.prototype.isActive = function () {\r\n        var rect = getContentRect(this.target);\r\n        this.contentRect_ = rect;\r\n        return (rect.width !== this.broadcastWidth ||\r\n            rect.height !== this.broadcastHeight);\r\n    };\r\n    /**\r\n     * Updates 'broadcastWidth' and 'broadcastHeight' properties with a data\r\n     * from the corresponding properties of the last observed content rectangle.\r\n     *\r\n     * @returns {DOMRectInit} Last observed content rectangle.\r\n     */\r\n    ResizeObservation.prototype.broadcastRect = function () {\r\n        var rect = this.contentRect_;\r\n        this.broadcastWidth = rect.width;\r\n        this.broadcastHeight = rect.height;\r\n        return rect;\r\n    };\r\n    return ResizeObservation;\r\n}());\n\nvar ResizeObserverEntry = /** @class */ (function () {\r\n    /**\r\n     * Creates an instance of ResizeObserverEntry.\r\n     *\r\n     * @param {Element} target - Element that is being observed.\r\n     * @param {DOMRectInit} rectInit - Data of the element's content rectangle.\r\n     */\r\n    function ResizeObserverEntry(target, rectInit) {\r\n        var contentRect = createReadOnlyRect(rectInit);\r\n        // According to the specification following properties are not writable\r\n        // and are also not enumerable in the native implementation.\r\n        //\r\n        // Property accessors are not being used as they'd require to define a\r\n        // private WeakMap storage which may cause memory leaks in browsers that\r\n        // don't support this type of collections.\r\n        defineConfigurable(this, { target: target, contentRect: contentRect });\r\n    }\r\n    return ResizeObserverEntry;\r\n}());\n\nvar ResizeObserverSPI = /** @class */ (function () {\r\n    /**\r\n     * Creates a new instance of ResizeObserver.\r\n     *\r\n     * @param {ResizeObserverCallback} callback - Callback function that is invoked\r\n     *      when one of the observed elements changes it's content dimensions.\r\n     * @param {ResizeObserverController} controller - Controller instance which\r\n     *      is responsible for the updates of observer.\r\n     * @param {ResizeObserver} callbackCtx - Reference to the public\r\n     *      ResizeObserver instance which will be passed to callback function.\r\n     */\r\n    function ResizeObserverSPI(callback, controller, callbackCtx) {\r\n        /**\r\n         * Collection of resize observations that have detected changes in dimensions\r\n         * of elements.\r\n         *\r\n         * @private {Array<ResizeObservation>}\r\n         */\r\n        this.activeObservations_ = [];\r\n        /**\r\n         * Registry of the ResizeObservation instances.\r\n         *\r\n         * @private {Map<Element, ResizeObservation>}\r\n         */\r\n        this.observations_ = new MapShim();\r\n        if (typeof callback !== 'function') {\r\n            throw new TypeError('The callback provided as parameter 1 is not a function.');\r\n        }\r\n        this.callback_ = callback;\r\n        this.controller_ = controller;\r\n        this.callbackCtx_ = callbackCtx;\r\n    }\r\n    /**\r\n     * Starts observing provided element.\r\n     *\r\n     * @param {Element} target - Element to be observed.\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.observe = function (target) {\r\n        if (!arguments.length) {\r\n            throw new TypeError('1 argument required, but only 0 present.');\r\n        }\r\n        // Do nothing if current environment doesn't have the Element interface.\r\n        if (typeof Element === 'undefined' || !(Element instanceof Object)) {\r\n            return;\r\n        }\r\n        if (!(target instanceof getWindowOf(target).Element)) {\r\n            throw new TypeError('parameter 1 is not of type \"Element\".');\r\n        }\r\n        var observations = this.observations_;\r\n        // Do nothing if element is already being observed.\r\n        if (observations.has(target)) {\r\n            return;\r\n        }\r\n        observations.set(target, new ResizeObservation(target));\r\n        this.controller_.addObserver(this);\r\n        // Force the update of observations.\r\n        this.controller_.refresh();\r\n    };\r\n    /**\r\n     * Stops observing provided element.\r\n     *\r\n     * @param {Element} target - Element to stop observing.\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.unobserve = function (target) {\r\n        if (!arguments.length) {\r\n            throw new TypeError('1 argument required, but only 0 present.');\r\n        }\r\n        // Do nothing if current environment doesn't have the Element interface.\r\n        if (typeof Element === 'undefined' || !(Element instanceof Object)) {\r\n            return;\r\n        }\r\n        if (!(target instanceof getWindowOf(target).Element)) {\r\n            throw new TypeError('parameter 1 is not of type \"Element\".');\r\n        }\r\n        var observations = this.observations_;\r\n        // Do nothing if element is not being observed.\r\n        if (!observations.has(target)) {\r\n            return;\r\n        }\r\n        observations.delete(target);\r\n        if (!observations.size) {\r\n            this.controller_.removeObserver(this);\r\n        }\r\n    };\r\n    /**\r\n     * Stops observing all elements.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.disconnect = function () {\r\n        this.clearActive();\r\n        this.observations_.clear();\r\n        this.controller_.removeObserver(this);\r\n    };\r\n    /**\r\n     * Collects observation instances the associated element of which has changed\r\n     * it's content rectangle.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.gatherActive = function () {\r\n        var _this = this;\r\n        this.clearActive();\r\n        this.observations_.forEach(function (observation) {\r\n            if (observation.isActive()) {\r\n                _this.activeObservations_.push(observation);\r\n            }\r\n        });\r\n    };\r\n    /**\r\n     * Invokes initial callback function with a list of ResizeObserverEntry\r\n     * instances collected from active resize observations.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.broadcastActive = function () {\r\n        // Do nothing if observer doesn't have active observations.\r\n        if (!this.hasActive()) {\r\n            return;\r\n        }\r\n        var ctx = this.callbackCtx_;\r\n        // Create ResizeObserverEntry instance for every active observation.\r\n        var entries = this.activeObservations_.map(function (observation) {\r\n            return new ResizeObserverEntry(observation.target, observation.broadcastRect());\r\n        });\r\n        this.callback_.call(ctx, entries, ctx);\r\n        this.clearActive();\r\n    };\r\n    /**\r\n     * Clears the collection of active observations.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.clearActive = function () {\r\n        this.activeObservations_.splice(0);\r\n    };\r\n    /**\r\n     * Tells whether observer has active observations.\r\n     *\r\n     * @returns {boolean}\r\n     */\r\n    ResizeObserverSPI.prototype.hasActive = function () {\r\n        return this.activeObservations_.length > 0;\r\n    };\r\n    return ResizeObserverSPI;\r\n}());\n\n// Registry of internal observers. If WeakMap is not available use current shim\r\n// for the Map collection as it has all required methods and because WeakMap\r\n// can't be fully polyfilled anyway.\r\nvar observers = typeof WeakMap !== 'undefined' ? new WeakMap() : new MapShim();\r\n/**\r\n * ResizeObserver API. Encapsulates the ResizeObserver SPI implementation\r\n * exposing only those methods and properties that are defined in the spec.\r\n */\r\nvar ResizeObserver = /** @class */ (function () {\r\n    /**\r\n     * Creates a new instance of ResizeObserver.\r\n     *\r\n     * @param {ResizeObserverCallback} callback - Callback that is invoked when\r\n     *      dimensions of the observed elements change.\r\n     */\r\n    function ResizeObserver(callback) {\r\n        if (!(this instanceof ResizeObserver)) {\r\n            throw new TypeError('Cannot call a class as a function.');\r\n        }\r\n        if (!arguments.length) {\r\n            throw new TypeError('1 argument required, but only 0 present.');\r\n        }\r\n        var controller = ResizeObserverController.getInstance();\r\n        var observer = new ResizeObserverSPI(callback, controller, this);\r\n        observers.set(this, observer);\r\n    }\r\n    return ResizeObserver;\r\n}());\r\n// Expose public methods of ResizeObserver.\r\n[\r\n    'observe',\r\n    'unobserve',\r\n    'disconnect'\r\n].forEach(function (method) {\r\n    ResizeObserver.prototype[method] = function () {\r\n        var _a;\r\n        return (_a = observers.get(this))[method].apply(_a, arguments);\r\n    };\r\n});\n\nvar index = (function () {\r\n    // Export existing implementation if available.\r\n    if (typeof global$1.ResizeObserver !== 'undefined') {\r\n        return global$1.ResizeObserver;\r\n    }\r\n    return ResizeObserver;\r\n})();\n\nexport default index;\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 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","/*!\n * is-plain-object <https://github.com/jonschlinkert/is-plain-object>\n *\n * Copyright (c) 2014-2017, Jon Schlinkert.\n * Released under the MIT License.\n */\n\nfunction isObject(o) {\n  return Object.prototype.toString.call(o) === '[object Object]';\n}\n\nfunction isPlainObject(o) {\n  var ctor,prot;\n\n  if (isObject(o) === false) return false;\n\n  // If has modified constructor\n  ctor = o.constructor;\n  if (ctor === undefined) return true;\n\n  // If has modified prototype\n  prot = ctor.prototype;\n  if (isObject(prot) === false) return false;\n\n  // If constructor does not have an Object-specific method\n  if (prot.hasOwnProperty('isPrototypeOf') === false) {\n    return false;\n  }\n\n  // Most likely a plain Object\n  return true;\n}\n\nexport { isPlainObject };\n","module.exports = SafeParseTuple\n\nfunction SafeParseTuple(obj, reviver) {\n    var json\n    var error = null\n\n    try {\n        json = JSON.parse(obj, reviver)\n    } catch (err) {\n        error = err\n    }\n\n    return [error, json]\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.24'\n    this.plugins = this.normalize(plugins)\n  }\n\n  use(plugin) {\n    this.plugins = this.plugins.concat(this.normalize([plugin]))\n    return this\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  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\nmodule.exports = Processor\nProcessor.default = Processor\n\nRoot.registerProcessor(Processor)\nDocument.registerProcessor(Processor)\n","// This file is autogenerated. It's used to publish CJS to npm.\n(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n  typeof define === 'function' && define.amd ? define(factory) :\n  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.tinycolor = factory());\n})(this, (function () { 'use strict';\n\n  function _typeof(obj) {\n    \"@babel/helpers - typeof\";\n\n    return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) {\n      return typeof obj;\n    } : function (obj) {\n      return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n    }, _typeof(obj);\n  }\n\n  // https://github.com/bgrins/TinyColor\n  // Brian Grinstead, MIT License\n\n  var trimLeft = /^\\s+/;\n  var trimRight = /\\s+$/;\n  function tinycolor(color, opts) {\n    color = color ? color : \"\";\n    opts = opts || {};\n\n    // If input is already a tinycolor, return itself\n    if (color instanceof tinycolor) {\n      return color;\n    }\n    // If we are called as a function, call using new instead\n    if (!(this instanceof tinycolor)) {\n      return new tinycolor(color, opts);\n    }\n    var rgb = inputToRGB(color);\n    this._originalInput = color, this._r = rgb.r, this._g = rgb.g, this._b = rgb.b, this._a = rgb.a, this._roundA = Math.round(100 * this._a) / 100, this._format = opts.format || rgb.format;\n    this._gradientType = opts.gradientType;\n\n    // Don't let the range of [0,255] come back in [0,1].\n    // Potentially lose a little bit of precision here, but will fix issues where\n    // .5 gets interpreted as half of the total, instead of half of 1\n    // If it was supposed to be 128, this was already taken care of by `inputToRgb`\n    if (this._r < 1) this._r = Math.round(this._r);\n    if (this._g < 1) this._g = Math.round(this._g);\n    if (this._b < 1) this._b = Math.round(this._b);\n    this._ok = rgb.ok;\n  }\n  tinycolor.prototype = {\n    isDark: function isDark() {\n      return this.getBrightness() < 128;\n    },\n    isLight: function isLight() {\n      return !this.isDark();\n    },\n    isValid: function isValid() {\n      return this._ok;\n    },\n    getOriginalInput: function getOriginalInput() {\n      return this._originalInput;\n    },\n    getFormat: function getFormat() {\n      return this._format;\n    },\n    getAlpha: function getAlpha() {\n      return this._a;\n    },\n    getBrightness: function getBrightness() {\n      //http://www.w3.org/TR/AERT#color-contrast\n      var rgb = this.toRgb();\n      return (rgb.r * 299 + rgb.g * 587 + rgb.b * 114) / 1000;\n    },\n    getLuminance: function getLuminance() {\n      //http://www.w3.org/TR/2008/REC-WCAG20-20081211/#relativeluminancedef\n      var rgb = this.toRgb();\n      var RsRGB, GsRGB, BsRGB, R, G, B;\n      RsRGB = rgb.r / 255;\n      GsRGB = rgb.g / 255;\n      BsRGB = rgb.b / 255;\n      if (RsRGB <= 0.03928) R = RsRGB / 12.92;else R = Math.pow((RsRGB + 0.055) / 1.055, 2.4);\n      if (GsRGB <= 0.03928) G = GsRGB / 12.92;else G = Math.pow((GsRGB + 0.055) / 1.055, 2.4);\n      if (BsRGB <= 0.03928) B = BsRGB / 12.92;else B = Math.pow((BsRGB + 0.055) / 1.055, 2.4);\n      return 0.2126 * R + 0.7152 * G + 0.0722 * B;\n    },\n    setAlpha: function setAlpha(value) {\n      this._a = boundAlpha(value);\n      this._roundA = Math.round(100 * this._a) / 100;\n      return this;\n    },\n    toHsv: function toHsv() {\n      var hsv = rgbToHsv(this._r, this._g, this._b);\n      return {\n        h: hsv.h * 360,\n        s: hsv.s,\n        v: hsv.v,\n        a: this._a\n      };\n    },\n    toHsvString: function toHsvString() {\n      var hsv = rgbToHsv(this._r, this._g, this._b);\n      var h = Math.round(hsv.h * 360),\n        s = Math.round(hsv.s * 100),\n        v = Math.round(hsv.v * 100);\n      return this._a == 1 ? \"hsv(\" + h + \", \" + s + \"%, \" + v + \"%)\" : \"hsva(\" + h + \", \" + s + \"%, \" + v + \"%, \" + this._roundA + \")\";\n    },\n    toHsl: function toHsl() {\n      var hsl = rgbToHsl(this._r, this._g, this._b);\n      return {\n        h: hsl.h * 360,\n        s: hsl.s,\n        l: hsl.l,\n        a: this._a\n      };\n    },\n    toHslString: function toHslString() {\n      var hsl = rgbToHsl(this._r, this._g, this._b);\n      var h = Math.round(hsl.h * 360),\n        s = Math.round(hsl.s * 100),\n        l = Math.round(hsl.l * 100);\n      return this._a == 1 ? \"hsl(\" + h + \", \" + s + \"%, \" + l + \"%)\" : \"hsla(\" + h + \", \" + s + \"%, \" + l + \"%, \" + this._roundA + \")\";\n    },\n    toHex: function toHex(allow3Char) {\n      return rgbToHex(this._r, this._g, this._b, allow3Char);\n    },\n    toHexString: function toHexString(allow3Char) {\n      return \"#\" + this.toHex(allow3Char);\n    },\n    toHex8: function toHex8(allow4Char) {\n      return rgbaToHex(this._r, this._g, this._b, this._a, allow4Char);\n    },\n    toHex8String: function toHex8String(allow4Char) {\n      return \"#\" + this.toHex8(allow4Char);\n    },\n    toRgb: function toRgb() {\n      return {\n        r: Math.round(this._r),\n        g: Math.round(this._g),\n        b: Math.round(this._b),\n        a: this._a\n      };\n    },\n    toRgbString: function toRgbString() {\n      return this._a == 1 ? \"rgb(\" + Math.round(this._r) + \", \" + Math.round(this._g) + \", \" + Math.round(this._b) + \")\" : \"rgba(\" + Math.round(this._r) + \", \" + Math.round(this._g) + \", \" + Math.round(this._b) + \", \" + this._roundA + \")\";\n    },\n    toPercentageRgb: function toPercentageRgb() {\n      return {\n        r: Math.round(bound01(this._r, 255) * 100) + \"%\",\n        g: Math.round(bound01(this._g, 255) * 100) + \"%\",\n        b: Math.round(bound01(this._b, 255) * 100) + \"%\",\n        a: this._a\n      };\n    },\n    toPercentageRgbString: function toPercentageRgbString() {\n      return this._a == 1 ? \"rgb(\" + Math.round(bound01(this._r, 255) * 100) + \"%, \" + Math.round(bound01(this._g, 255) * 100) + \"%, \" + Math.round(bound01(this._b, 255) * 100) + \"%)\" : \"rgba(\" + Math.round(bound01(this._r, 255) * 100) + \"%, \" + Math.round(bound01(this._g, 255) * 100) + \"%, \" + Math.round(bound01(this._b, 255) * 100) + \"%, \" + this._roundA + \")\";\n    },\n    toName: function toName() {\n      if (this._a === 0) {\n        return \"transparent\";\n      }\n      if (this._a < 1) {\n        return false;\n      }\n      return hexNames[rgbToHex(this._r, this._g, this._b, true)] || false;\n    },\n    toFilter: function toFilter(secondColor) {\n      var hex8String = \"#\" + rgbaToArgbHex(this._r, this._g, this._b, this._a);\n      var secondHex8String = hex8String;\n      var gradientType = this._gradientType ? \"GradientType = 1, \" : \"\";\n      if (secondColor) {\n        var s = tinycolor(secondColor);\n        secondHex8String = \"#\" + rgbaToArgbHex(s._r, s._g, s._b, s._a);\n      }\n      return \"progid:DXImageTransform.Microsoft.gradient(\" + gradientType + \"startColorstr=\" + hex8String + \",endColorstr=\" + secondHex8String + \")\";\n    },\n    toString: function toString(format) {\n      var formatSet = !!format;\n      format = format || this._format;\n      var formattedString = false;\n      var hasAlpha = this._a < 1 && this._a >= 0;\n      var needsAlphaFormat = !formatSet && hasAlpha && (format === \"hex\" || format === \"hex6\" || format === \"hex3\" || format === \"hex4\" || format === \"hex8\" || format === \"name\");\n      if (needsAlphaFormat) {\n        // Special case for \"transparent\", all other non-alpha formats\n        // will return rgba when there is transparency.\n        if (format === \"name\" && this._a === 0) {\n          return this.toName();\n        }\n        return this.toRgbString();\n      }\n      if (format === \"rgb\") {\n        formattedString = this.toRgbString();\n      }\n      if (format === \"prgb\") {\n        formattedString = this.toPercentageRgbString();\n      }\n      if (format === \"hex\" || format === \"hex6\") {\n        formattedString = this.toHexString();\n      }\n      if (format === \"hex3\") {\n        formattedString = this.toHexString(true);\n      }\n      if (format === \"hex4\") {\n        formattedString = this.toHex8String(true);\n      }\n      if (format === \"hex8\") {\n        formattedString = this.toHex8String();\n      }\n      if (format === \"name\") {\n        formattedString = this.toName();\n      }\n      if (format === \"hsl\") {\n        formattedString = this.toHslString();\n      }\n      if (format === \"hsv\") {\n        formattedString = this.toHsvString();\n      }\n      return formattedString || this.toHexString();\n    },\n    clone: function clone() {\n      return tinycolor(this.toString());\n    },\n    _applyModification: function _applyModification(fn, args) {\n      var color = fn.apply(null, [this].concat([].slice.call(args)));\n      this._r = color._r;\n      this._g = color._g;\n      this._b = color._b;\n      this.setAlpha(color._a);\n      return this;\n    },\n    lighten: function lighten() {\n      return this._applyModification(_lighten, arguments);\n    },\n    brighten: function brighten() {\n      return this._applyModification(_brighten, arguments);\n    },\n    darken: function darken() {\n      return this._applyModification(_darken, arguments);\n    },\n    desaturate: function desaturate() {\n      return this._applyModification(_desaturate, arguments);\n    },\n    saturate: function saturate() {\n      return this._applyModification(_saturate, arguments);\n    },\n    greyscale: function greyscale() {\n      return this._applyModification(_greyscale, arguments);\n    },\n    spin: function spin() {\n      return this._applyModification(_spin, arguments);\n    },\n    _applyCombination: function _applyCombination(fn, args) {\n      return fn.apply(null, [this].concat([].slice.call(args)));\n    },\n    analogous: function analogous() {\n      return this._applyCombination(_analogous, arguments);\n    },\n    complement: function complement() {\n      return this._applyCombination(_complement, arguments);\n    },\n    monochromatic: function monochromatic() {\n      return this._applyCombination(_monochromatic, arguments);\n    },\n    splitcomplement: function splitcomplement() {\n      return this._applyCombination(_splitcomplement, arguments);\n    },\n    // Disabled until https://github.com/bgrins/TinyColor/issues/254\n    // polyad: function (number) {\n    //   return this._applyCombination(polyad, [number]);\n    // },\n    triad: function triad() {\n      return this._applyCombination(polyad, [3]);\n    },\n    tetrad: function tetrad() {\n      return this._applyCombination(polyad, [4]);\n    }\n  };\n\n  // If input is an object, force 1 into \"1.0\" to handle ratios properly\n  // String input requires \"1.0\" as input, so 1 will be treated as 1\n  tinycolor.fromRatio = function (color, opts) {\n    if (_typeof(color) == \"object\") {\n      var newColor = {};\n      for (var i in color) {\n        if (color.hasOwnProperty(i)) {\n          if (i === \"a\") {\n            newColor[i] = color[i];\n          } else {\n            newColor[i] = convertToPercentage(color[i]);\n          }\n        }\n      }\n      color = newColor;\n    }\n    return tinycolor(color, opts);\n  };\n\n  // Given a string or object, convert that input to RGB\n  // Possible string inputs:\n  //\n  //     \"red\"\n  //     \"#f00\" or \"f00\"\n  //     \"#ff0000\" or \"ff0000\"\n  //     \"#ff000000\" or \"ff000000\"\n  //     \"rgb 255 0 0\" or \"rgb (255, 0, 0)\"\n  //     \"rgb 1.0 0 0\" or \"rgb (1, 0, 0)\"\n  //     \"rgba (255, 0, 0, 1)\" or \"rgba 255, 0, 0, 1\"\n  //     \"rgba (1.0, 0, 0, 1)\" or \"rgba 1.0, 0, 0, 1\"\n  //     \"hsl(0, 100%, 50%)\" or \"hsl 0 100% 50%\"\n  //     \"hsla(0, 100%, 50%, 1)\" or \"hsla 0 100% 50%, 1\"\n  //     \"hsv(0, 100%, 100%)\" or \"hsv 0 100% 100%\"\n  //\n  function inputToRGB(color) {\n    var rgb = {\n      r: 0,\n      g: 0,\n      b: 0\n    };\n    var a = 1;\n    var s = null;\n    var v = null;\n    var l = null;\n    var ok = false;\n    var format = false;\n    if (typeof color == \"string\") {\n      color = stringInputToObject(color);\n    }\n    if (_typeof(color) == \"object\") {\n      if (isValidCSSUnit(color.r) && isValidCSSUnit(color.g) && isValidCSSUnit(color.b)) {\n        rgb = rgbToRgb(color.r, color.g, color.b);\n        ok = true;\n        format = String(color.r).substr(-1) === \"%\" ? \"prgb\" : \"rgb\";\n      } else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.v)) {\n        s = convertToPercentage(color.s);\n        v = convertToPercentage(color.v);\n        rgb = hsvToRgb(color.h, s, v);\n        ok = true;\n        format = \"hsv\";\n      } else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.l)) {\n        s = convertToPercentage(color.s);\n        l = convertToPercentage(color.l);\n        rgb = hslToRgb(color.h, s, l);\n        ok = true;\n        format = \"hsl\";\n      }\n      if (color.hasOwnProperty(\"a\")) {\n        a = color.a;\n      }\n    }\n    a = boundAlpha(a);\n    return {\n      ok: ok,\n      format: color.format || format,\n      r: Math.min(255, Math.max(rgb.r, 0)),\n      g: Math.min(255, Math.max(rgb.g, 0)),\n      b: Math.min(255, Math.max(rgb.b, 0)),\n      a: a\n    };\n  }\n\n  // Conversion Functions\n  // --------------------\n\n  // `rgbToHsl`, `rgbToHsv`, `hslToRgb`, `hsvToRgb` modified from:\n  // <http://mjijackson.com/2008/02/rgb-to-hsl-and-rgb-to-hsv-color-model-conversion-algorithms-in-javascript>\n\n  // `rgbToRgb`\n  // Handle bounds / percentage checking to conform to CSS color spec\n  // <http://www.w3.org/TR/css3-color/>\n  // *Assumes:* r, g, b in [0, 255] or [0, 1]\n  // *Returns:* { r, g, b } in [0, 255]\n  function rgbToRgb(r, g, b) {\n    return {\n      r: bound01(r, 255) * 255,\n      g: bound01(g, 255) * 255,\n      b: bound01(b, 255) * 255\n    };\n  }\n\n  // `rgbToHsl`\n  // Converts an RGB color value to HSL.\n  // *Assumes:* r, g, and b are contained in [0, 255] or [0, 1]\n  // *Returns:* { h, s, l } in [0,1]\n  function rgbToHsl(r, g, b) {\n    r = bound01(r, 255);\n    g = bound01(g, 255);\n    b = bound01(b, 255);\n    var max = Math.max(r, g, b),\n      min = Math.min(r, g, b);\n    var h,\n      s,\n      l = (max + min) / 2;\n    if (max == min) {\n      h = s = 0; // achromatic\n    } else {\n      var d = max - min;\n      s = l > 0.5 ? d / (2 - max - min) : d / (max + min);\n      switch (max) {\n        case r:\n          h = (g - b) / d + (g < b ? 6 : 0);\n          break;\n        case g:\n          h = (b - r) / d + 2;\n          break;\n        case b:\n          h = (r - g) / d + 4;\n          break;\n      }\n      h /= 6;\n    }\n    return {\n      h: h,\n      s: s,\n      l: l\n    };\n  }\n\n  // `hslToRgb`\n  // Converts an HSL color value to RGB.\n  // *Assumes:* h is contained in [0, 1] or [0, 360] and s and l are contained [0, 1] or [0, 100]\n  // *Returns:* { r, g, b } in the set [0, 255]\n  function hslToRgb(h, s, l) {\n    var r, g, b;\n    h = bound01(h, 360);\n    s = bound01(s, 100);\n    l = bound01(l, 100);\n    function hue2rgb(p, q, t) {\n      if (t < 0) t += 1;\n      if (t > 1) t -= 1;\n      if (t < 1 / 6) return p + (q - p) * 6 * t;\n      if (t < 1 / 2) return q;\n      if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;\n      return p;\n    }\n    if (s === 0) {\n      r = g = b = l; // achromatic\n    } else {\n      var q = l < 0.5 ? l * (1 + s) : l + s - l * s;\n      var p = 2 * l - q;\n      r = hue2rgb(p, q, h + 1 / 3);\n      g = hue2rgb(p, q, h);\n      b = hue2rgb(p, q, h - 1 / 3);\n    }\n    return {\n      r: r * 255,\n      g: g * 255,\n      b: b * 255\n    };\n  }\n\n  // `rgbToHsv`\n  // Converts an RGB color value to HSV\n  // *Assumes:* r, g, and b are contained in the set [0, 255] or [0, 1]\n  // *Returns:* { h, s, v } in [0,1]\n  function rgbToHsv(r, g, b) {\n    r = bound01(r, 255);\n    g = bound01(g, 255);\n    b = bound01(b, 255);\n    var max = Math.max(r, g, b),\n      min = Math.min(r, g, b);\n    var h,\n      s,\n      v = max;\n    var d = max - min;\n    s = max === 0 ? 0 : d / max;\n    if (max == min) {\n      h = 0; // achromatic\n    } else {\n      switch (max) {\n        case r:\n          h = (g - b) / d + (g < b ? 6 : 0);\n          break;\n        case g:\n          h = (b - r) / d + 2;\n          break;\n        case b:\n          h = (r - g) / d + 4;\n          break;\n      }\n      h /= 6;\n    }\n    return {\n      h: h,\n      s: s,\n      v: v\n    };\n  }\n\n  // `hsvToRgb`\n  // Converts an HSV color value to RGB.\n  // *Assumes:* h is contained in [0, 1] or [0, 360] and s and v are contained in [0, 1] or [0, 100]\n  // *Returns:* { r, g, b } in the set [0, 255]\n  function hsvToRgb(h, s, v) {\n    h = bound01(h, 360) * 6;\n    s = bound01(s, 100);\n    v = bound01(v, 100);\n    var i = Math.floor(h),\n      f = h - i,\n      p = v * (1 - s),\n      q = v * (1 - f * s),\n      t = v * (1 - (1 - f) * s),\n      mod = i % 6,\n      r = [v, q, p, p, t, v][mod],\n      g = [t, v, v, q, p, p][mod],\n      b = [p, p, t, v, v, q][mod];\n    return {\n      r: r * 255,\n      g: g * 255,\n      b: b * 255\n    };\n  }\n\n  // `rgbToHex`\n  // Converts an RGB color to hex\n  // Assumes r, g, and b are contained in the set [0, 255]\n  // Returns a 3 or 6 character hex\n  function rgbToHex(r, g, b, allow3Char) {\n    var hex = [pad2(Math.round(r).toString(16)), pad2(Math.round(g).toString(16)), pad2(Math.round(b).toString(16))];\n\n    // Return a 3 character hex if possible\n    if (allow3Char && hex[0].charAt(0) == hex[0].charAt(1) && hex[1].charAt(0) == hex[1].charAt(1) && hex[2].charAt(0) == hex[2].charAt(1)) {\n      return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0);\n    }\n    return hex.join(\"\");\n  }\n\n  // `rgbaToHex`\n  // Converts an RGBA color plus alpha transparency to hex\n  // Assumes r, g, b are contained in the set [0, 255] and\n  // a in [0, 1]. Returns a 4 or 8 character rgba hex\n  function rgbaToHex(r, g, b, a, allow4Char) {\n    var hex = [pad2(Math.round(r).toString(16)), pad2(Math.round(g).toString(16)), pad2(Math.round(b).toString(16)), pad2(convertDecimalToHex(a))];\n\n    // Return a 4 character hex if possible\n    if (allow4Char && hex[0].charAt(0) == hex[0].charAt(1) && hex[1].charAt(0) == hex[1].charAt(1) && hex[2].charAt(0) == hex[2].charAt(1) && hex[3].charAt(0) == hex[3].charAt(1)) {\n      return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0) + hex[3].charAt(0);\n    }\n    return hex.join(\"\");\n  }\n\n  // `rgbaToArgbHex`\n  // Converts an RGBA color to an ARGB Hex8 string\n  // Rarely used, but required for \"toFilter()\"\n  function rgbaToArgbHex(r, g, b, a) {\n    var hex = [pad2(convertDecimalToHex(a)), pad2(Math.round(r).toString(16)), pad2(Math.round(g).toString(16)), pad2(Math.round(b).toString(16))];\n    return hex.join(\"\");\n  }\n\n  // `equals`\n  // Can be called with any tinycolor input\n  tinycolor.equals = function (color1, color2) {\n    if (!color1 || !color2) return false;\n    return tinycolor(color1).toRgbString() == tinycolor(color2).toRgbString();\n  };\n  tinycolor.random = function () {\n    return tinycolor.fromRatio({\n      r: Math.random(),\n      g: Math.random(),\n      b: Math.random()\n    });\n  };\n\n  // Modification Functions\n  // ----------------------\n  // Thanks to less.js for some of the basics here\n  // <https://github.com/cloudhead/less.js/blob/master/lib/less/functions.js>\n\n  function _desaturate(color, amount) {\n    amount = amount === 0 ? 0 : amount || 10;\n    var hsl = tinycolor(color).toHsl();\n    hsl.s -= amount / 100;\n    hsl.s = clamp01(hsl.s);\n    return tinycolor(hsl);\n  }\n  function _saturate(color, amount) {\n    amount = amount === 0 ? 0 : amount || 10;\n    var hsl = tinycolor(color).toHsl();\n    hsl.s += amount / 100;\n    hsl.s = clamp01(hsl.s);\n    return tinycolor(hsl);\n  }\n  function _greyscale(color) {\n    return tinycolor(color).desaturate(100);\n  }\n  function _lighten(color, amount) {\n    amount = amount === 0 ? 0 : amount || 10;\n    var hsl = tinycolor(color).toHsl();\n    hsl.l += amount / 100;\n    hsl.l = clamp01(hsl.l);\n    return tinycolor(hsl);\n  }\n  function _brighten(color, amount) {\n    amount = amount === 0 ? 0 : amount || 10;\n    var rgb = tinycolor(color).toRgb();\n    rgb.r = Math.max(0, Math.min(255, rgb.r - Math.round(255 * -(amount / 100))));\n    rgb.g = Math.max(0, Math.min(255, rgb.g - Math.round(255 * -(amount / 100))));\n    rgb.b = Math.max(0, Math.min(255, rgb.b - Math.round(255 * -(amount / 100))));\n    return tinycolor(rgb);\n  }\n  function _darken(color, amount) {\n    amount = amount === 0 ? 0 : amount || 10;\n    var hsl = tinycolor(color).toHsl();\n    hsl.l -= amount / 100;\n    hsl.l = clamp01(hsl.l);\n    return tinycolor(hsl);\n  }\n\n  // Spin takes a positive or negative amount within [-360, 360] indicating the change of hue.\n  // Values outside of this range will be wrapped into this range.\n  function _spin(color, amount) {\n    var hsl = tinycolor(color).toHsl();\n    var hue = (hsl.h + amount) % 360;\n    hsl.h = hue < 0 ? 360 + hue : hue;\n    return tinycolor(hsl);\n  }\n\n  // Combination Functions\n  // ---------------------\n  // Thanks to jQuery xColor for some of the ideas behind these\n  // <https://github.com/infusion/jQuery-xcolor/blob/master/jquery.xcolor.js>\n\n  function _complement(color) {\n    var hsl = tinycolor(color).toHsl();\n    hsl.h = (hsl.h + 180) % 360;\n    return tinycolor(hsl);\n  }\n  function polyad(color, number) {\n    if (isNaN(number) || number <= 0) {\n      throw new Error(\"Argument to polyad must be a positive number\");\n    }\n    var hsl = tinycolor(color).toHsl();\n    var result = [tinycolor(color)];\n    var step = 360 / number;\n    for (var i = 1; i < number; i++) {\n      result.push(tinycolor({\n        h: (hsl.h + i * step) % 360,\n        s: hsl.s,\n        l: hsl.l\n      }));\n    }\n    return result;\n  }\n  function _splitcomplement(color) {\n    var hsl = tinycolor(color).toHsl();\n    var h = hsl.h;\n    return [tinycolor(color), tinycolor({\n      h: (h + 72) % 360,\n      s: hsl.s,\n      l: hsl.l\n    }), tinycolor({\n      h: (h + 216) % 360,\n      s: hsl.s,\n      l: hsl.l\n    })];\n  }\n  function _analogous(color, results, slices) {\n    results = results || 6;\n    slices = slices || 30;\n    var hsl = tinycolor(color).toHsl();\n    var part = 360 / slices;\n    var ret = [tinycolor(color)];\n    for (hsl.h = (hsl.h - (part * results >> 1) + 720) % 360; --results;) {\n      hsl.h = (hsl.h + part) % 360;\n      ret.push(tinycolor(hsl));\n    }\n    return ret;\n  }\n  function _monochromatic(color, results) {\n    results = results || 6;\n    var hsv = tinycolor(color).toHsv();\n    var h = hsv.h,\n      s = hsv.s,\n      v = hsv.v;\n    var ret = [];\n    var modification = 1 / results;\n    while (results--) {\n      ret.push(tinycolor({\n        h: h,\n        s: s,\n        v: v\n      }));\n      v = (v + modification) % 1;\n    }\n    return ret;\n  }\n\n  // Utility Functions\n  // ---------------------\n\n  tinycolor.mix = function (color1, color2, amount) {\n    amount = amount === 0 ? 0 : amount || 50;\n    var rgb1 = tinycolor(color1).toRgb();\n    var rgb2 = tinycolor(color2).toRgb();\n    var p = amount / 100;\n    var rgba = {\n      r: (rgb2.r - rgb1.r) * p + rgb1.r,\n      g: (rgb2.g - rgb1.g) * p + rgb1.g,\n      b: (rgb2.b - rgb1.b) * p + rgb1.b,\n      a: (rgb2.a - rgb1.a) * p + rgb1.a\n    };\n    return tinycolor(rgba);\n  };\n\n  // Readability Functions\n  // ---------------------\n  // <http://www.w3.org/TR/2008/REC-WCAG20-20081211/#contrast-ratiodef (WCAG Version 2)\n\n  // `contrast`\n  // Analyze the 2 colors and returns the color contrast defined by (WCAG Version 2)\n  tinycolor.readability = function (color1, color2) {\n    var c1 = tinycolor(color1);\n    var c2 = tinycolor(color2);\n    return (Math.max(c1.getLuminance(), c2.getLuminance()) + 0.05) / (Math.min(c1.getLuminance(), c2.getLuminance()) + 0.05);\n  };\n\n  // `isReadable`\n  // Ensure that foreground and background color combinations meet WCAG2 guidelines.\n  // The third argument is an optional Object.\n  //      the 'level' property states 'AA' or 'AAA' - if missing or invalid, it defaults to 'AA';\n  //      the 'size' property states 'large' or 'small' - if missing or invalid, it defaults to 'small'.\n  // If the entire object is absent, isReadable defaults to {level:\"AA\",size:\"small\"}.\n\n  // *Example*\n  //    tinycolor.isReadable(\"#000\", \"#111\") => false\n  //    tinycolor.isReadable(\"#000\", \"#111\",{level:\"AA\",size:\"large\"}) => false\n  tinycolor.isReadable = function (color1, color2, wcag2) {\n    var readability = tinycolor.readability(color1, color2);\n    var wcag2Parms, out;\n    out = false;\n    wcag2Parms = validateWCAG2Parms(wcag2);\n    switch (wcag2Parms.level + wcag2Parms.size) {\n      case \"AAsmall\":\n      case \"AAAlarge\":\n        out = readability >= 4.5;\n        break;\n      case \"AAlarge\":\n        out = readability >= 3;\n        break;\n      case \"AAAsmall\":\n        out = readability >= 7;\n        break;\n    }\n    return out;\n  };\n\n  // `mostReadable`\n  // Given a base color and a list of possible foreground or background\n  // colors for that base, returns the most readable color.\n  // Optionally returns Black or White if the most readable color is unreadable.\n  // *Example*\n  //    tinycolor.mostReadable(tinycolor.mostReadable(\"#123\", [\"#124\", \"#125\"],{includeFallbackColors:false}).toHexString(); // \"#112255\"\n  //    tinycolor.mostReadable(tinycolor.mostReadable(\"#123\", [\"#124\", \"#125\"],{includeFallbackColors:true}).toHexString();  // \"#ffffff\"\n  //    tinycolor.mostReadable(\"#a8015a\", [\"#faf3f3\"],{includeFallbackColors:true,level:\"AAA\",size:\"large\"}).toHexString(); // \"#faf3f3\"\n  //    tinycolor.mostReadable(\"#a8015a\", [\"#faf3f3\"],{includeFallbackColors:true,level:\"AAA\",size:\"small\"}).toHexString(); // \"#ffffff\"\n  tinycolor.mostReadable = function (baseColor, colorList, args) {\n    var bestColor = null;\n    var bestScore = 0;\n    var readability;\n    var includeFallbackColors, level, size;\n    args = args || {};\n    includeFallbackColors = args.includeFallbackColors;\n    level = args.level;\n    size = args.size;\n    for (var i = 0; i < colorList.length; i++) {\n      readability = tinycolor.readability(baseColor, colorList[i]);\n      if (readability > bestScore) {\n        bestScore = readability;\n        bestColor = tinycolor(colorList[i]);\n      }\n    }\n    if (tinycolor.isReadable(baseColor, bestColor, {\n      level: level,\n      size: size\n    }) || !includeFallbackColors) {\n      return bestColor;\n    } else {\n      args.includeFallbackColors = false;\n      return tinycolor.mostReadable(baseColor, [\"#fff\", \"#000\"], args);\n    }\n  };\n\n  // Big List of Colors\n  // ------------------\n  // <https://www.w3.org/TR/css-color-4/#named-colors>\n  var names = tinycolor.names = {\n    aliceblue: \"f0f8ff\",\n    antiquewhite: \"faebd7\",\n    aqua: \"0ff\",\n    aquamarine: \"7fffd4\",\n    azure: \"f0ffff\",\n    beige: \"f5f5dc\",\n    bisque: \"ffe4c4\",\n    black: \"000\",\n    blanchedalmond: \"ffebcd\",\n    blue: \"00f\",\n    blueviolet: \"8a2be2\",\n    brown: \"a52a2a\",\n    burlywood: \"deb887\",\n    burntsienna: \"ea7e5d\",\n    cadetblue: \"5f9ea0\",\n    chartreuse: \"7fff00\",\n    chocolate: \"d2691e\",\n    coral: \"ff7f50\",\n    cornflowerblue: \"6495ed\",\n    cornsilk: \"fff8dc\",\n    crimson: \"dc143c\",\n    cyan: \"0ff\",\n    darkblue: \"00008b\",\n    darkcyan: \"008b8b\",\n    darkgoldenrod: \"b8860b\",\n    darkgray: \"a9a9a9\",\n    darkgreen: \"006400\",\n    darkgrey: \"a9a9a9\",\n    darkkhaki: \"bdb76b\",\n    darkmagenta: \"8b008b\",\n    darkolivegreen: \"556b2f\",\n    darkorange: \"ff8c00\",\n    darkorchid: \"9932cc\",\n    darkred: \"8b0000\",\n    darksalmon: \"e9967a\",\n    darkseagreen: \"8fbc8f\",\n    darkslateblue: \"483d8b\",\n    darkslategray: \"2f4f4f\",\n    darkslategrey: \"2f4f4f\",\n    darkturquoise: \"00ced1\",\n    darkviolet: \"9400d3\",\n    deeppink: \"ff1493\",\n    deepskyblue: \"00bfff\",\n    dimgray: \"696969\",\n    dimgrey: \"696969\",\n    dodgerblue: \"1e90ff\",\n    firebrick: \"b22222\",\n    floralwhite: \"fffaf0\",\n    forestgreen: \"228b22\",\n    fuchsia: \"f0f\",\n    gainsboro: \"dcdcdc\",\n    ghostwhite: \"f8f8ff\",\n    gold: \"ffd700\",\n    goldenrod: \"daa520\",\n    gray: \"808080\",\n    green: \"008000\",\n    greenyellow: \"adff2f\",\n    grey: \"808080\",\n    honeydew: \"f0fff0\",\n    hotpink: \"ff69b4\",\n    indianred: \"cd5c5c\",\n    indigo: \"4b0082\",\n    ivory: \"fffff0\",\n    khaki: \"f0e68c\",\n    lavender: \"e6e6fa\",\n    lavenderblush: \"fff0f5\",\n    lawngreen: \"7cfc00\",\n    lemonchiffon: \"fffacd\",\n    lightblue: \"add8e6\",\n    lightcoral: \"f08080\",\n    lightcyan: \"e0ffff\",\n    lightgoldenrodyellow: \"fafad2\",\n    lightgray: \"d3d3d3\",\n    lightgreen: \"90ee90\",\n    lightgrey: \"d3d3d3\",\n    lightpink: \"ffb6c1\",\n    lightsalmon: \"ffa07a\",\n    lightseagreen: \"20b2aa\",\n    lightskyblue: \"87cefa\",\n    lightslategray: \"789\",\n    lightslategrey: \"789\",\n    lightsteelblue: \"b0c4de\",\n    lightyellow: \"ffffe0\",\n    lime: \"0f0\",\n    limegreen: \"32cd32\",\n    linen: \"faf0e6\",\n    magenta: \"f0f\",\n    maroon: \"800000\",\n    mediumaquamarine: \"66cdaa\",\n    mediumblue: \"0000cd\",\n    mediumorchid: \"ba55d3\",\n    mediumpurple: \"9370db\",\n    mediumseagreen: \"3cb371\",\n    mediumslateblue: \"7b68ee\",\n    mediumspringgreen: \"00fa9a\",\n    mediumturquoise: \"48d1cc\",\n    mediumvioletred: \"c71585\",\n    midnightblue: \"191970\",\n    mintcream: \"f5fffa\",\n    mistyrose: \"ffe4e1\",\n    moccasin: \"ffe4b5\",\n    navajowhite: \"ffdead\",\n    navy: \"000080\",\n    oldlace: \"fdf5e6\",\n    olive: \"808000\",\n    olivedrab: \"6b8e23\",\n    orange: \"ffa500\",\n    orangered: \"ff4500\",\n    orchid: \"da70d6\",\n    palegoldenrod: \"eee8aa\",\n    palegreen: \"98fb98\",\n    paleturquoise: \"afeeee\",\n    palevioletred: \"db7093\",\n    papayawhip: \"ffefd5\",\n    peachpuff: \"ffdab9\",\n    peru: \"cd853f\",\n    pink: \"ffc0cb\",\n    plum: \"dda0dd\",\n    powderblue: \"b0e0e6\",\n    purple: \"800080\",\n    rebeccapurple: \"663399\",\n    red: \"f00\",\n    rosybrown: \"bc8f8f\",\n    royalblue: \"4169e1\",\n    saddlebrown: \"8b4513\",\n    salmon: \"fa8072\",\n    sandybrown: \"f4a460\",\n    seagreen: \"2e8b57\",\n    seashell: \"fff5ee\",\n    sienna: \"a0522d\",\n    silver: \"c0c0c0\",\n    skyblue: \"87ceeb\",\n    slateblue: \"6a5acd\",\n    slategray: \"708090\",\n    slategrey: \"708090\",\n    snow: \"fffafa\",\n    springgreen: \"00ff7f\",\n    steelblue: \"4682b4\",\n    tan: \"d2b48c\",\n    teal: \"008080\",\n    thistle: \"d8bfd8\",\n    tomato: \"ff6347\",\n    turquoise: \"40e0d0\",\n    violet: \"ee82ee\",\n    wheat: \"f5deb3\",\n    white: \"fff\",\n    whitesmoke: \"f5f5f5\",\n    yellow: \"ff0\",\n    yellowgreen: \"9acd32\"\n  };\n\n  // Make it easy to access colors via `hexNames[hex]`\n  var hexNames = tinycolor.hexNames = flip(names);\n\n  // Utilities\n  // ---------\n\n  // `{ 'name1': 'val1' }` becomes `{ 'val1': 'name1' }`\n  function flip(o) {\n    var flipped = {};\n    for (var i in o) {\n      if (o.hasOwnProperty(i)) {\n        flipped[o[i]] = i;\n      }\n    }\n    return flipped;\n  }\n\n  // Return a valid alpha value [0,1] with all invalid values being set to 1\n  function boundAlpha(a) {\n    a = parseFloat(a);\n    if (isNaN(a) || a < 0 || a > 1) {\n      a = 1;\n    }\n    return a;\n  }\n\n  // Take input from [0, n] and return it as [0, 1]\n  function bound01(n, max) {\n    if (isOnePointZero(n)) n = \"100%\";\n    var processPercent = isPercentage(n);\n    n = Math.min(max, Math.max(0, parseFloat(n)));\n\n    // Automatically convert percentage into number\n    if (processPercent) {\n      n = parseInt(n * max, 10) / 100;\n    }\n\n    // Handle floating point rounding errors\n    if (Math.abs(n - max) < 0.000001) {\n      return 1;\n    }\n\n    // Convert into [0, 1] range if it isn't already\n    return n % max / parseFloat(max);\n  }\n\n  // Force a number between 0 and 1\n  function clamp01(val) {\n    return Math.min(1, Math.max(0, val));\n  }\n\n  // Parse a base-16 hex value into a base-10 integer\n  function parseIntFromHex(val) {\n    return parseInt(val, 16);\n  }\n\n  // Need to handle 1.0 as 100%, since once it is a number, there is no difference between it and 1\n  // <http://stackoverflow.com/questions/7422072/javascript-how-to-detect-number-as-a-decimal-including-1-0>\n  function isOnePointZero(n) {\n    return typeof n == \"string\" && n.indexOf(\".\") != -1 && parseFloat(n) === 1;\n  }\n\n  // Check to see if string passed in is a percentage\n  function isPercentage(n) {\n    return typeof n === \"string\" && n.indexOf(\"%\") != -1;\n  }\n\n  // Force a hex value to have 2 characters\n  function pad2(c) {\n    return c.length == 1 ? \"0\" + c : \"\" + c;\n  }\n\n  // Replace a decimal with it's percentage value\n  function convertToPercentage(n) {\n    if (n <= 1) {\n      n = n * 100 + \"%\";\n    }\n    return n;\n  }\n\n  // Converts a decimal to a hex value\n  function convertDecimalToHex(d) {\n    return Math.round(parseFloat(d) * 255).toString(16);\n  }\n  // Converts a hex value to a decimal\n  function convertHexToDecimal(h) {\n    return parseIntFromHex(h) / 255;\n  }\n  var matchers = function () {\n    // <http://www.w3.org/TR/css3-values/#integers>\n    var CSS_INTEGER = \"[-\\\\+]?\\\\d+%?\";\n\n    // <http://www.w3.org/TR/css3-values/#number-value>\n    var CSS_NUMBER = \"[-\\\\+]?\\\\d*\\\\.\\\\d+%?\";\n\n    // Allow positive/negative integer/number.  Don't capture the either/or, just the entire outcome.\n    var CSS_UNIT = \"(?:\" + CSS_NUMBER + \")|(?:\" + CSS_INTEGER + \")\";\n\n    // Actual matching.\n    // Parentheses and commas are optional, but not required.\n    // Whitespace can take the place of commas or opening paren\n    var PERMISSIVE_MATCH3 = \"[\\\\s|\\\\(]+(\" + CSS_UNIT + \")[,|\\\\s]+(\" + CSS_UNIT + \")[,|\\\\s]+(\" + CSS_UNIT + \")\\\\s*\\\\)?\";\n    var PERMISSIVE_MATCH4 = \"[\\\\s|\\\\(]+(\" + CSS_UNIT + \")[,|\\\\s]+(\" + CSS_UNIT + \")[,|\\\\s]+(\" + CSS_UNIT + \")[,|\\\\s]+(\" + CSS_UNIT + \")\\\\s*\\\\)?\";\n    return {\n      CSS_UNIT: new RegExp(CSS_UNIT),\n      rgb: new RegExp(\"rgb\" + PERMISSIVE_MATCH3),\n      rgba: new RegExp(\"rgba\" + PERMISSIVE_MATCH4),\n      hsl: new RegExp(\"hsl\" + PERMISSIVE_MATCH3),\n      hsla: new RegExp(\"hsla\" + PERMISSIVE_MATCH4),\n      hsv: new RegExp(\"hsv\" + PERMISSIVE_MATCH3),\n      hsva: new RegExp(\"hsva\" + PERMISSIVE_MATCH4),\n      hex3: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,\n      hex6: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/,\n      hex4: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,\n      hex8: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/\n    };\n  }();\n\n  // `isValidCSSUnit`\n  // Take in a single string / number and check to see if it looks like a CSS unit\n  // (see `matchers` above for definition).\n  function isValidCSSUnit(color) {\n    return !!matchers.CSS_UNIT.exec(color);\n  }\n\n  // `stringInputToObject`\n  // Permissive string parsing.  Take in a number of formats, and output an object\n  // based on detected format.  Returns `{ r, g, b }` or `{ h, s, l }` or `{ h, s, v}`\n  function stringInputToObject(color) {\n    color = color.replace(trimLeft, \"\").replace(trimRight, \"\").toLowerCase();\n    var named = false;\n    if (names[color]) {\n      color = names[color];\n      named = true;\n    } else if (color == \"transparent\") {\n      return {\n        r: 0,\n        g: 0,\n        b: 0,\n        a: 0,\n        format: \"name\"\n      };\n    }\n\n    // Try to match string input using regular expressions.\n    // Keep most of the number bounding out of this function - don't worry about [0,1] or [0,100] or [0,360]\n    // Just return an object and let the conversion functions handle that.\n    // This way the result will be the same whether the tinycolor is initialized with string or object.\n    var match;\n    if (match = matchers.rgb.exec(color)) {\n      return {\n        r: match[1],\n        g: match[2],\n        b: match[3]\n      };\n    }\n    if (match = matchers.rgba.exec(color)) {\n      return {\n        r: match[1],\n        g: match[2],\n        b: match[3],\n        a: match[4]\n      };\n    }\n    if (match = matchers.hsl.exec(color)) {\n      return {\n        h: match[1],\n        s: match[2],\n        l: match[3]\n      };\n    }\n    if (match = matchers.hsla.exec(color)) {\n      return {\n        h: match[1],\n        s: match[2],\n        l: match[3],\n        a: match[4]\n      };\n    }\n    if (match = matchers.hsv.exec(color)) {\n      return {\n        h: match[1],\n        s: match[2],\n        v: match[3]\n      };\n    }\n    if (match = matchers.hsva.exec(color)) {\n      return {\n        h: match[1],\n        s: match[2],\n        v: match[3],\n        a: match[4]\n      };\n    }\n    if (match = matchers.hex8.exec(color)) {\n      return {\n        r: parseIntFromHex(match[1]),\n        g: parseIntFromHex(match[2]),\n        b: parseIntFromHex(match[3]),\n        a: convertHexToDecimal(match[4]),\n        format: named ? \"name\" : \"hex8\"\n      };\n    }\n    if (match = matchers.hex6.exec(color)) {\n      return {\n        r: parseIntFromHex(match[1]),\n        g: parseIntFromHex(match[2]),\n        b: parseIntFromHex(match[3]),\n        format: named ? \"name\" : \"hex\"\n      };\n    }\n    if (match = matchers.hex4.exec(color)) {\n      return {\n        r: parseIntFromHex(match[1] + \"\" + match[1]),\n        g: parseIntFromHex(match[2] + \"\" + match[2]),\n        b: parseIntFromHex(match[3] + \"\" + match[3]),\n        a: convertHexToDecimal(match[4] + \"\" + match[4]),\n        format: named ? \"name\" : \"hex8\"\n      };\n    }\n    if (match = matchers.hex3.exec(color)) {\n      return {\n        r: parseIntFromHex(match[1] + \"\" + match[1]),\n        g: parseIntFromHex(match[2] + \"\" + match[2]),\n        b: parseIntFromHex(match[3] + \"\" + match[3]),\n        format: named ? \"name\" : \"hex\"\n      };\n    }\n    return false;\n  }\n  function validateWCAG2Parms(parms) {\n    // return valid WCAG2 parms for isReadable.\n    // If input parms are invalid, return {\"level\":\"AA\", \"size\":\"small\"}\n    var level, size;\n    parms = parms || {\n      level: \"AA\",\n      size: \"small\"\n    };\n    level = (parms.level || \"AA\").toUpperCase();\n    size = (parms.size || \"small\").toLowerCase();\n    if (level !== \"AA\" && level !== \"AAA\") {\n      level = \"AA\";\n    }\n    if (size !== \"small\" && size !== \"large\") {\n      size = \"small\";\n    }\n    return {\n      level: level,\n      size: size\n    };\n  }\n\n  return tinycolor;\n\n}));\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __createBinding(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (p !== \"default\" && !exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","\"use strict\";\n\n(function(root) {\n    const MAX_VALUE = 0x7fffffff;\n\n    // The SHA256 and PBKDF2 implementation are from scrypt-async-js:\n    // See: https://github.com/dchest/scrypt-async-js\n    function SHA256(m) {\n        const K = new Uint32Array([\n           0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b,\n           0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01,\n           0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7,\n           0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,\n           0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152,\n           0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,\n           0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc,\n           0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,\n           0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819,\n           0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08,\n           0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f,\n           0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,\n           0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2\n       ]);\n\n        let h0 = 0x6a09e667, h1 = 0xbb67ae85, h2 = 0x3c6ef372, h3 = 0xa54ff53a;\n        let h4 = 0x510e527f, h5 = 0x9b05688c, h6 = 0x1f83d9ab, h7 = 0x5be0cd19;\n        const w = new Uint32Array(64);\n\n        function blocks(p) {\n            let off = 0, len = p.length;\n            while (len >= 64) {\n                let a = h0, b = h1, c = h2, d = h3, e = h4, f = h5, g = h6, h = h7, u, i, j, t1, t2;\n\n                for (i = 0; i < 16; i++) {\n                    j = off + i*4;\n                    w[i] = ((p[j] & 0xff)<<24) | ((p[j+1] & 0xff)<<16) |\n                    ((p[j+2] & 0xff)<<8) | (p[j+3] & 0xff);\n                }\n\n                for (i = 16; i < 64; i++) {\n                    u = w[i-2];\n                    t1 = ((u>>>17) | (u<<(32-17))) ^ ((u>>>19) | (u<<(32-19))) ^ (u>>>10);\n\n                    u = w[i-15];\n                    t2 = ((u>>>7) | (u<<(32-7))) ^ ((u>>>18) | (u<<(32-18))) ^ (u>>>3);\n\n                    w[i] = (((t1 + w[i-7]) | 0) + ((t2 + w[i-16]) | 0)) | 0;\n                }\n\n                for (i = 0; i < 64; i++) {\n                    t1 = ((((((e>>>6) | (e<<(32-6))) ^ ((e>>>11) | (e<<(32-11))) ^\n                             ((e>>>25) | (e<<(32-25)))) + ((e & f) ^ (~e & g))) | 0) +\n                          ((h + ((K[i] + w[i]) | 0)) | 0)) | 0;\n\n                    t2 = ((((a>>>2) | (a<<(32-2))) ^ ((a>>>13) | (a<<(32-13))) ^\n                           ((a>>>22) | (a<<(32-22)))) + ((a & b) ^ (a & c) ^ (b & c))) | 0;\n\n                    h = g;\n                    g = f;\n                    f = e;\n                    e = (d + t1) | 0;\n                    d = c;\n                    c = b;\n                    b = a;\n                    a = (t1 + t2) | 0;\n                }\n\n                h0 = (h0 + a) | 0;\n                h1 = (h1 + b) | 0;\n                h2 = (h2 + c) | 0;\n                h3 = (h3 + d) | 0;\n                h4 = (h4 + e) | 0;\n                h5 = (h5 + f) | 0;\n                h6 = (h6 + g) | 0;\n                h7 = (h7 + h) | 0;\n\n                off += 64;\n                len -= 64;\n            }\n        }\n\n        blocks(m);\n\n        let i, bytesLeft = m.length % 64,\n        bitLenHi = (m.length / 0x20000000) | 0,\n        bitLenLo = m.length << 3,\n        numZeros = (bytesLeft < 56) ? 56 : 120,\n        p = m.slice(m.length - bytesLeft, m.length);\n\n        p.push(0x80);\n        for (i = bytesLeft + 1; i < numZeros; i++) { p.push(0); }\n        p.push((bitLenHi >>> 24) & 0xff);\n        p.push((bitLenHi >>> 16) & 0xff);\n        p.push((bitLenHi >>> 8)  & 0xff);\n        p.push((bitLenHi >>> 0)  & 0xff);\n        p.push((bitLenLo >>> 24) & 0xff);\n        p.push((bitLenLo >>> 16) & 0xff);\n        p.push((bitLenLo >>> 8)  & 0xff);\n        p.push((bitLenLo >>> 0)  & 0xff);\n\n        blocks(p);\n\n        return [\n            (h0 >>> 24) & 0xff, (h0 >>> 16) & 0xff, (h0 >>> 8) & 0xff, (h0 >>> 0) & 0xff,\n            (h1 >>> 24) & 0xff, (h1 >>> 16) & 0xff, (h1 >>> 8) & 0xff, (h1 >>> 0) & 0xff,\n            (h2 >>> 24) & 0xff, (h2 >>> 16) & 0xff, (h2 >>> 8) & 0xff, (h2 >>> 0) & 0xff,\n            (h3 >>> 24) & 0xff, (h3 >>> 16) & 0xff, (h3 >>> 8) & 0xff, (h3 >>> 0) & 0xff,\n            (h4 >>> 24) & 0xff, (h4 >>> 16) & 0xff, (h4 >>> 8) & 0xff, (h4 >>> 0) & 0xff,\n            (h5 >>> 24) & 0xff, (h5 >>> 16) & 0xff, (h5 >>> 8) & 0xff, (h5 >>> 0) & 0xff,\n            (h6 >>> 24) & 0xff, (h6 >>> 16) & 0xff, (h6 >>> 8) & 0xff, (h6 >>> 0) & 0xff,\n            (h7 >>> 24) & 0xff, (h7 >>> 16) & 0xff, (h7 >>> 8) & 0xff, (h7 >>> 0) & 0xff\n        ];\n    }\n\n    function PBKDF2_HMAC_SHA256_OneIter(password, salt, dkLen) {\n        // compress password if it's longer than hash block length\n        password = (password.length <= 64) ? password : SHA256(password);\n\n        const innerLen = 64 + salt.length + 4;\n        const inner = new Array(innerLen);\n        const outerKey = new Array(64);\n\n        let i;\n        let dk = [];\n\n        // inner = (password ^ ipad) || salt || counter\n        for (i = 0; i < 64; i++) { inner[i] = 0x36; }\n        for (i = 0; i < password.length; i++) { inner[i] ^= password[i]; }\n        for (i = 0; i < salt.length; i++) { inner[64 + i] = salt[i]; }\n        for (i = innerLen - 4; i < innerLen; i++) { inner[i] = 0; }\n\n        // outerKey = password ^ opad\n        for (i = 0; i < 64; i++) outerKey[i] = 0x5c;\n        for (i = 0; i < password.length; i++) outerKey[i] ^= password[i];\n\n        // increments counter inside inner\n        function incrementCounter() {\n            for (let i = innerLen - 1; i >= innerLen - 4; i--) {\n                inner[i]++;\n                if (inner[i] <= 0xff) return;\n                inner[i] = 0;\n            }\n        }\n\n        // output blocks = SHA256(outerKey || SHA256(inner)) ...\n        while (dkLen >= 32) {\n            incrementCounter();\n            dk = dk.concat(SHA256(outerKey.concat(SHA256(inner))));\n            dkLen -= 32;\n        }\n        if (dkLen > 0) {\n            incrementCounter();\n            dk = dk.concat(SHA256(outerKey.concat(SHA256(inner))).slice(0, dkLen));\n        }\n\n        return dk;\n    }\n\n    // The following is an adaptation of scryptsy\n    // See: https://www.npmjs.com/package/scryptsy\n    function blockmix_salsa8(BY, Yi, r, x, _X) {\n        let i;\n\n        arraycopy(BY, (2 * r - 1) * 16, _X, 0, 16);\n        for (i = 0; i < 2 * r; i++) {\n            blockxor(BY, i * 16, _X, 16);\n            salsa20_8(_X, x);\n            arraycopy(_X, 0, BY, Yi + (i * 16), 16);\n        }\n\n        for (i = 0; i < r; i++) {\n            arraycopy(BY, Yi + (i * 2) * 16, BY, (i * 16), 16);\n        }\n\n        for (i = 0; i < r; i++) {\n            arraycopy(BY, Yi + (i * 2 + 1) * 16, BY, (i + r) * 16, 16);\n        }\n    }\n\n    function R(a, b) {\n        return (a << b) | (a >>> (32 - b));\n    }\n\n    function salsa20_8(B, x) {\n        arraycopy(B, 0, x, 0, 16);\n\n        for (let i = 8; i > 0; i -= 2) {\n            x[ 4] ^= R(x[ 0] + x[12], 7);\n            x[ 8] ^= R(x[ 4] + x[ 0], 9);\n            x[12] ^= R(x[ 8] + x[ 4], 13);\n            x[ 0] ^= R(x[12] + x[ 8], 18);\n            x[ 9] ^= R(x[ 5] + x[ 1], 7);\n            x[13] ^= R(x[ 9] + x[ 5], 9);\n            x[ 1] ^= R(x[13] + x[ 9], 13);\n            x[ 5] ^= R(x[ 1] + x[13], 18);\n            x[14] ^= R(x[10] + x[ 6], 7);\n            x[ 2] ^= R(x[14] + x[10], 9);\n            x[ 6] ^= R(x[ 2] + x[14], 13);\n            x[10] ^= R(x[ 6] + x[ 2], 18);\n            x[ 3] ^= R(x[15] + x[11], 7);\n            x[ 7] ^= R(x[ 3] + x[15], 9);\n            x[11] ^= R(x[ 7] + x[ 3], 13);\n            x[15] ^= R(x[11] + x[ 7], 18);\n            x[ 1] ^= R(x[ 0] + x[ 3], 7);\n            x[ 2] ^= R(x[ 1] + x[ 0], 9);\n            x[ 3] ^= R(x[ 2] + x[ 1], 13);\n            x[ 0] ^= R(x[ 3] + x[ 2], 18);\n            x[ 6] ^= R(x[ 5] + x[ 4], 7);\n            x[ 7] ^= R(x[ 6] + x[ 5], 9);\n            x[ 4] ^= R(x[ 7] + x[ 6], 13);\n            x[ 5] ^= R(x[ 4] + x[ 7], 18);\n            x[11] ^= R(x[10] + x[ 9], 7);\n            x[ 8] ^= R(x[11] + x[10], 9);\n            x[ 9] ^= R(x[ 8] + x[11], 13);\n            x[10] ^= R(x[ 9] + x[ 8], 18);\n            x[12] ^= R(x[15] + x[14], 7);\n            x[13] ^= R(x[12] + x[15], 9);\n            x[14] ^= R(x[13] + x[12], 13);\n            x[15] ^= R(x[14] + x[13], 18);\n        }\n\n        for (let i = 0; i < 16; ++i) {\n            B[i] += x[i];\n        }\n    }\n\n    // naive approach... going back to loop unrolling may yield additional performance\n    function blockxor(S, Si, D, len) {\n        for (let i = 0; i < len; i++) {\n            D[i] ^= S[Si + i]\n        }\n    }\n\n    function arraycopy(src, srcPos, dest, destPos, length) {\n        while (length--) {\n            dest[destPos++] = src[srcPos++];\n        }\n    }\n\n    function checkBufferish(o) {\n        if (!o || typeof(o.length) !== 'number') { return false; }\n\n        for (let i = 0; i < o.length; i++) {\n            const v = o[i];\n            if (typeof(v) !== 'number' || v % 1 || v < 0 || v >= 256) {\n                return false;\n            }\n        }\n\n        return true;\n    }\n\n    function ensureInteger(value, name) {\n        if (typeof(value) !== \"number\" || (value % 1)) { throw new Error('invalid ' + name); }\n        return value;\n    }\n\n    // N = Cpu cost, r = Memory cost, p = parallelization cost\n    // callback(error, progress, key)\n    function _scrypt(password, salt, N, r, p, dkLen, callback) {\n\n        N = ensureInteger(N, 'N');\n        r = ensureInteger(r, 'r');\n        p = ensureInteger(p, 'p');\n\n        dkLen = ensureInteger(dkLen, 'dkLen');\n\n        if (N === 0 || (N & (N - 1)) !== 0) { throw new Error('N must be power of 2'); }\n\n        if (N > MAX_VALUE / 128 / r) { throw new Error('N too large'); }\n        if (r > MAX_VALUE / 128 / p) { throw new Error('r too large'); }\n\n        if (!checkBufferish(password)) {\n            throw new Error('password must be an array or buffer');\n        }\n        password = Array.prototype.slice.call(password);\n\n        if (!checkBufferish(salt)) {\n            throw new Error('salt must be an array or buffer');\n        }\n        salt = Array.prototype.slice.call(salt);\n\n        let b = PBKDF2_HMAC_SHA256_OneIter(password, salt, p * 128 * r);\n        const B = new Uint32Array(p * 32 * r)\n        for (let i = 0; i < B.length; i++) {\n            const j = i * 4;\n            B[i] = ((b[j + 3] & 0xff) << 24) |\n                   ((b[j + 2] & 0xff) << 16) |\n                   ((b[j + 1] & 0xff) << 8) |\n                   ((b[j + 0] & 0xff) << 0);\n        }\n\n        const XY = new Uint32Array(64 * r);\n        const V = new Uint32Array(32 * r * N);\n\n        const Yi = 32 * r;\n\n        // scratch space\n        const x = new Uint32Array(16);       // salsa20_8\n        const _X = new Uint32Array(16);      // blockmix_salsa8\n\n        const totalOps = p * N * 2;\n        let currentOp = 0;\n        let lastPercent10 = null;\n\n        // Set this to true to abandon the scrypt on the next step\n        let stop = false;\n\n        // State information\n        let state = 0;\n        let i0 = 0, i1;\n        let Bi;\n\n        // How many blockmix_salsa8 can we do per step?\n        const limit = callback ? parseInt(1000 / r): 0xffffffff;\n\n        // Trick from scrypt-async; if there is a setImmediate shim in place, use it\n        const nextTick = (typeof(setImmediate) !== 'undefined') ? setImmediate : setTimeout;\n\n        // This is really all I changed; making scryptsy a state machine so we occasionally\n        // stop and give other evnts on the evnt loop a chance to run. ~RicMoo\n        const incrementalSMix = function() {\n            if (stop) {\n                return callback(new Error('cancelled'), currentOp / totalOps);\n            }\n\n            let steps;\n\n            switch (state) {\n                case 0:\n                    // for (var i = 0; i < p; i++)...\n                    Bi = i0 * 32 * r;\n\n                    arraycopy(B, Bi, XY, 0, Yi);                       // ROMix - 1\n\n                    state = 1;                                         // Move to ROMix 2\n                    i1 = 0;\n\n                    // Fall through\n\n                case 1:\n\n                    // Run up to 1000 steps of the first inner smix loop\n                    steps = N - i1;\n                    if (steps > limit) { steps = limit; }\n                    for (let i = 0; i < steps; i++) {                  // ROMix - 2\n                        arraycopy(XY, 0, V, (i1 + i) * Yi, Yi)         // ROMix - 3\n                        blockmix_salsa8(XY, Yi, r, x, _X);             // ROMix - 4\n                    }\n\n                    // for (var i = 0; i < N; i++)\n                    i1 += steps;\n                    currentOp += steps;\n\n                    if (callback) {\n                        // Call the callback with the progress (optionally stopping us)\n                        const percent10 = parseInt(1000 * currentOp / totalOps);\n                        if (percent10 !== lastPercent10) {\n                            stop = callback(null, currentOp / totalOps);\n                            if (stop) { break; }\n                            lastPercent10 = percent10;\n                        }\n                    }\n\n                    if (i1 < N) { break; }\n\n                    i1 = 0;                                          // Move to ROMix 6\n                    state = 2;\n\n                    // Fall through\n\n                case 2:\n\n                    // Run up to 1000 steps of the second inner smix loop\n                    steps = N - i1;\n                    if (steps > limit) { steps = limit; }\n                    for (let i = 0; i < steps; i++) {                // ROMix - 6\n                        const offset = (2 * r - 1) * 16;             // ROMix - 7\n                        const j = XY[offset] & (N - 1);\n                        blockxor(V, j * Yi, XY, Yi);                 // ROMix - 8 (inner)\n                        blockmix_salsa8(XY, Yi, r, x, _X);           // ROMix - 9 (outer)\n                    }\n\n                    // for (var i = 0; i < N; i++)...\n                    i1 += steps;\n                    currentOp += steps;\n\n                    // Call the callback with the progress (optionally stopping us)\n                    if (callback) {\n                        const percent10 = parseInt(1000 * currentOp / totalOps);\n                        if (percent10 !== lastPercent10) {\n                            stop = callback(null, currentOp / totalOps);\n                            if (stop) { break; }\n                            lastPercent10 = percent10;\n                        }\n                    }\n\n                    if (i1 < N) { break; }\n\n                    arraycopy(XY, 0, B, Bi, Yi);                     // ROMix - 10\n\n                    // for (var i = 0; i < p; i++)...\n                    i0++;\n                    if (i0 < p) {\n                        state = 0;\n                        break;\n                    }\n\n                    b = [];\n                    for (let i = 0; i < B.length; i++) {\n                        b.push((B[i] >>  0) & 0xff);\n                        b.push((B[i] >>  8) & 0xff);\n                        b.push((B[i] >> 16) & 0xff);\n                        b.push((B[i] >> 24) & 0xff);\n                    }\n\n                    const derivedKey = PBKDF2_HMAC_SHA256_OneIter(password, b, dkLen);\n\n                    // Send the result to the callback\n                    if (callback) { callback(null, 1.0, derivedKey); }\n\n                    // Done; don't break (which would reschedule)\n                    return derivedKey;\n            }\n\n            // Schedule the next steps\n            if (callback) { nextTick(incrementalSMix); }\n        }\n\n        // Run the smix state machine until completion\n        if (!callback) {\n            while (true) {\n                const derivedKey = incrementalSMix();\n                if (derivedKey != undefined) { return derivedKey; }\n            }\n        }\n\n        // Bootstrap the async incremental smix\n        incrementalSMix();\n    }\n\n    const lib = {\n        scrypt: function(password, salt, N, r, p, dkLen, progressCallback) {\n            return new Promise(function(resolve, reject) {\n                let lastProgress = 0;\n                if (progressCallback) { progressCallback(0); }\n                _scrypt(password, salt, N, r, p, dkLen, function(error, progress, key) {\n                    if (error) {\n                        reject(error);\n                    } else if (key) {\n                        if (progressCallback && lastProgress !== 1) {\n                            progressCallback(1);\n                        }\n                        resolve(new Uint8Array(key));\n                    } else if (progressCallback && progress !== lastProgress) {\n                        lastProgress = progress;\n                        return progressCallback(progress);\n                    }\n                });\n            });\n        },\n        syncScrypt: function(password, salt, N, r, p, dkLen) {\n            return new Uint8Array(_scrypt(password, salt, N, r, p, dkLen));\n        }\n    };\n\n    // node.js\n    if (typeof(exports) !== 'undefined') {\n       module.exports = lib;\n\n    // RequireJS/AMD\n    // http://www.requirejs.org/docs/api.html\n    // https://github.com/amdjs/amdjs-api/wiki/AMD\n    } else if (typeof(define) === 'function' && define.amd) {\n        define(lib);\n\n    // Web Browsers\n    } else if (root) {\n\n        // If there was an existing library \"scrypt\", make sure it is still available\n        if (root.scrypt) {\n            root._scrypt = root.scrypt;\n        }\n\n        root.scrypt = lib;\n    }\n\n})(this);\n","//\n//\n//\n//\nvar script = {\n  props: {\n    height: {\n      type: [Number, String],\n      default: 100\n    },\n    width: {\n      type: [Number, String],\n      default: 100\n    },\n    color: {\n      type: String,\n      default: 'rgba(0, 0, 0, 0.12)'\n    },\n    animation: {\n      type: String,\n      default: 'wave'\n    }\n  },\n  computed: {\n    bindClass() {\n      return `animation--${this.animation}`;\n    }\n\n  },\n\n  mounted() {\n    const width = typeof this.width === 'number' ? `${this.width}px` : this.width;\n    const height = typeof this.width === 'number' ? `${this.height}px` : this.height;\n    const background = `${this.color}`;\n    const loader = this.$el;\n    loader.style.setProperty('width', width);\n    loader.style.setProperty('height', height);\n    loader.style.setProperty('background-color', background);\n  }\n\n};\n\nfunction normalizeComponent(template, style, script, scopeId, isFunctionalTemplate, moduleIdentifier /* server only */, shadowMode, createInjector, createInjectorSSR, createInjectorShadow) {\r\n    if (typeof shadowMode !== 'boolean') {\r\n        createInjectorSSR = createInjector;\r\n        createInjector = shadowMode;\r\n        shadowMode = false;\r\n    }\r\n    // Vue.extend constructor export interop.\r\n    const options = typeof script === 'function' ? script.options : script;\r\n    // render functions\r\n    if (template && template.render) {\r\n        options.render = template.render;\r\n        options.staticRenderFns = template.staticRenderFns;\r\n        options._compiled = true;\r\n        // functional template\r\n        if (isFunctionalTemplate) {\r\n            options.functional = true;\r\n        }\r\n    }\r\n    // scopedId\r\n    if (scopeId) {\r\n        options._scopeId = scopeId;\r\n    }\r\n    let hook;\r\n    if (moduleIdentifier) {\r\n        // server build\r\n        hook = function (context) {\r\n            // 2.3 injection\r\n            context =\r\n                context || // cached call\r\n                    (this.$vnode && this.$vnode.ssrContext) || // stateful\r\n                    (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext); // functional\r\n            // 2.2 with runInNewContext: true\r\n            if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {\r\n                context = __VUE_SSR_CONTEXT__;\r\n            }\r\n            // inject component styles\r\n            if (style) {\r\n                style.call(this, createInjectorSSR(context));\r\n            }\r\n            // register component module identifier for async chunk inference\r\n            if (context && context._registeredComponents) {\r\n                context._registeredComponents.add(moduleIdentifier);\r\n            }\r\n        };\r\n        // used by ssr in case component is cached and beforeCreate\r\n        // never gets called\r\n        options._ssrRegister = hook;\r\n    }\r\n    else if (style) {\r\n        hook = shadowMode\r\n            ? function (context) {\r\n                style.call(this, createInjectorShadow(context, this.$root.$options.shadowRoot));\r\n            }\r\n            : function (context) {\r\n                style.call(this, createInjector(context));\r\n            };\r\n    }\r\n    if (hook) {\r\n        if (options.functional) {\r\n            // register for functional component in vue file\r\n            const originalRender = options.render;\r\n            options.render = function renderWithStyleInjection(h, context) {\r\n                hook.call(context);\r\n                return originalRender(h, context);\r\n            };\r\n        }\r\n        else {\r\n            // inject component registration as beforeCreate hook\r\n            const existing = options.beforeCreate;\r\n            options.beforeCreate = existing ? [].concat(existing, hook) : [hook];\r\n        }\r\n    }\r\n    return script;\r\n}\n\nconst isOldIE = typeof navigator !== 'undefined' &&\r\n    /msie [6-9]\\\\b/.test(navigator.userAgent.toLowerCase());\r\nfunction createInjector(context) {\r\n    return (id, style) => addStyle(id, style);\r\n}\r\nlet HEAD;\r\nconst styles = {};\r\nfunction addStyle(id, css) {\r\n    const group = isOldIE ? css.media || 'default' : id;\r\n    const style = styles[group] || (styles[group] = { ids: new Set(), styles: [] });\r\n    if (!style.ids.has(id)) {\r\n        style.ids.add(id);\r\n        let code = css.source;\r\n        if (css.map) {\r\n            // https://developer.chrome.com/devtools/docs/javascript-debugging\r\n            // this makes source maps inside style tags work properly in Chrome\r\n            code += '\\n/*# sourceURL=' + css.map.sources[0] + ' */';\r\n            // http://stackoverflow.com/a/26603875\r\n            code +=\r\n                '\\n/*# sourceMappingURL=data:application/json;base64,' +\r\n                    btoa(unescape(encodeURIComponent(JSON.stringify(css.map)))) +\r\n                    ' */';\r\n        }\r\n        if (!style.element) {\r\n            style.element = document.createElement('style');\r\n            style.element.type = 'text/css';\r\n            if (css.media)\r\n                style.element.setAttribute('media', css.media);\r\n            if (HEAD === undefined) {\r\n                HEAD = document.head || document.getElementsByTagName('head')[0];\r\n            }\r\n            HEAD.appendChild(style.element);\r\n        }\r\n        if ('styleSheet' in style.element) {\r\n            style.styles.push(code);\r\n            style.element.styleSheet.cssText = style.styles\r\n                .filter(Boolean)\r\n                .join('\\n');\r\n        }\r\n        else {\r\n            const index = style.ids.size - 1;\r\n            const textNode = document.createTextNode(code);\r\n            const nodes = style.element.childNodes;\r\n            if (nodes[index])\r\n                style.element.removeChild(nodes[index]);\r\n            if (nodes.length)\r\n                style.element.insertBefore(textNode, nodes[index]);\r\n            else\r\n                style.element.appendChild(textNode);\r\n        }\r\n    }\r\n}\n\n/* script */\nconst __vue_script__ = script;\n/* template */\n\nvar __vue_render__ = function () {\n  var _vm = this;\n\n  var _h = _vm.$createElement;\n\n  var _c = _vm._self._c || _h;\n\n  return _c('div', {\n    staticClass: \"loader loader--circle\",\n    class: _vm.bindClass\n  });\n};\n\nvar __vue_staticRenderFns__ = [];\n/* style */\n\nconst __vue_inject_styles__ = function (inject) {\n  if (!inject) return;\n  inject(\"data-v-c49d1d20_0\", {\n    source: \".loader--circle[data-v-c49d1d20]{overflow:hidden;width:100px;height:100px;background-color:red;border-radius:50%;position:relative}.loader--circle[data-v-c49d1d20]::before{content:\\\"\\\";display:block;position:absolute;left:0;right:0;bottom:0;top:0}\",\n    map: undefined,\n    media: undefined\n  });\n};\n/* scoped */\n\n\nconst __vue_scope_id__ = \"data-v-c49d1d20\";\n/* module identifier */\n\nconst __vue_module_identifier__ = undefined;\n/* functional template */\n\nconst __vue_is_functional_template__ = false;\n/* style inject SSR */\n\n/* style inject shadow dom */\n\nconst __vue_component__ = /*#__PURE__*/normalizeComponent({\n  render: __vue_render__,\n  staticRenderFns: __vue_staticRenderFns__\n}, __vue_inject_styles__, __vue_script__, __vue_scope_id__, __vue_is_functional_template__, __vue_module_identifier__, false, createInjector, undefined, undefined);\n\n//\n//\n//\n//\nvar script$1 = {\n  props: {\n    height: {\n      type: [Number, String],\n      default: 100\n    },\n    width: {\n      type: [Number, String],\n      default: 200\n    },\n    color: {\n      type: String,\n      default: 'rgba(0, 0, 0, 0.12)'\n    },\n    animation: {\n      type: String,\n      default: 'wave'\n    },\n    type: {\n      type: String,\n      default: 'rect'\n    },\n    rounded: {\n      type: Boolean,\n      default: false\n    },\n    radius: {\n      type: [Number, String],\n      default: 0\n    }\n  },\n  computed: {\n    style() {\n      return {\n        width: typeof this.width === 'number' ? `${this.width}px` : this.width,\n        height: typeof this.width === 'number' ? `${this.height}px` : this.height,\n        'background-color': `${this.color}`,\n        'border-radius': this.rounded ? `${this.radius}px` : 0\n      };\n    },\n\n    bindClass() {\n      return `animation--${this.animation} shape--${this.type} shape--${this.rounded ? 'round' : 'flat'}`;\n    }\n\n  },\n\n  mounted() {\n    const width = typeof this.width === 'number' ? `${this.width}px` : this.width;\n    const height = typeof this.width === 'number' ? `${this.height}px` : this.height;\n    const background = `${this.color}`;\n    const borderRadius = this.rounded ? `${this.radius}px` : 0;\n    const loader = this.$el;\n    loader.style.setProperty('width', width);\n    loader.style.setProperty('height', height);\n    loader.style.setProperty('background-color', background);\n    loader.style.setProperty('border-radius', borderRadius);\n  }\n\n};\n\n/* script */\nconst __vue_script__$1 = script$1;\n/* template */\n\nvar __vue_render__$1 = function () {\n  var _vm = this;\n\n  var _h = _vm.$createElement;\n\n  var _c = _vm._self._c || _h;\n\n  return _c('div', {\n    staticClass: \"loader\",\n    class: _vm.bindClass\n  });\n};\n\nvar __vue_staticRenderFns__$1 = [];\n/* style */\n\nconst __vue_inject_styles__$1 = function (inject) {\n  if (!inject) return;\n  inject(\"data-v-39eb697a_0\", {\n    source: \".loader[data-v-39eb697a]{overflow:hidden;position:relative}.loader[data-v-39eb697a]::before{content:\\\"\\\";display:block;position:absolute;left:0;right:0;bottom:0;top:0}.shape--text[data-v-39eb697a]{height:20px}.shape--round[data-v-39eb697a]{border-radius:8px}\",\n    map: undefined,\n    media: undefined\n  });\n};\n/* scoped */\n\n\nconst __vue_scope_id__$1 = \"data-v-39eb697a\";\n/* module identifier */\n\nconst __vue_module_identifier__$1 = undefined;\n/* functional template */\n\nconst __vue_is_functional_template__$1 = false;\n/* style inject SSR */\n\n/* style inject shadow dom */\n\nconst __vue_component__$1 = /*#__PURE__*/normalizeComponent({\n  render: __vue_render__$1,\n  staticRenderFns: __vue_staticRenderFns__$1\n}, __vue_inject_styles__$1, __vue_script__$1, __vue_scope_id__$1, __vue_is_functional_template__$1, __vue_module_identifier__$1, false, createInjector, undefined, undefined);\n\n//\nvar script$2 = {\n  components: {\n    CircleLoader: __vue_component__,\n    SquareLoader: __vue_component__$1\n  },\n  props: {\n    type: {\n      type: String,\n      default: 'rect'\n    },\n    size: {\n      type: [Number, String]\n    },\n    animation: {\n      type: String,\n      default: 'wave'\n    },\n    height: {\n      type: [Number, String]\n    },\n    width: {\n      type: [Number, String]\n    },\n    color: {\n      type: String,\n      default: 'rgba(0, 0, 0, 0.12)'\n    },\n    waveColor: {\n      type: String\n    },\n    rounded: {\n      type: Boolean,\n      default: false\n    },\n    radius: {\n      type: [Number, String],\n      default: 8\n    }\n  },\n  computed: {\n    loaderWidth() {\n      if (this.size) {\n        return this.size;\n      } else {\n        return this.width;\n      }\n    },\n\n    loaderHeight() {\n      if (this.size) {\n        return this.size;\n      } else {\n        return this.height;\n      }\n    }\n\n  },\n\n  mounted() {\n    if (this.waveColor) {\n      this.$el.style.setProperty('--gradient-color', this.waveColor);\n    }\n  }\n\n};\n\n/* script */\nconst __vue_script__$2 = script$2;\n/* template */\n\nvar __vue_render__$2 = function () {\n  var _vm = this;\n\n  var _h = _vm.$createElement;\n\n  var _c = _vm._self._c || _h;\n\n  return _vm.type === 'circle' ? _c('circle-loader', {\n    attrs: {\n      \"width\": _vm.loaderWidth,\n      \"height\": _vm.loaderHeight,\n      \"animation\": _vm.animation,\n      \"color\": _vm.color\n    }\n  }) : _c('square-loader', {\n    attrs: {\n      \"width\": _vm.loaderWidth,\n      \"height\": _vm.loaderHeight,\n      \"animation\": _vm.animation,\n      \"type\": _vm.type,\n      \"color\": _vm.color,\n      \"rounded\": _vm.rounded,\n      \"radius\": _vm.radius\n    }\n  });\n};\n\nvar __vue_staticRenderFns__$2 = [];\n/* style */\n\nconst __vue_inject_styles__$2 = function (inject) {\n  if (!inject) return;\n  inject(\"data-v-28d24b2c_0\", {\n    source: \".loader{width:fit-content;cursor:wait;--gradient-color:rgba(255, 255, 255, 0.5)}@keyframes fade{0%{opacity:1}50%{opacity:.4}100%{opacity:1}}@keyframes pulse{0%{transform:scale(1)}50%{transform:scale(.85)}100%{transform:scale(1)}}@keyframes pulse-x{0%{transform:scaleX(1)}50%{transform:scaleX(.75)}100%{transform:scaleX(1)}}@keyframes pulse-y{0%{transform:scaleY(1)}50%{transform:scaleY(.75)}100%{transform:scaleY(1)}}@keyframes wave{0%{transform:translateX(-100%)}100%{transform:translateX(100%)}}.animation--fade{animation:fade 1.5s linear .5s infinite}.animation--wave::before{background:linear-gradient(90deg,transparent,rgba(255,255,255,.5),transparent);background:linear-gradient(90deg,transparent,var(--gradient-color),transparent);animation:wave 1.5s linear .5s infinite}.animation--pulse-x{animation:pulse-x 1.5s linear .5s infinite}.animation--pulse-y{animation:pulse-y 1.5s linear .5s infinite}.animation--pulse{animation:pulse 1.5s linear .5s infinite}\",\n    map: undefined,\n    media: undefined\n  });\n};\n/* scoped */\n\n\nconst __vue_scope_id__$2 = undefined;\n/* module identifier */\n\nconst __vue_module_identifier__$2 = undefined;\n/* functional template */\n\nconst __vue_is_functional_template__$2 = false;\n/* style inject SSR */\n\n/* style inject shadow dom */\n\nconst __vue_component__$2 = /*#__PURE__*/normalizeComponent({\n  render: __vue_render__$2,\n  staticRenderFns: __vue_staticRenderFns__$2\n}, __vue_inject_styles__$2, __vue_script__$2, __vue_scope_id__$2, __vue_is_functional_template__$2, __vue_module_identifier__$2, false, createInjector, undefined, undefined);\n\n// Import vue components\n\nconst install = function installSkeletonLoaderVue(Vue) {\n  if (install.installed) return;\n  install.installed = true;\n  Vue.component('skeleton-loader-vue', __vue_component__$2);\n}; // Create module definition for Vue.use()\n\n__vue_component__$2.install = install; // Export component by default\n\nexport default __vue_component__$2;\n","'use strict';\n\nmodule.exports = string => {\n\tif (typeof string !== 'string') {\n\t\tthrow new TypeError('Expected a string');\n\t}\n\n\t// Escape characters with special meaning either inside or outside character sets.\n\t// Use a simple backslash escape when it’s always valid, and a \\unnnn escape when the simpler form would be disallowed by Unicode patterns’ stricter grammar.\n\treturn string\n\t\t.replace(/[|\\\\{}()[\\]^$+*?.]/g, '\\\\$&')\n\t\t.replace(/-/g, '\\\\x2d');\n};\n","'use strict'\n\nlet { SourceMapConsumer, SourceMapGenerator } = require('source-map-js')\nlet { fileURLToPath, pathToFileURL } = require('url')\nlet { resolve, isAbsolute } = 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  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      line: min + 1,\n      col: offset - lineToIndex[min] + 1\n    }\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          : { line: origin.line, column: origin.column },\n        origin.endLine === undefined\n          ? origin.column\n          : { line: origin.endLine, column: origin.endColumn },\n        origin.source,\n        origin.file,\n        opts.plugin\n      )\n    } else {\n      result = new CssSyntaxError(\n        message,\n        endLine === undefined ? line : { line, column },\n        endLine === undefined ? column : { line: endLine, column: endColumn },\n        this.css,\n        this.file,\n        opts.plugin\n      )\n    }\n\n    result.input = { line, column, endLine, endColumn, 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  origin(line, column, endLine, endColumn) {\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 to\n    if (typeof endLine === 'number') {\n      to = consumer.originalPositionFor({ line: endLine, column: endColumn })\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      url: fromUrl.toString(),\n      line: from.line,\n      column: from.column,\n      endLine: to && to.line,\n      endColumn: to && to.column\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  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  get from() {\n    return this.file || this.id\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\nmodule.exports = Input\nInput.default = Input\n\nif (terminalHighlight && terminalHighlight.registerInput) {\n  terminalHighlight.registerInput(Input)\n}\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 = /.[\\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    nextToken,\n    endOfFile,\n    position\n  }\n}\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  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  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","/* 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\nlet { SourceMapConsumer, SourceMapGenerator } = require('source-map-js')\nlet { dirname, resolve, relative, 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\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      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  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    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  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  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  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    } else {\n      return window.btoa(unescape(encodeURIComponent(str)))\n    }\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  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  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        source: this.opts.from\n          ? this.toUrl(this.path(this.opts.from))\n          : '<no source>',\n        generated: { line: 1, column: 0 },\n        original: { line: 1, column: 0 }\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  path(file) {\n    if (file.indexOf('<') === 0) return file\n    if (/^\\w+:\\/\\//.test(file)) return file\n    if (this.mapOpts.absolute) return file\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    file = relative(from, file)\n    return file\n  }\n\n  toUrl(path) {\n    if (sep === '\\\\') {\n      path = path.replace(/\\\\/g, '/')\n    }\n    return encodeURI(path).replace(/[#?]/g, encodeURIComponent)\n  }\n\n  toFileUrl(path) {\n    if (pathToFileURL) {\n      return pathToFileURL(path).toString()\n    } else {\n      throw new Error(\n        '`map.absolute` option is not available in this PostCSS build'\n      )\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  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      source: '',\n      generated: { line: 0, column: 0 },\n      original: { line: 0, column: 0 }\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  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\nmodule.exports = MapGenerator\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  error(message, opts = {}) {\n    if (this.source) {\n      let { start, end } = this.rangeBy(opts)\n      return this.source.input.error(\n        message,\n        { line: start.line, column: start.column },\n        { line: end.line, column: end.column },\n        opts\n      )\n    }\n    return new CssSyntaxError(message)\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  remove() {\n    if (this.parent) {\n      this.parent.removeChild(this)\n    }\n    this.parent = undefined\n    return this\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  assign(overrides = {}) {\n    for (let name in overrides) {\n      this[name] = overrides[name]\n    }\n    return this\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  cloneBefore(overrides = {}) {\n    let cloned = this.clone(overrides)\n    this.parent.insertBefore(this, cloned)\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  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  next() {\n    if (!this.parent) return undefined\n    let index = this.parent.index(this)\n    return this.parent.nodes[index + 1]\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  before(add) {\n    this.parent.insertBefore(this, add)\n    return this\n  }\n\n  after(add) {\n    this.parent.insertAfter(this, add)\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  raw(prop, defaultType) {\n    let str = new Stringifier()\n    return str.raw(this, prop, defaultType)\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  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          inputId,\n          start: value.start,\n          end: value.end\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  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  rangeBy(opts) {\n    let start = {\n      line: this.source.start.line,\n      column: this.source.start.column\n    }\n    let end = this.source.end\n      ? {\n          line: this.source.end.line,\n          column: this.source.end.column + 1\n        }\n      : {\n          line: start.line,\n          column: start.column + 1\n        }\n\n    if (opts.word) {\n      let index = this.toString().indexOf(opts.word)\n      if (index !== -1) {\n        start = this.positionInside(index)\n        end = this.positionInside(index + opts.word.length)\n      }\n    } else {\n      if (opts.start) {\n        start = {\n          line: opts.start.line,\n          column: opts.start.column\n        }\n      } else if (opts.index) {\n        start = this.positionInside(opts.index)\n      }\n\n      if (opts.end) {\n        end = {\n          line: opts.end.line,\n          column: opts.end.column\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 = { line: start.line, column: start.column + 1 }\n    }\n\n    return { start, end }\n  }\n\n  getProxyProcessor() {\n    return {\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      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  }\n\n  toProxy() {\n    if (!this.proxyCache) {\n      this.proxyCache = new Proxy(this, this.getProxyProcessor())\n    }\n    return this.proxyCache\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  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  get proxyOf() {\n    return this\n  }\n}\n\nmodule.exports = Node\nNode.default = Node\n","'use strict';\n\nfunction shallowEqualArrays(arrA, arrB) {\n  if (arrA === arrB) {\n    return true;\n  }\n\n  if (!arrA || !arrB) {\n    return false;\n  }\n\n  var len = arrA.length;\n\n  if (arrB.length !== len) {\n    return false;\n  }\n\n  for (var i = 0; i < len; i++) {\n    if (arrA[i] !== arrB[i]) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nmodule.exports = shallowEqualArrays;\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  get [Symbol.toStringTag]() {\n    return 'NoWorkResult'\n  }\n\n  get processor() {\n    return this.result.processor\n  }\n\n  get opts() {\n    return this.result.opts\n  }\n\n  get css() {\n    return this.result.css\n  }\n\n  get content() {\n    return this.result.css\n  }\n\n  get map() {\n    return this.result.map\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 messages() {\n    return []\n  }\n\n  warnings() {\n    return []\n  }\n\n  toString() {\n    return this._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\n    return this.async().then(onFulfilled, onRejected)\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  async() {\n    if (this.error) return Promise.reject(this.error)\n    return Promise.resolve(this.result)\n  }\n\n  sync() {\n    if (this.error) throw this.error\n    return this.result\n  }\n}\n\nmodule.exports = NoWorkResult\nNoWorkResult.default = NoWorkResult\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nfunction safeJsonParse(value) {\n    if (typeof value !== 'string') {\n        throw new Error(`Cannot safe json parse value of type ${typeof value}`);\n    }\n    try {\n        return JSON.parse(value);\n    }\n    catch (_a) {\n        return value;\n    }\n}\nexports.safeJsonParse = safeJsonParse;\nfunction safeJsonStringify(value) {\n    return typeof value === 'string'\n        ? value\n        : JSON.stringify(value, (key, value) => typeof value === 'undefined' ? null : value);\n}\nexports.safeJsonStringify = safeJsonStringify;\n//# sourceMappingURL=index.js.map","'use strict'\n\nmodule.exports.isClean = Symbol('isClean')\n\nmodule.exports.my = Symbol('my')\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  withContent() {\n    return !!(\n      this.consumer().sourcesContent &&\n      this.consumer().sourcesContent.length > 0\n    )\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.replace(/^\\/\\*\\s*# sourceMappingURL=/, '').trim()\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  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  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  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\nmodule.exports = PreviousMap\nPreviousMap.default = PreviousMap\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 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","'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\nmodule.exports = (string, separator) => {\n\tif (!(typeof string === 'string' && typeof separator === 'string')) {\n\t\tthrow new TypeError('Expected the arguments to be of type `string`');\n\t}\n\n\tif (separator === '') {\n\t\treturn [string];\n\t}\n\n\tconst separatorIndex = string.indexOf(separator);\n\n\tif (separatorIndex === -1) {\n\t\treturn [string];\n\t}\n\n\treturn [\n\t\tstring.slice(0, separatorIndex),\n\t\tstring.slice(separatorIndex + separator.length)\n\t];\n};\n","'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  push(child) {\n    child.parent = this\n    this.proxyOf.nodes.push(child)\n    return this\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  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  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  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  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  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  cleanRaws(keepBetween) {\n    super.cleanRaws(keepBetween)\n    if (this.nodes) {\n      for (let node of this.nodes) node.cleanRaws(keepBetween)\n    }\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  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  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  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  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  every(condition) {\n    return this.nodes.every(condition)\n  }\n\n  some(condition) {\n    return this.nodes.some(condition)\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  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  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  getProxyProcessor() {\n    return {\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      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  }\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\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"],"sourceRoot":""}