{"version":3,"sources":["webpack:///./node_modules/sanitize-html/node_modules/postcss/lib/lazy-result.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/secp256k1/elliptic.js","webpack:///./node_modules/secp256k1/lib/index.js","webpack:///./node_modules/sanitize-html/node_modules/postcss/lib/css-syntax-error.js","webpack:///./node_modules/secp256k1/lib/elliptic.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/sanitize-html/node_modules/postcss/lib/declaration.js","webpack:///./node_modules/sanitize-html/node_modules/postcss/lib/document.js","webpack:///./node_modules/safe-buffer/index.js","webpack:///./node_modules/sanitize-html/node_modules/is-plain-object/dist/is-plain-object.mjs","webpack:///./node_modules/sanitize-html/node_modules/postcss/lib/processor.js","webpack:///./node_modules/scrypt-js/scrypt.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/sanitize-html/node_modules/postcss/lib/no-work-result.js","webpack:///./node_modules/safer-buffer/safer.js","webpack:///./node_modules/safe-json-utils/dist/cjs/index.js","webpack:///./node_modules/sanitize-html/node_modules/nanoid/non-secure/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/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","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","list","defaults","super","selectors","comma","selector","values","match","sep","raw","join","registerRule","CssSyntaxError","Processor","fromJSON","Warning","Input","Node","Array","isArray","initializer","cache","warningPrinted","creator","args","warn","startsWith","transformer","defineProperty","get","process","processOpts","pluginOpts","atRule","errors","assert","cond","msg","isUint8Array","value","Uint8Array","includes","isCompressed","toTypeString","getAssertedOutput","output","len","prototype","call","slice","secp256k1","contextRandomize","seed","privateKeyVerify","seckey","privateKeyNegate","privateKeyTweakAdd","tweak","privateKeyTweakMul","publicKeyVerify","pubkey","publicKeyCreate","compressed","publicKeyConvert","publicKeyNegate","publicKeyCombine","pubkeys","publicKeyTweakAdd","publicKeyTweakMul","signatureNormalize","sig","signatureExport","outputlen","signatureImport","ecdsaSign","msg32","options","noncefn","signature","recid","ecdsaVerify","ecdsaRecover","ecdh","hashfn","xbuf","ybuf","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","index","number","gutter","spacing","replace","code","ec","EC","ecparams","curve","BN","n","loadPublicKey","first","x","cmp","p","toRed","y","redSqr","redIMul","redIAdd","b","redSqrt","isOdd","redNeg","keyPair","pub","loadCompressedPublicKey","subarray","x3","redISub","isZero","loadUncompressedPublicKey","savePublicKey","point","encode","bn","negate","sub","umod","toArrayLike","set","iadd","isub","tweaked","imul","keyFromPrivate","getPublic","pair","pairs","isInfinity","g","mul","s","nh","sigR","sigS","lenR","posR","lenS","posS","_noncefn","counter","nonce","d","sign","canonical","k","pers","recoveryParam","sigObj","sigr","sigs","verify","recoverPubKey","scalar","sha256","hash","update","digest","getX","toArray","getY","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","checkMissedSemicolon","unnamedAtrule","open","params","afterName","spacesAndCommentsFromStart","after","unexpectedClose","unclosedBlock","ownSemicolon","fromOffset","col","clean","reduce","lastTokenType","from","splice","element","entries","doubleColon","founded","separators","array","func","inQuote","prevQuote","escape","letter","warning","htmlparser","escapeStringRegexp","isPlainObject","deepmerge","parseSrcset","postcssParse","mediaTags","vulnerableTags","has","hasOwnProperty","a","v","sanitizeHtml","VALID_HTML_ATTRIBUTE_NAME","html","_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","Parser","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","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","rawCache","beforeAfter","method","toUpperCase","capitalize","walk","rawSemicolon","rawEmptyBody","rawIndent","parts","rawBeforeComment","walkComments","rawBeforeDecl","walkDecls","rawBeforeRule","rawBeforeClose","rawBeforeOpen","rawColon","buf","step","registerParse","range","rangeBy","opt","word","variable","toResult","registerProcessor","buffer","Buffer","copyProps","src","dst","SafeBuffer","arg","encodingOrOffset","alloc","allocUnsafe","allocUnsafeSlow","create","TypeError","size","fill","encoding","SlowBuffer","isObject","ctor","prot","NoWorkResult","normalize","use","normalized","MAX_VALUE","SHA256","m","K","Uint32Array","h0","h1","h2","h3","h4","h5","h6","h7","blocks","off","u","t1","t2","c","f","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","B","S","Si","D","srcPos","dest","destPos","checkBufferish","ensureInteger","_scrypt","N","callback","XY","V","totalOps","i1","Bi","currentOp","lastPercent10","stop","state","i0","limit","parseInt","nextTick","setImmediate","setTimeout","incrementalSMix","steps","percent10","derivedKey","lib","scrypt","progressCallback","lastProgress","progress","syncScrypt","SourceMapConsumer","SourceMapGenerator","fileURLToPath","pathToFileURL","isAbsolute","nanoid","PreviousMap","fromOffsetCache","sourceMapAvailable","Boolean","pathAvailable","hasBOM","consumer","mapResolve","id","lastLine","lineToIndex","prevIndex","l","mid","origin","to","fromUrl","originalPositionFor","sourceRoot","mapFile","sourceContentFor","toJSON","json","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","returned","unclosed","what","ignoreUnclosed","controlChar","fromCharCode","charAt","position","removeChild","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","window","btoa","unescape","encodeURIComponent","addAnnotation","outputFile","eol","generateMap","generateString","fromSourceMap","addMapping","generated","original","encodeURI","sourcePath","noSource","mapping","lastIndexOf","cloneNode","cloned","clone","remove","overrides","cloneBefore","insertBefore","cloneAfter","insertAfter","replaceWith","bookmark","foundSelf","defaultType","cleanRaws","keepBetween","_","inputs","fixed","emitInputs","Map","inputsNextIndex","inputId","positionInside","positionBy","endIndex","getProxyProcessor","markDirty","proxyCache","Proxy","postcssNode","_processor","_css","_opts","_map","self","generatedCSS","generatedMap","_root","safer","Safer","RangeError","kStringMaxLength","binding","constants","MAX_LENGTH","kMaxLength","MAX_STRING_LENGTH","safeJsonParse","JSON","_a","safeJsonStringify","customAlphabet","alphabet","defaultSize","random","existsSync","readFileSync","fromBase64","atob","loadAnnotation","startWith","loadMap","getAnnotationURL","sourceMapString","comments","decodeInline","decodeURIComponent","lastMatch","loadFile","prevPath","mappings","_mappings","sections","ownInputs","inputHydrated","__proto__","children","prepend","registerAtRule","cleanSource","markDirtyUp","walkRules","walkAtRules","reverse","unshift","exist","existIndex","removeAll","replaceValues","pattern","props","fast","every","condition","lastEach","setPrototypeOf"],"mappings":"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","file":"js/chunk-vendors~c8728516.504f85e9.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","'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","module.exports = require('./lib')(require('./lib/elliptic'))\n","const errors = {\n  IMPOSSIBLE_CASE: 'Impossible case. Please create issue.',\n  TWEAK_ADD:\n    'The tweak was out of range or the resulted private key is invalid',\n  TWEAK_MUL: 'The tweak was out of range or equal to zero',\n  CONTEXT_RANDOMIZE_UNKNOW: 'Unknow error on context randomization',\n  SECKEY_INVALID: 'Private Key is invalid',\n  PUBKEY_PARSE: 'Public Key could not be parsed',\n  PUBKEY_SERIALIZE: 'Public Key serialization error',\n  PUBKEY_COMBINE: 'The sum of the public keys is not valid',\n  SIG_PARSE: 'Signature could not be parsed',\n  SIGN: 'The nonce generation function failed, or the private key was invalid',\n  RECOVER: 'Public key could not be recover',\n  ECDH: 'Scalar was invalid (zero or overflow)'\n}\n\nfunction assert (cond, msg) {\n  if (!cond) throw new Error(msg)\n}\n\nfunction isUint8Array (name, value, length) {\n  assert(value instanceof Uint8Array, `Expected ${name} to be an Uint8Array`)\n\n  if (length !== undefined) {\n    if (Array.isArray(length)) {\n      const numbers = length.join(', ')\n      const msg = `Expected ${name} to be an Uint8Array with length [${numbers}]`\n      assert(length.includes(value.length), msg)\n    } else {\n      const msg = `Expected ${name} to be an Uint8Array with length ${length}`\n      assert(value.length === length, msg)\n    }\n  }\n}\n\nfunction isCompressed (value) {\n  assert(toTypeString(value) === 'Boolean', 'Expected compressed to be a Boolean')\n}\n\nfunction getAssertedOutput (output = (len) => new Uint8Array(len), length) {\n  if (typeof output === 'function') output = output(length)\n  isUint8Array('output', output, length)\n  return output\n}\n\nfunction toTypeString (value) {\n  return Object.prototype.toString.call(value).slice(8, -1)\n}\n\nmodule.exports = (secp256k1) => {\n  return {\n    contextRandomize (seed) {\n      assert(\n        seed === null || seed instanceof Uint8Array,\n        'Expected seed to be an Uint8Array or null'\n      )\n      if (seed !== null) isUint8Array('seed', seed, 32)\n\n      switch (secp256k1.contextRandomize(seed)) {\n        case 1:\n          throw new Error(errors.CONTEXT_RANDOMIZE_UNKNOW)\n      }\n    },\n\n    privateKeyVerify (seckey) {\n      isUint8Array('private key', seckey, 32)\n\n      return secp256k1.privateKeyVerify(seckey) === 0\n    },\n\n    privateKeyNegate (seckey) {\n      isUint8Array('private key', seckey, 32)\n\n      switch (secp256k1.privateKeyNegate(seckey)) {\n        case 0:\n          return seckey\n        case 1:\n          throw new Error(errors.IMPOSSIBLE_CASE)\n      }\n    },\n\n    privateKeyTweakAdd (seckey, tweak) {\n      isUint8Array('private key', seckey, 32)\n      isUint8Array('tweak', tweak, 32)\n\n      switch (secp256k1.privateKeyTweakAdd(seckey, tweak)) {\n        case 0:\n          return seckey\n        case 1:\n          throw new Error(errors.TWEAK_ADD)\n      }\n    },\n\n    privateKeyTweakMul (seckey, tweak) {\n      isUint8Array('private key', seckey, 32)\n      isUint8Array('tweak', tweak, 32)\n\n      switch (secp256k1.privateKeyTweakMul(seckey, tweak)) {\n        case 0:\n          return seckey\n        case 1:\n          throw new Error(errors.TWEAK_MUL)\n      }\n    },\n\n    publicKeyVerify (pubkey) {\n      isUint8Array('public key', pubkey, [33, 65])\n\n      return secp256k1.publicKeyVerify(pubkey) === 0\n    },\n\n    publicKeyCreate (seckey, compressed = true, output) {\n      isUint8Array('private key', seckey, 32)\n      isCompressed(compressed)\n      output = getAssertedOutput(output, compressed ? 33 : 65)\n\n      switch (secp256k1.publicKeyCreate(output, seckey)) {\n        case 0:\n          return output\n        case 1:\n          throw new Error(errors.SECKEY_INVALID)\n        case 2:\n          throw new Error(errors.PUBKEY_SERIALIZE)\n      }\n    },\n\n    publicKeyConvert (pubkey, compressed = true, output) {\n      isUint8Array('public key', pubkey, [33, 65])\n      isCompressed(compressed)\n      output = getAssertedOutput(output, compressed ? 33 : 65)\n\n      switch (secp256k1.publicKeyConvert(output, pubkey)) {\n        case 0:\n          return output\n        case 1:\n          throw new Error(errors.PUBKEY_PARSE)\n        case 2:\n          throw new Error(errors.PUBKEY_SERIALIZE)\n      }\n    },\n\n    publicKeyNegate (pubkey, compressed = true, output) {\n      isUint8Array('public key', pubkey, [33, 65])\n      isCompressed(compressed)\n      output = getAssertedOutput(output, compressed ? 33 : 65)\n\n      switch (secp256k1.publicKeyNegate(output, pubkey)) {\n        case 0:\n          return output\n        case 1:\n          throw new Error(errors.PUBKEY_PARSE)\n        case 2:\n          throw new Error(errors.IMPOSSIBLE_CASE)\n        case 3:\n          throw new Error(errors.PUBKEY_SERIALIZE)\n      }\n    },\n\n    publicKeyCombine (pubkeys, compressed = true, output) {\n      assert(Array.isArray(pubkeys), 'Expected public keys to be an Array')\n      assert(pubkeys.length > 0, 'Expected public keys array will have more than zero items')\n      for (const pubkey of pubkeys) {\n        isUint8Array('public key', pubkey, [33, 65])\n      }\n      isCompressed(compressed)\n      output = getAssertedOutput(output, compressed ? 33 : 65)\n\n      switch (secp256k1.publicKeyCombine(output, pubkeys)) {\n        case 0:\n          return output\n        case 1:\n          throw new Error(errors.PUBKEY_PARSE)\n        case 2:\n          throw new Error(errors.PUBKEY_COMBINE)\n        case 3:\n          throw new Error(errors.PUBKEY_SERIALIZE)\n      }\n    },\n\n    publicKeyTweakAdd (pubkey, tweak, compressed = true, output) {\n      isUint8Array('public key', pubkey, [33, 65])\n      isUint8Array('tweak', tweak, 32)\n      isCompressed(compressed)\n      output = getAssertedOutput(output, compressed ? 33 : 65)\n\n      switch (secp256k1.publicKeyTweakAdd(output, pubkey, tweak)) {\n        case 0:\n          return output\n        case 1:\n          throw new Error(errors.PUBKEY_PARSE)\n        case 2:\n          throw new Error(errors.TWEAK_ADD)\n      }\n    },\n\n    publicKeyTweakMul (pubkey, tweak, compressed = true, output) {\n      isUint8Array('public key', pubkey, [33, 65])\n      isUint8Array('tweak', tweak, 32)\n      isCompressed(compressed)\n      output = getAssertedOutput(output, compressed ? 33 : 65)\n\n      switch (secp256k1.publicKeyTweakMul(output, pubkey, tweak)) {\n        case 0:\n          return output\n        case 1:\n          throw new Error(errors.PUBKEY_PARSE)\n        case 2:\n          throw new Error(errors.TWEAK_MUL)\n      }\n    },\n\n    signatureNormalize (sig) {\n      isUint8Array('signature', sig, 64)\n\n      switch (secp256k1.signatureNormalize(sig)) {\n        case 0:\n          return sig\n        case 1:\n          throw new Error(errors.SIG_PARSE)\n      }\n    },\n\n    signatureExport (sig, output) {\n      isUint8Array('signature', sig, 64)\n      output = getAssertedOutput(output, 72)\n\n      const obj = { output, outputlen: 72 }\n      switch (secp256k1.signatureExport(obj, sig)) {\n        case 0:\n          return output.slice(0, obj.outputlen)\n        case 1:\n          throw new Error(errors.SIG_PARSE)\n        case 2:\n          throw new Error(errors.IMPOSSIBLE_CASE)\n      }\n    },\n\n    signatureImport (sig, output) {\n      isUint8Array('signature', sig)\n      output = getAssertedOutput(output, 64)\n\n      switch (secp256k1.signatureImport(output, sig)) {\n        case 0:\n          return output\n        case 1:\n          throw new Error(errors.SIG_PARSE)\n        case 2:\n          throw new Error(errors.IMPOSSIBLE_CASE)\n      }\n    },\n\n    ecdsaSign (msg32, seckey, options = {}, output) {\n      isUint8Array('message', msg32, 32)\n      isUint8Array('private key', seckey, 32)\n      assert(toTypeString(options) === 'Object', 'Expected options to be an Object')\n      if (options.data !== undefined) isUint8Array('options.data', options.data)\n      if (options.noncefn !== undefined) assert(toTypeString(options.noncefn) === 'Function', 'Expected options.noncefn to be a Function')\n      output = getAssertedOutput(output, 64)\n\n      const obj = { signature: output, recid: null }\n      switch (secp256k1.ecdsaSign(obj, msg32, seckey, options.data, options.noncefn)) {\n        case 0:\n          return obj\n        case 1:\n          throw new Error(errors.SIGN)\n        case 2:\n          throw new Error(errors.IMPOSSIBLE_CASE)\n      }\n    },\n\n    ecdsaVerify (sig, msg32, pubkey) {\n      isUint8Array('signature', sig, 64)\n      isUint8Array('message', msg32, 32)\n      isUint8Array('public key', pubkey, [33, 65])\n\n      switch (secp256k1.ecdsaVerify(sig, msg32, pubkey)) {\n        case 0:\n          return true\n        case 3:\n          return false\n        case 1:\n          throw new Error(errors.SIG_PARSE)\n        case 2:\n          throw new Error(errors.PUBKEY_PARSE)\n      }\n    },\n\n    ecdsaRecover (sig, recid, msg32, compressed = true, output) {\n      isUint8Array('signature', sig, 64)\n      assert(\n        toTypeString(recid) === 'Number' &&\n          recid >= 0 &&\n          recid <= 3,\n        'Expected recovery id to be a Number within interval [0, 3]'\n      )\n      isUint8Array('message', msg32, 32)\n      isCompressed(compressed)\n      output = getAssertedOutput(output, compressed ? 33 : 65)\n\n      switch (secp256k1.ecdsaRecover(output, sig, recid, msg32)) {\n        case 0:\n          return output\n        case 1:\n          throw new Error(errors.SIG_PARSE)\n        case 2:\n          throw new Error(errors.RECOVER)\n        case 3:\n          throw new Error(errors.IMPOSSIBLE_CASE)\n      }\n    },\n\n    ecdh (pubkey, seckey, options = {}, output) {\n      isUint8Array('public key', pubkey, [33, 65])\n      isUint8Array('private key', seckey, 32)\n      assert(toTypeString(options) === 'Object', 'Expected options to be an Object')\n      if (options.data !== undefined) isUint8Array('options.data', options.data)\n      if (options.hashfn !== undefined) {\n        assert(toTypeString(options.hashfn) === 'Function', 'Expected options.hashfn to be a Function')\n        if (options.xbuf !== undefined) isUint8Array('options.xbuf', options.xbuf, 32)\n        if (options.ybuf !== undefined) isUint8Array('options.ybuf', options.ybuf, 32)\n        isUint8Array('output', output)\n      } else {\n        output = getAssertedOutput(output, 32)\n      }\n\n      switch (secp256k1.ecdh(output, pubkey, seckey, options.data, options.hashfn, options.xbuf, options.ybuf)) {\n        case 0:\n          return output\n        case 1:\n          throw new Error(errors.PUBKEY_PARSE)\n        case 2:\n          throw new Error(errors.ECDH)\n      }\n    }\n  }\n}\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","const EC = require('elliptic').ec\n\nconst ec = new EC('secp256k1')\nconst ecparams = ec.curve\n\n// Hack, we can not use bn.js@5, while elliptic uses bn.js@4\n// See https://github.com/indutny/elliptic/issues/191#issuecomment-569888758\nconst BN = ecparams.n.constructor\n\nfunction loadCompressedPublicKey (first, xbuf) {\n  let x = new BN(xbuf)\n\n  // overflow\n  if (x.cmp(ecparams.p) >= 0) return null\n  x = x.toRed(ecparams.red)\n\n  // compute corresponding Y\n  let y = x.redSqr().redIMul(x).redIAdd(ecparams.b).redSqrt()\n  if ((first === 0x03) !== y.isOdd()) y = y.redNeg()\n\n  return ec.keyPair({ pub: { x: x, y: y } })\n}\n\nfunction loadUncompressedPublicKey (first, xbuf, ybuf) {\n  let x = new BN(xbuf)\n  let y = new BN(ybuf)\n\n  // overflow\n  if (x.cmp(ecparams.p) >= 0 || y.cmp(ecparams.p) >= 0) return null\n\n  x = x.toRed(ecparams.red)\n  y = y.toRed(ecparams.red)\n\n  // is odd flag\n  if ((first === 0x06 || first === 0x07) && y.isOdd() !== (first === 0x07)) return null\n\n  // x*x*x + b = y*y\n  const x3 = x.redSqr().redIMul(x)\n  if (!y.redSqr().redISub(x3.redIAdd(ecparams.b)).isZero()) return null\n\n  return ec.keyPair({ pub: { x: x, y: y } })\n}\n\nfunction loadPublicKey (pubkey) {\n  // length should be validated in interface\n  const first = pubkey[0]\n  switch (first) {\n    case 0x02:\n    case 0x03:\n      if (pubkey.length !== 33) return null\n      return loadCompressedPublicKey(first, pubkey.subarray(1, 33))\n    case 0x04:\n    case 0x06:\n    case 0x07:\n      if (pubkey.length !== 65) return null\n      return loadUncompressedPublicKey(first, pubkey.subarray(1, 33), pubkey.subarray(33, 65))\n    default:\n      return null\n  }\n}\n\nfunction savePublicKey (output, point) {\n  const pubkey = point.encode(null, output.length === 33)\n  // Loop should be faster because we do not need create extra Uint8Array\n  // output.set(new Uint8Array(pubkey))\n  for (let i = 0; i < output.length; ++i) output[i] = pubkey[i]\n}\n\nmodule.exports = {\n  contextRandomize () {\n    return 0\n  },\n\n  privateKeyVerify (seckey) {\n    const bn = new BN(seckey)\n    return bn.cmp(ecparams.n) < 0 && !bn.isZero() ? 0 : 1\n  },\n\n  privateKeyNegate (seckey) {\n    const bn = new BN(seckey)\n    const negate = ecparams.n.sub(bn).umod(ecparams.n).toArrayLike(Uint8Array, 'be', 32)\n    seckey.set(negate)\n    return 0\n  },\n\n  privateKeyTweakAdd (seckey, tweak) {\n    const bn = new BN(tweak)\n    if (bn.cmp(ecparams.n) >= 0) return 1\n\n    bn.iadd(new BN(seckey))\n    if (bn.cmp(ecparams.n) >= 0) bn.isub(ecparams.n)\n    if (bn.isZero()) return 1\n\n    const tweaked = bn.toArrayLike(Uint8Array, 'be', 32)\n    seckey.set(tweaked)\n\n    return 0\n  },\n\n  privateKeyTweakMul (seckey, tweak) {\n    let bn = new BN(tweak)\n    if (bn.cmp(ecparams.n) >= 0 || bn.isZero()) return 1\n\n    bn.imul(new BN(seckey))\n    if (bn.cmp(ecparams.n) >= 0) bn = bn.umod(ecparams.n)\n\n    const tweaked = bn.toArrayLike(Uint8Array, 'be', 32)\n    seckey.set(tweaked)\n\n    return 0\n  },\n\n  publicKeyVerify (pubkey) {\n    const pair = loadPublicKey(pubkey)\n    return pair === null ? 1 : 0\n  },\n\n  publicKeyCreate (output, seckey) {\n    const bn = new BN(seckey)\n    if (bn.cmp(ecparams.n) >= 0 || bn.isZero()) return 1\n\n    const point = ec.keyFromPrivate(seckey).getPublic()\n    savePublicKey(output, point)\n\n    return 0\n  },\n\n  publicKeyConvert (output, pubkey) {\n    const pair = loadPublicKey(pubkey)\n    if (pair === null) return 1\n\n    const point = pair.getPublic()\n    savePublicKey(output, point)\n\n    return 0\n  },\n\n  publicKeyNegate (output, pubkey) {\n    const pair = loadPublicKey(pubkey)\n    if (pair === null) return 1\n\n    const point = pair.getPublic()\n    point.y = point.y.redNeg()\n    savePublicKey(output, point)\n\n    return 0\n  },\n\n  publicKeyCombine (output, pubkeys) {\n    const pairs = new Array(pubkeys.length)\n    for (let i = 0; i < pubkeys.length; ++i) {\n      pairs[i] = loadPublicKey(pubkeys[i])\n      if (pairs[i] === null) return 1\n    }\n\n    let point = pairs[0].getPublic()\n    for (let i = 1; i < pairs.length; ++i) point = point.add(pairs[i].pub)\n    if (point.isInfinity()) return 2\n\n    savePublicKey(output, point)\n\n    return 0\n  },\n\n  publicKeyTweakAdd (output, pubkey, tweak) {\n    const pair = loadPublicKey(pubkey)\n    if (pair === null) return 1\n\n    tweak = new BN(tweak)\n    if (tweak.cmp(ecparams.n) >= 0) return 2\n\n    const point = pair.getPublic().add(ecparams.g.mul(tweak))\n    if (point.isInfinity()) return 2\n\n    savePublicKey(output, point)\n\n    return 0\n  },\n\n  publicKeyTweakMul (output, pubkey, tweak) {\n    const pair = loadPublicKey(pubkey)\n    if (pair === null) return 1\n\n    tweak = new BN(tweak)\n    if (tweak.cmp(ecparams.n) >= 0 || tweak.isZero()) return 2\n\n    const point = pair.getPublic().mul(tweak)\n    savePublicKey(output, point)\n\n    return 0\n  },\n\n  signatureNormalize (sig) {\n    const r = new BN(sig.subarray(0, 32))\n    const s = new BN(sig.subarray(32, 64))\n    if (r.cmp(ecparams.n) >= 0 || s.cmp(ecparams.n) >= 0) return 1\n\n    if (s.cmp(ec.nh) === 1) {\n      sig.set(ecparams.n.sub(s).toArrayLike(Uint8Array, 'be', 32), 32)\n    }\n\n    return 0\n  },\n\n  // Copied 1-to-1 from https://github.com/bitcoinjs/bip66/blob/master/index.js\n  // Adapted for Uint8Array instead Buffer\n  signatureExport (obj, sig) {\n    const sigR = sig.subarray(0, 32)\n    const sigS = sig.subarray(32, 64)\n    if (new BN(sigR).cmp(ecparams.n) >= 0) return 1\n    if (new BN(sigS).cmp(ecparams.n) >= 0) return 1\n\n    const { output } = obj\n\n    // Prepare R\n    let r = output.subarray(4, 4 + 33)\n    r[0] = 0x00\n    r.set(sigR, 1)\n\n    let lenR = 33\n    let posR = 0\n    for (; lenR > 1 && r[posR] === 0x00 && !(r[posR + 1] & 0x80); --lenR, ++posR);\n\n    r = r.subarray(posR)\n    if (r[0] & 0x80) return 1\n    if (lenR > 1 && (r[0] === 0x00) && !(r[1] & 0x80)) return 1\n\n    // Prepare S\n    let s = output.subarray(6 + 33, 6 + 33 + 33)\n    s[0] = 0x00\n    s.set(sigS, 1)\n\n    let lenS = 33\n    let posS = 0\n    for (; lenS > 1 && s[posS] === 0x00 && !(s[posS + 1] & 0x80); --lenS, ++posS);\n\n    s = s.subarray(posS)\n    if (s[0] & 0x80) return 1\n    if (lenS > 1 && (s[0] === 0x00) && !(s[1] & 0x80)) return 1\n\n    // Set output length for return\n    obj.outputlen = 6 + lenR + lenS\n\n    // Output in specified format\n    // 0x30 [total-length] 0x02 [R-length] [R] 0x02 [S-length] [S]\n    output[0] = 0x30\n    output[1] = obj.outputlen - 2\n    output[2] = 0x02\n    output[3] = r.length\n    output.set(r, 4)\n    output[4 + lenR] = 0x02\n    output[5 + lenR] = s.length\n    output.set(s, 6 + lenR)\n\n    return 0\n  },\n\n  // Copied 1-to-1 from https://github.com/bitcoinjs/bip66/blob/master/index.js\n  // Adapted for Uint8Array instead Buffer\n  signatureImport (output, sig) {\n    if (sig.length < 8) return 1\n    if (sig.length > 72) return 1\n    if (sig[0] !== 0x30) return 1\n    if (sig[1] !== sig.length - 2) return 1\n    if (sig[2] !== 0x02) return 1\n\n    const lenR = sig[3]\n    if (lenR === 0) return 1\n    if (5 + lenR >= sig.length) return 1\n    if (sig[4 + lenR] !== 0x02) return 1\n\n    const lenS = sig[5 + lenR]\n    if (lenS === 0) return 1\n    if ((6 + lenR + lenS) !== sig.length) return 1\n\n    if (sig[4] & 0x80) return 1\n    if (lenR > 1 && (sig[4] === 0x00) && !(sig[5] & 0x80)) return 1\n\n    if (sig[lenR + 6] & 0x80) return 1\n    if (lenS > 1 && (sig[lenR + 6] === 0x00) && !(sig[lenR + 7] & 0x80)) return 1\n\n    let sigR = sig.subarray(4, 4 + lenR)\n    if (sigR.length === 33 && sigR[0] === 0x00) sigR = sigR.subarray(1)\n    if (sigR.length > 32) return 1\n\n    let sigS = sig.subarray(6 + lenR)\n    if (sigS.length === 33 && sigS[0] === 0x00) sigS = sigS.slice(1)\n    if (sigS.length > 32) throw new Error('S length is too long')\n\n    let r = new BN(sigR)\n    if (r.cmp(ecparams.n) >= 0) r = new BN(0)\n\n    let s = new BN(sig.subarray(6 + lenR))\n    if (s.cmp(ecparams.n) >= 0) s = new BN(0)\n\n    output.set(r.toArrayLike(Uint8Array, 'be', 32), 0)\n    output.set(s.toArrayLike(Uint8Array, 'be', 32), 32)\n\n    return 0\n  },\n\n  ecdsaSign (obj, message, seckey, data, noncefn) {\n    if (noncefn) {\n      const _noncefn = noncefn\n      noncefn = (counter) => {\n        const nonce = _noncefn(message, seckey, null, data, counter)\n\n        const isValid = nonce instanceof Uint8Array && nonce.length === 32\n        if (!isValid) throw new Error('This is the way')\n\n        return new BN(nonce)\n      }\n    }\n\n    const d = new BN(seckey)\n    if (d.cmp(ecparams.n) >= 0 || d.isZero()) return 1\n\n    let sig\n    try {\n      sig = ec.sign(message, seckey, { canonical: true, k: noncefn, pers: data })\n    } catch (err) {\n      return 1\n    }\n\n    obj.signature.set(sig.r.toArrayLike(Uint8Array, 'be', 32), 0)\n    obj.signature.set(sig.s.toArrayLike(Uint8Array, 'be', 32), 32)\n    obj.recid = sig.recoveryParam\n\n    return 0\n  },\n\n  ecdsaVerify (sig, msg32, pubkey) {\n    const sigObj = { r: sig.subarray(0, 32), s: sig.subarray(32, 64) }\n\n    const sigr = new BN(sigObj.r)\n    const sigs = new BN(sigObj.s)\n    if (sigr.cmp(ecparams.n) >= 0 || sigs.cmp(ecparams.n) >= 0) return 1\n    if (sigs.cmp(ec.nh) === 1 || sigr.isZero() || sigs.isZero()) return 3\n\n    const pair = loadPublicKey(pubkey)\n    if (pair === null) return 2\n\n    const point = pair.getPublic()\n    const isValid = ec.verify(msg32, sigObj, point)\n    return isValid ? 0 : 3\n  },\n\n  ecdsaRecover (output, sig, recid, msg32) {\n    const sigObj = { r: sig.slice(0, 32), s: sig.slice(32, 64) }\n\n    const sigr = new BN(sigObj.r)\n    const sigs = new BN(sigObj.s)\n    if (sigr.cmp(ecparams.n) >= 0 || sigs.cmp(ecparams.n) >= 0) return 1\n\n    if (sigr.isZero() || sigs.isZero()) return 2\n\n    // Can throw `throw new Error('Unable to find sencond key candinate');`\n    let point\n    try {\n      point = ec.recoverPubKey(msg32, sigObj, recid)\n    } catch (err) {\n      return 2\n    }\n\n    savePublicKey(output, point)\n\n    return 0\n  },\n\n  ecdh (output, pubkey, seckey, data, hashfn, xbuf, ybuf) {\n    const pair = loadPublicKey(pubkey)\n    if (pair === null) return 1\n\n    const scalar = new BN(seckey)\n    if (scalar.cmp(ecparams.n) >= 0 || scalar.isZero()) return 2\n\n    const point = pair.getPublic().mul(scalar)\n\n    if (hashfn === undefined) {\n      const data = point.encode(null, true)\n      const sha256 = ec.hash().update(data).digest()\n      for (let i = 0; i < 32; ++i) output[i] = sha256[i]\n    } else {\n      if (!xbuf) xbuf = new Uint8Array(32)\n      const x = point.getX().toArray('be', 32)\n      for (let i = 0; i < 32; ++i) xbuf[i] = x[i]\n\n      if (!ybuf) ybuf = new Uint8Array(32)\n      const y = point.getY().toArray('be', 32)\n      for (let i = 0; i < 32; ++i) ybuf[i] = y[i]\n\n      const hash = hashfn(xbuf, ybuf, data)\n\n      const isValid = hash instanceof Uint8Array && hash.length === output.length\n      if (!isValid) return 2\n\n      output.set(hash)\n    }\n\n    return 0\n  }\n}\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","'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","/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */\n/* eslint-disable node/no-deprecated-api */\nvar buffer = require('buffer')\nvar Buffer = buffer.Buffer\n\n// alternative to using Object.keys for old browsers\nfunction copyProps (src, dst) {\n  for (var key in src) {\n    dst[key] = src[key]\n  }\n}\nif (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {\n  module.exports = buffer\n} else {\n  // Copy properties from require('buffer')\n  copyProps(buffer, exports)\n  exports.Buffer = SafeBuffer\n}\n\nfunction SafeBuffer (arg, encodingOrOffset, length) {\n  return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.prototype = Object.create(Buffer.prototype)\n\n// Copy static methods from Buffer\ncopyProps(Buffer, SafeBuffer)\n\nSafeBuffer.from = function (arg, encodingOrOffset, length) {\n  if (typeof arg === 'number') {\n    throw new TypeError('Argument must not be a number')\n  }\n  return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.alloc = function (size, fill, encoding) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  var buf = Buffer(size)\n  if (fill !== undefined) {\n    if (typeof encoding === 'string') {\n      buf.fill(fill, encoding)\n    } else {\n      buf.fill(fill)\n    }\n  } else {\n    buf.fill(0)\n  }\n  return buf\n}\n\nSafeBuffer.allocUnsafe = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return Buffer(size)\n}\n\nSafeBuffer.allocUnsafeSlow = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return buffer.SlowBuffer(size)\n}\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","'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.19'\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","\"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","'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 line.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        if (node.type !== 'decl' || 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\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","/* eslint-disable node/no-deprecated-api */\n\n'use strict'\n\nvar buffer = require('buffer')\nvar Buffer = buffer.Buffer\n\nvar safer = {}\n\nvar key\n\nfor (key in buffer) {\n  if (!buffer.hasOwnProperty(key)) continue\n  if (key === 'SlowBuffer' || key === 'Buffer') continue\n  safer[key] = buffer[key]\n}\n\nvar Safer = safer.Buffer = {}\nfor (key in Buffer) {\n  if (!Buffer.hasOwnProperty(key)) continue\n  if (key === 'allocUnsafe' || key === 'allocUnsafeSlow') continue\n  Safer[key] = Buffer[key]\n}\n\nsafer.Buffer.prototype = Buffer.prototype\n\nif (!Safer.from || Safer.from === Uint8Array.from) {\n  Safer.from = function (value, encodingOrOffset, length) {\n    if (typeof value === 'number') {\n      throw new TypeError('The \"value\" argument must not be of type number. Received type ' + typeof value)\n    }\n    if (value && typeof value.length === 'undefined') {\n      throw new TypeError('The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type ' + typeof value)\n    }\n    return Buffer(value, encodingOrOffset, length)\n  }\n}\n\nif (!Safer.alloc) {\n  Safer.alloc = function (size, fill, encoding) {\n    if (typeof size !== 'number') {\n      throw new TypeError('The \"size\" argument must be of type number. Received type ' + typeof size)\n    }\n    if (size < 0 || size >= 2 * (1 << 30)) {\n      throw new RangeError('The value \"' + size + '\" is invalid for option \"size\"')\n    }\n    var buf = Buffer(size)\n    if (!fill || fill.length === 0) {\n      buf.fill(0)\n    } else if (typeof encoding === 'string') {\n      buf.fill(fill, encoding)\n    } else {\n      buf.fill(fill)\n    }\n    return buf\n  }\n}\n\nif (!safer.kStringMaxLength) {\n  try {\n    safer.kStringMaxLength = process.binding('buffer').kStringMaxLength\n  } catch (e) {\n    // we can't determine kStringMaxLength in environments where process.binding\n    // is unsupported, so let's not set it\n  }\n}\n\nif (!safer.constants) {\n  safer.constants = {\n    MAX_LENGTH: safer.kMaxLength\n  }\n  if (safer.kStringMaxLength) {\n    safer.constants.MAX_STRING_LENGTH = safer.kStringMaxLength\n  }\n}\n\nmodule.exports = safer\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","let urlAlphabet =\n  'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'\nlet customAlphabet = (alphabet, defaultSize = 21) => {\n  return (size = defaultSize) => {\n    let id = ''\n    let i = size\n    while (i--) {\n      id += alphabet[(Math.random() * alphabet.length) | 0]\n    }\n    return id\n  }\n}\nlet nanoid = (size = 21) => {\n  let id = ''\n  let i = size\n  while (i--) {\n    id += urlAlphabet[(Math.random() * 64) | 0]\n  }\n  return id\n}\nexport { nanoid, customAlphabet }\n","'use strict'\n\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\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":""}