{"version":3,"file":"static/js/vendors-c03846fd.0d9a4799.js","mappings":"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","sources":["../node_modules/postcss/lib/at-rule.js","../node_modules/postcss/lib/comment.js","../node_modules/postcss/lib/container.js","../node_modules/postcss/lib/css-syntax-error.js","../node_modules/postcss/lib/declaration.js","../node_modules/postcss/lib/document.js","../node_modules/postcss/lib/fromJSON.js","../node_modules/postcss/lib/input.js","../node_modules/postcss/lib/lazy-result.js","../node_modules/postcss/lib/list.js","../node_modules/postcss/lib/map-generator.js","../node_modules/postcss/lib/no-work-result.js","../node_modules/postcss/lib/node.js","../node_modules/postcss/lib/parse.js","../node_modules/postcss/lib/parser.js","../node_modules/postcss/lib/postcss.js","../node_modules/postcss/lib/previous-map.js","../node_modules/postcss/lib/processor.js","../node_modules/postcss/lib/result.js","../node_modules/postcss/lib/root.js","../node_modules/postcss/lib/rule.js","../node_modules/postcss/lib/stringifier.js","../node_modules/postcss/lib/stringify.js","../node_modules/postcss/lib/symbols.js","../node_modules/postcss/lib/tokenize.js","../node_modules/postcss/lib/warn-once.js","../node_modules/postcss/lib/warning.js","../node_modules/postcss/lib/postcss.mjs"],"sourcesContent":["'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 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 Comment = require('./comment')\nlet Declaration = require('./declaration')\nlet Node = require('./node')\nlet { isClean, my } = require('./symbols')\n\nlet AtRule, parse, Root, Rule\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 markTreeDirty(node) {\n  node[isClean] = false\n  if (node.proxyOf.nodes) {\n    for (let i of node.proxyOf.nodes) {\n      markTreeDirty(i)\n    }\n  }\n}\n\nclass Container extends Node {\n  append(...children) {\n    for (let child of children) {\n      let nodes = this.normalize(child, this.last)\n      for (let node of nodes) this.proxyOf.nodes.push(node)\n    }\n\n    this.markDirty()\n\n    return this\n  }\n\n  cleanRaws(keepBetween) {\n    super.cleanRaws(keepBetween)\n    if (this.nodes) {\n      for (let node of this.nodes) node.cleanRaws(keepBetween)\n    }\n  }\n\n  each(callback) {\n    if (!this.proxyOf.nodes) return undefined\n    let iterator = this.getIterator()\n\n    let index, result\n    while (this.indexes[iterator] < this.proxyOf.nodes.length) {\n      index = this.indexes[iterator]\n      result = callback(this.proxyOf.nodes[index], index)\n      if (result === false) break\n\n      this.indexes[iterator] += 1\n    }\n\n    delete this.indexes[iterator]\n    return result\n  }\n\n  every(condition) {\n    return this.nodes.every(condition)\n  }\n\n  getIterator() {\n    if (!this.lastEach) this.lastEach = 0\n    if (!this.indexes) this.indexes = {}\n\n    this.lastEach += 1\n    let iterator = this.lastEach\n    this.indexes[iterator] = 0\n\n    return iterator\n  }\n\n  getProxyProcessor() {\n    return {\n      get(node, prop) {\n        if (prop === 'proxyOf') {\n          return node\n        } else if (!node[prop]) {\n          return node[prop]\n        } else if (\n          prop === 'each' ||\n          (typeof prop === 'string' && prop.startsWith('walk'))\n        ) {\n          return (...args) => {\n            return node[prop](\n              ...args.map(i => {\n                if (typeof i === 'function') {\n                  return (child, index) => i(child.toProxy(), index)\n                } else {\n                  return i\n                }\n              })\n            )\n          }\n        } else if (prop === 'every' || prop === 'some') {\n          return cb => {\n            return node[prop]((child, ...other) =>\n              cb(child.toProxy(), ...other)\n            )\n          }\n        } else if (prop === 'root') {\n          return () => node.root().toProxy()\n        } else if (prop === 'nodes') {\n          return node.nodes.map(i => i.toProxy())\n        } else if (prop === 'first' || prop === 'last') {\n          return node[prop].toProxy()\n        } else {\n          return node[prop]\n        }\n      },\n\n      set(node, prop, value) {\n        if (node[prop] === value) return true\n        node[prop] = value\n        if (prop === 'name' || prop === 'params' || prop === 'selector') {\n          node.markDirty()\n        }\n        return true\n      }\n    }\n  }\n\n  index(child) {\n    if (typeof child === 'number') return child\n    if (child.proxyOf) child = child.proxyOf\n    return this.proxyOf.nodes.indexOf(child)\n  }\n\n  insertAfter(exist, add) {\n    let existIndex = this.index(exist)\n    let nodes = this.normalize(add, this.proxyOf.nodes[existIndex]).reverse()\n    existIndex = this.index(exist)\n    for (let node of nodes) this.proxyOf.nodes.splice(existIndex + 1, 0, node)\n\n    let index\n    for (let id in this.indexes) {\n      index = this.indexes[id]\n      if (existIndex < index) {\n        this.indexes[id] = index + nodes.length\n      }\n    }\n\n    this.markDirty()\n\n    return this\n  }\n\n  insertBefore(exist, add) {\n    let existIndex = this.index(exist)\n    let type = existIndex === 0 ? 'prepend' : false\n    let nodes = this.normalize(\n      add,\n      this.proxyOf.nodes[existIndex],\n      type\n    ).reverse()\n    existIndex = this.index(exist)\n    for (let node of nodes) this.proxyOf.nodes.splice(existIndex, 0, node)\n\n    let index\n    for (let id in this.indexes) {\n      index = this.indexes[id]\n      if (existIndex <= index) {\n        this.indexes[id] = index + nodes.length\n      }\n    }\n\n    this.markDirty()\n\n    return this\n  }\n\n  normalize(nodes, sample) {\n    if (typeof nodes === 'string') {\n      nodes = cleanSource(parse(nodes).nodes)\n    } else if (typeof nodes === 'undefined') {\n      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 || nodes.selectors) {\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]) markTreeDirty(i)\n\n      if (!i.raws) i.raws = {}\n      if (typeof i.raws.before === 'undefined') {\n        if (sample && typeof sample.raws.before !== 'undefined') {\n          i.raws.before = sample.raws.before.replace(/\\S/g, '')\n        }\n      }\n      i.parent = this.proxyOf\n      return i\n    })\n\n    return processed\n  }\n\n  prepend(...children) {\n    children = children.reverse()\n    for (let child of children) {\n      let nodes = this.normalize(child, this.first, 'prepend').reverse()\n      for (let node of nodes) this.proxyOf.nodes.unshift(node)\n      for (let id in this.indexes) {\n        this.indexes[id] = this.indexes[id] + nodes.length\n      }\n    }\n\n    this.markDirty()\n\n    return this\n  }\n\n  push(child) {\n    child.parent = this\n    this.proxyOf.nodes.push(child)\n    return this\n  }\n\n  removeAll() {\n    for (let node of this.proxyOf.nodes) node.parent = undefined\n    this.proxyOf.nodes = []\n\n    this.markDirty()\n\n    return this\n  }\n\n  removeChild(child) {\n    child = this.index(child)\n    this.proxyOf.nodes[child].parent = undefined\n    this.proxyOf.nodes.splice(child, 1)\n\n    let index\n    for (let id in this.indexes) {\n      index = this.indexes[id]\n      if (index >= child) {\n        this.indexes[id] = index - 1\n      }\n    }\n\n    this.markDirty()\n\n    return this\n  }\n\n  replaceValues(pattern, opts, callback) {\n    if (!callback) {\n      callback = opts\n      opts = {}\n    }\n\n    this.walkDecls(decl => {\n      if (opts.props && !opts.props.includes(decl.prop)) return\n      if (opts.fast && !decl.value.includes(opts.fast)) return\n\n      decl.value = decl.value.replace(pattern, callback)\n    })\n\n    this.markDirty()\n\n    return this\n  }\n\n  some(condition) {\n    return this.nodes.some(condition)\n  }\n\n  walk(callback) {\n    return this.each((child, i) => {\n      let result\n      try {\n        result = callback(child, i)\n      } catch (e) {\n        throw child.addToError(e)\n      }\n      if (result !== false && child.walk) {\n        result = child.walk(callback)\n      }\n\n      return result\n    })\n  }\n\n  walkAtRules(name, callback) {\n    if (!callback) {\n      callback = name\n      return this.walk((child, i) => {\n        if (child.type === 'atrule') {\n          return callback(child, i)\n        }\n      })\n    }\n    if (name instanceof RegExp) {\n      return this.walk((child, i) => {\n        if (child.type === 'atrule' && name.test(child.name)) {\n          return callback(child, i)\n        }\n      })\n    }\n    return this.walk((child, i) => {\n      if (child.type === 'atrule' && child.name === name) {\n        return callback(child, i)\n      }\n    })\n  }\n\n  walkComments(callback) {\n    return this.walk((child, i) => {\n      if (child.type === 'comment') {\n        return callback(child, i)\n      }\n    })\n  }\n\n  walkDecls(prop, callback) {\n    if (!callback) {\n      callback = prop\n      return this.walk((child, i) => {\n        if (child.type === 'decl') {\n          return callback(child, i)\n        }\n      })\n    }\n    if (prop instanceof RegExp) {\n      return this.walk((child, i) => {\n        if (child.type === 'decl' && prop.test(child.prop)) {\n          return callback(child, i)\n        }\n      })\n    }\n    return this.walk((child, i) => {\n      if (child.type === 'decl' && child.prop === prop) {\n        return callback(child, i)\n      }\n    })\n  }\n\n  walkRules(selector, callback) {\n    if (!callback) {\n      callback = selector\n\n      return this.walk((child, i) => {\n        if (child.type === 'rule') {\n          return callback(child, i)\n        }\n      })\n    }\n    if (selector instanceof RegExp) {\n      return this.walk((child, i) => {\n        if (child.type === 'rule' && selector.test(child.selector)) {\n          return callback(child, i)\n        }\n      })\n    }\n    return this.walk((child, i) => {\n      if (child.type === 'rule' && child.selector === selector) {\n        return callback(child, i)\n      }\n    })\n  }\n\n  get first() {\n    if (!this.proxyOf.nodes) return undefined\n    return this.proxyOf.nodes[0]\n  }\n\n  get last() {\n    if (!this.proxyOf.nodes) return undefined\n    return this.proxyOf.nodes[this.proxyOf.nodes.length - 1]\n  }\n}\n\nContainer.registerParse = dependant => {\n  parse = dependant\n}\n\nContainer.registerRule = dependant => {\n  Rule = dependant\n}\n\nContainer.registerAtRule = dependant => {\n  AtRule = dependant\n}\n\nContainer.registerRoot = dependant => {\n  Root = dependant\n}\n\nmodule.exports = Container\nContainer.default = Container\n\n/* c8 ignore start */\nContainer.rebuild = node => {\n  if (node.type === 'atrule') {\n    Object.setPrototypeOf(node, AtRule.prototype)\n  } else if (node.type === 'rule') {\n    Object.setPrototypeOf(node, Rule.prototype)\n  } else if (node.type === 'decl') {\n    Object.setPrototypeOf(node, Declaration.prototype)\n  } else if (node.type === 'comment') {\n    Object.setPrototypeOf(node, Comment.prototype)\n  } else if (node.type === 'root') {\n    Object.setPrototypeOf(node, Root.prototype)\n  }\n\n  node[my] = true\n\n  if (node.nodes) {\n    node.nodes.forEach(child => {\n      Container.rebuild(child)\n    })\n  }\n}\n/* c8 ignore stop */\n","'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\n    let aside = text => text\n    let mark = text => text\n    let highlight = text => text\n    if (color) {\n      let { bold, gray, red } = pico.createColors(true)\n      mark = text => bold(red(text))\n      aside = text => gray(text)\n      if (terminalHighlight) {\n        highlight = text => terminalHighlight(text)\n      }\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    let maxWidth = String(end).length\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          if (line.length > 160) {\n            let padding = 20\n            let subLineStart = Math.max(0, this.column - padding)\n            let subLineEnd = Math.max(\n              this.column + padding,\n              this.endColumn + padding\n            )\n            let subLine = line.slice(subLineStart, subLineEnd)\n\n            let spacing =\n              aside(gutter.replace(/\\d/g, ' ')) +\n              line\n                .slice(0, Math.min(this.column - 1, padding - 1))\n                .replace(/[^\\t]/g, ' ')\n\n            return (\n              mark('>') +\n              aside(gutter) +\n              highlight(subLine) +\n              '\\n ' +\n              spacing +\n              mark('^')\n            )\n          }\n\n          let spacing =\n            aside(gutter.replace(/\\d/g, ' ')) +\n            line.slice(0, this.column - 1).replace(/[^\\t]/g, ' ')\n\n          return (\n            mark('>') +\n            aside(gutter) +\n            highlight(line) +\n            '\\n ' +\n            spacing +\n            mark('^')\n          )\n        }\n\n        return ' ' + aside(gutter) + highlight(line)\n      })\n      .join('\\n')\n  }\n\n  toString() {\n    let code = this.showSourceCode()\n    if (code) {\n      code = '\\n\\n' + code + '\\n'\n    }\n    return this.name + ': ' + this.message + code\n  }\n}\n\nmodule.exports = CssSyntaxError\nCssSyntaxError.default = CssSyntaxError\n","'use strict'\n\nlet 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","'use strict'\n\nlet AtRule = require('./at-rule')\nlet Comment = require('./comment')\nlet Declaration = require('./declaration')\nlet Input = require('./input')\nlet PreviousMap = require('./previous-map')\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 { nanoid } = require('nanoid/non-secure')\nlet { isAbsolute, resolve } = require('path')\nlet { SourceMapConsumer, SourceMapGenerator } = require('source-map-js')\nlet { fileURLToPath, pathToFileURL } = require('url')\n\nlet CssSyntaxError = require('./css-syntax-error')\nlet PreviousMap = require('./previous-map')\nlet terminalHighlight = require('./terminal-highlight')\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    this.document = this.css\n    if (opts.document) this.document = opts.document.toString()\n\n    if (opts.from) {\n      if (\n        !pathAvailable ||\n        /^\\w+:\\/\\//.test(opts.from) ||\n        isAbsolute(opts.from)\n      ) {\n        this.file = opts.from\n      } else {\n        this.file = resolve(opts.from)\n      }\n    }\n\n    if (pathAvailable && sourceMapAvailable) {\n      let map = new PreviousMap(this.css, opts)\n      if (map.text) {\n        this.map = map\n        let file = map.consumer().file\n        if (!this.file && file) this.file = this.mapResolve(file)\n      }\n    }\n\n    if (!this.file) {\n      this.id = '<input css ' + nanoid(6) + '>'\n    }\n    if (this.map) this.map.file = this.from\n  }\n\n  error(message, line, column, opts = {}) {\n    let endColumn, endLine, result\n\n    if (line && typeof line === 'object') {\n      let start = line\n      let end = column\n      if (typeof start.offset === 'number') {\n        let pos = this.fromOffset(start.offset)\n        line = pos.line\n        column = pos.col\n      } else {\n        line = start.line\n        column = start.column\n      }\n      if (typeof end.offset === 'number') {\n        let pos = this.fromOffset(end.offset)\n        endLine = pos.line\n        endColumn = pos.col\n      } else {\n        endLine = end.line\n        endColumn = end.column\n      }\n    } else if (!column) {\n      let pos = this.fromOffset(line)\n      line = pos.line\n      column = pos.col\n    }\n\n    let origin = this.origin(line, column, endLine, endColumn)\n    if (origin) {\n      result = new CssSyntaxError(\n        message,\n        origin.endLine === undefined\n          ? origin.line\n          : { column: origin.column, line: origin.line },\n        origin.endLine === undefined\n          ? origin.column\n          : { column: origin.endColumn, line: origin.endLine },\n        origin.source,\n        origin.file,\n        opts.plugin\n      )\n    } else {\n      result = new CssSyntaxError(\n        message,\n        endLine === undefined ? line : { column, line },\n        endLine === undefined ? column : { column: endColumn, line: endLine },\n        this.css,\n        this.file,\n        opts.plugin\n      )\n    }\n\n    result.input = { column, endColumn, endLine, line, source: this.css }\n    if (this.file) {\n      if (pathToFileURL) {\n        result.input.url = pathToFileURL(this.file).toString()\n      }\n      result.input.file = this.file\n    }\n\n    return result\n  }\n\n  fromOffset(offset) {\n    let lastLine, lineToIndex\n    if (!this[fromOffsetCache]) {\n      let lines = this.css.split('\\n')\n      lineToIndex = new Array(lines.length)\n      let prevIndex = 0\n\n      for (let i = 0, l = lines.length; i < l; i++) {\n        lineToIndex[i] = prevIndex\n        prevIndex += lines[i].length + 1\n      }\n\n      this[fromOffsetCache] = lineToIndex\n    } else {\n      lineToIndex = this[fromOffsetCache]\n    }\n    lastLine = lineToIndex[lineToIndex.length - 1]\n\n    let min = 0\n    if (offset >= lastLine) {\n      min = lineToIndex.length - 1\n    } else {\n      let max = lineToIndex.length - 2\n      let mid\n      while (min < max) {\n        mid = min + ((max - min) >> 1)\n        if (offset < lineToIndex[mid]) {\n          max = mid - 1\n        } else if (offset >= lineToIndex[mid + 1]) {\n          min = mid + 1\n        } else {\n          min = mid\n          break\n        }\n      }\n    }\n    return {\n      col: offset - lineToIndex[min] + 1,\n      line: min + 1\n    }\n  }\n\n  mapResolve(file) {\n    if (/^\\w+:\\/\\//.test(file)) {\n      return file\n    }\n    return resolve(this.map.consumer().sourceRoot || this.map.root || '.', file)\n  }\n\n  origin(line, column, endLine, endColumn) {\n    if (!this.map) return false\n    let consumer = this.map.consumer()\n\n    let from = consumer.originalPositionFor({ column, line })\n    if (!from.source) return false\n\n    let to\n    if (typeof endLine === 'number') {\n      to = consumer.originalPositionFor({ column: endColumn, line: endLine })\n    }\n\n    let fromUrl\n\n    if (isAbsolute(from.source)) {\n      fromUrl = pathToFileURL(from.source)\n    } else {\n      fromUrl = new URL(\n        from.source,\n        this.map.consumer().sourceRoot || pathToFileURL(this.map.mapFile)\n      )\n    }\n\n    let result = {\n      column: from.column,\n      endColumn: to && to.column,\n      endLine: to && to.line,\n      line: from.line,\n      url: fromUrl.toString()\n    }\n\n    if (fromUrl.protocol === 'file:') {\n      if (fileURLToPath) {\n        result.file = fileURLToPath(fromUrl)\n      } else {\n        /* c8 ignore next 2 */\n        throw new Error(`file: protocol is not available in this PostCSS build`)\n      }\n    }\n\n    let source = consumer.sourceContentFor(from.source)\n    if (source) result.source = source\n\n    return result\n  }\n\n  toJSON() {\n    let json = {}\n    for (let name of ['hasBOM', 'css', 'file', 'id']) {\n      if (this[name] != null) {\n        json[name] = this[name]\n      }\n    }\n    if (this.map) {\n      json.map = { ...this.map }\n      if (json.map.consumerCache) {\n        json.map.consumerCache = undefined\n      }\n    }\n    return json\n  }\n\n  get from() {\n    return this.file || this.id\n  }\n}\n\nmodule.exports = Input\nInput.default = Input\n\nif (terminalHighlight && terminalHighlight.registerInput) {\n  terminalHighlight.registerInput(Input)\n}\n","'use strict'\n\nlet Container = require('./container')\nlet Document = require('./document')\nlet MapGenerator = require('./map-generator')\nlet parse = require('./parse')\nlet Result = require('./result')\nlet Root = require('./root')\nlet stringify = require('./stringify')\nlet { isClean, my } = require('./symbols')\nlet warnOnce = require('./warn-once')\n\nconst TYPE_TO_CLASS_NAME = {\n  atrule: 'AtRule',\n  comment: 'Comment',\n  decl: 'Declaration',\n  document: 'Document',\n  root: 'Root',\n  rule: 'Rule'\n}\n\nconst PLUGIN_PROPS = {\n  AtRule: true,\n  AtRuleExit: true,\n  Comment: true,\n  CommentExit: true,\n  Declaration: true,\n  DeclarationExit: true,\n  Document: true,\n  DocumentExit: true,\n  Once: true,\n  OnceExit: true,\n  postcssPlugin: true,\n  prepare: true,\n  Root: true,\n  RootExit: true,\n  Rule: true,\n  RuleExit: true\n}\n\nconst NOT_VISITORS = {\n  Once: true,\n  postcssPlugin: true,\n  prepare: true\n}\n\nconst CHILDREN = 0\n\nfunction isPromise(obj) {\n  return typeof obj === 'object' && typeof obj.then === 'function'\n}\n\nfunction getEvents(node) {\n  let key = false\n  let type = TYPE_TO_CLASS_NAME[node.type]\n  if (node.type === 'decl') {\n    key = node.prop.toLowerCase()\n  } else if (node.type === 'atrule') {\n    key = node.name.toLowerCase()\n  }\n\n  if (key && node.append) {\n    return [\n      type,\n      type + '-' + key,\n      CHILDREN,\n      type + 'Exit',\n      type + 'Exit-' + key\n    ]\n  } else if (key) {\n    return [type, type + '-' + key, type + 'Exit', type + 'Exit-' + key]\n  } else if (node.append) {\n    return [type, CHILDREN, type + 'Exit']\n  } else {\n    return [type, type + 'Exit']\n  }\n}\n\nfunction toStack(node) {\n  let events\n  if (node.type === 'document') {\n    events = ['Document', CHILDREN, 'DocumentExit']\n  } else if (node.type === 'root') {\n    events = ['Root', CHILDREN, 'RootExit']\n  } else {\n    events = getEvents(node)\n  }\n\n  return {\n    eventIndex: 0,\n    events,\n    iterator: 0,\n    node,\n    visitorIndex: 0,\n    visitors: []\n  }\n}\n\nfunction cleanMarks(node) {\n  node[isClean] = false\n  if (node.nodes) node.nodes.forEach(i => cleanMarks(i))\n  return node\n}\n\nlet postcss = {}\n\nclass LazyResult {\n  constructor(processor, css, opts) {\n    this.stringified = false\n    this.processed = false\n\n    let root\n    if (\n      typeof css === 'object' &&\n      css !== null &&\n      (css.type === 'root' || css.type === 'document')\n    ) {\n      root = cleanMarks(css)\n    } else if (css instanceof LazyResult || css instanceof Result) {\n      root = cleanMarks(css.root)\n      if (css.map) {\n        if (typeof opts.map === 'undefined') opts.map = {}\n        if (!opts.map.inline) opts.map.inline = false\n        opts.map.prev = css.map\n      }\n    } else {\n      let parser = parse\n      if (opts.syntax) parser = opts.syntax.parse\n      if (opts.parser) parser = opts.parser\n      if (parser.parse) parser = parser.parse\n\n      try {\n        root = parser(css, opts)\n      } catch (error) {\n        this.processed = true\n        this.error = error\n      }\n\n      if (root && !root[my]) {\n        /* c8 ignore next 2 */\n        Container.rebuild(root)\n      }\n    }\n\n    this.result = new Result(processor, root, opts)\n    this.helpers = { ...postcss, postcss, result: this.result }\n    this.plugins = this.processor.plugins.map(plugin => {\n      if (typeof plugin === 'object' && plugin.prepare) {\n        return { ...plugin, ...plugin.prepare(this.result) }\n      } else {\n        return plugin\n      }\n    })\n  }\n\n  async() {\n    if (this.error) return Promise.reject(this.error)\n    if (this.processed) return Promise.resolve(this.result)\n    if (!this.processing) {\n      this.processing = this.runAsync()\n    }\n    return this.processing\n  }\n\n  catch(onRejected) {\n    return this.async().catch(onRejected)\n  }\n\n  finally(onFinally) {\n    return this.async().then(onFinally, onFinally)\n  }\n\n  getAsyncError() {\n    throw new Error('Use process(css).then(cb) to work with async plugins')\n  }\n\n  handleError(error, node) {\n    let plugin = this.result.lastPlugin\n    try {\n      if (node) node.addToError(error)\n      this.error = error\n      if (error.name === 'CssSyntaxError' && !error.plugin) {\n        error.plugin = plugin.postcssPlugin\n        error.setMessage()\n      } else if (plugin.postcssVersion) {\n        if (process.env.NODE_ENV !== 'production') {\n          let pluginName = plugin.postcssPlugin\n          let pluginVer = plugin.postcssVersion\n          let runtimeVer = this.result.processor.version\n          let a = pluginVer.split('.')\n          let b = runtimeVer.split('.')\n\n          if (a[0] !== b[0] || parseInt(a[1]) > parseInt(b[1])) {\n            // eslint-disable-next-line no-console\n            console.error(\n              'Unknown error from PostCSS plugin. Your current PostCSS ' +\n                'version is ' +\n                runtimeVer +\n                ', but ' +\n                pluginName +\n                ' uses ' +\n                pluginVer +\n                '. Perhaps this is the source of the error below.'\n            )\n          }\n        }\n      }\n    } catch (err) {\n      /* c8 ignore next 3 */\n      // eslint-disable-next-line no-console\n      if (console && console.error) console.error(err)\n    }\n    return error\n  }\n\n  prepareVisitors() {\n    this.listeners = {}\n    let add = (plugin, type, cb) => {\n      if (!this.listeners[type]) this.listeners[type] = []\n      this.listeners[type].push([plugin, cb])\n    }\n    for (let plugin of this.plugins) {\n      if (typeof plugin === 'object') {\n        for (let event in plugin) {\n          if (!PLUGIN_PROPS[event] && /^[A-Z]/.test(event)) {\n            throw new Error(\n              `Unknown event ${event} in ${plugin.postcssPlugin}. ` +\n                `Try to update PostCSS (${this.processor.version} now).`\n            )\n          }\n          if (!NOT_VISITORS[event]) {\n            if (typeof plugin[event] === 'object') {\n              for (let filter in plugin[event]) {\n                if (filter === '*') {\n                  add(plugin, event, plugin[event][filter])\n                } else {\n                  add(\n                    plugin,\n                    event + '-' + filter.toLowerCase(),\n                    plugin[event][filter]\n                  )\n                }\n              }\n            } else if (typeof plugin[event] === 'function') {\n              add(plugin, event, plugin[event])\n            }\n          }\n        }\n      }\n    }\n    this.hasListener = Object.keys(this.listeners).length > 0\n  }\n\n  async runAsync() {\n    this.plugin = 0\n    for (let i = 0; i < this.plugins.length; i++) {\n      let plugin = this.plugins[i]\n      let promise = this.runOnRoot(plugin)\n      if (isPromise(promise)) {\n        try {\n          await promise\n        } catch (error) {\n          throw this.handleError(error)\n        }\n      }\n    }\n\n    this.prepareVisitors()\n    if (this.hasListener) {\n      let root = this.result.root\n      while (!root[isClean]) {\n        root[isClean] = true\n        let stack = [toStack(root)]\n        while (stack.length > 0) {\n          let promise = this.visitTick(stack)\n          if (isPromise(promise)) {\n            try {\n              await promise\n            } catch (e) {\n              let node = stack[stack.length - 1].node\n              throw this.handleError(e, node)\n            }\n          }\n        }\n      }\n\n      if (this.listeners.OnceExit) {\n        for (let [plugin, visitor] of this.listeners.OnceExit) {\n          this.result.lastPlugin = plugin\n          try {\n            if (root.type === 'document') {\n              let roots = root.nodes.map(subRoot =>\n                visitor(subRoot, this.helpers)\n              )\n\n              await Promise.all(roots)\n            } else {\n              await visitor(root, this.helpers)\n            }\n          } catch (e) {\n            throw this.handleError(e)\n          }\n        }\n      }\n    }\n\n    this.processed = true\n    return this.stringify()\n  }\n\n  runOnRoot(plugin) {\n    this.result.lastPlugin = plugin\n    try {\n      if (typeof plugin === 'object' && plugin.Once) {\n        if (this.result.root.type === 'document') {\n          let roots = this.result.root.nodes.map(root =>\n            plugin.Once(root, this.helpers)\n          )\n\n          if (isPromise(roots[0])) {\n            return Promise.all(roots)\n          }\n\n          return roots\n        }\n\n        return plugin.Once(this.result.root, this.helpers)\n      } else if (typeof plugin === 'function') {\n        return plugin(this.result.root, this.result)\n      }\n    } catch (error) {\n      throw this.handleError(error)\n    }\n  }\n\n  stringify() {\n    if (this.error) throw this.error\n    if (this.stringified) return this.result\n    this.stringified = true\n\n    this.sync()\n\n    let opts = this.result.opts\n    let str = stringify\n    if (opts.syntax) str = opts.syntax.stringify\n    if (opts.stringifier) str = opts.stringifier\n    if (str.stringify) str = str.stringify\n\n    let map = new MapGenerator(str, this.result.root, this.result.opts)\n    let data = map.generate()\n    this.result.css = data[0]\n    this.result.map = data[1]\n\n    return this.result\n  }\n\n  sync() {\n    if (this.error) throw this.error\n    if (this.processed) return this.result\n    this.processed = true\n\n    if (this.processing) {\n      throw this.getAsyncError()\n    }\n\n    for (let plugin of this.plugins) {\n      let promise = this.runOnRoot(plugin)\n      if (isPromise(promise)) {\n        throw this.getAsyncError()\n      }\n    }\n\n    this.prepareVisitors()\n    if (this.hasListener) {\n      let root = this.result.root\n      while (!root[isClean]) {\n        root[isClean] = true\n        this.walkSync(root)\n      }\n      if (this.listeners.OnceExit) {\n        if (root.type === 'document') {\n          for (let subRoot of root.nodes) {\n            this.visitSync(this.listeners.OnceExit, subRoot)\n          }\n        } else {\n          this.visitSync(this.listeners.OnceExit, root)\n        }\n      }\n    }\n\n    return this.result\n  }\n\n  then(onFulfilled, onRejected) {\n    if (process.env.NODE_ENV !== 'production') {\n      if (!('from' in this.opts)) {\n        warnOnce(\n          'Without `from` option PostCSS could generate wrong source map ' +\n            'and will not find Browserslist config. Set it to CSS file path ' +\n            'or to `undefined` to prevent this warning.'\n        )\n      }\n    }\n    return this.async().then(onFulfilled, onRejected)\n  }\n\n  toString() {\n    return this.css\n  }\n\n  visitSync(visitors, node) {\n    for (let [plugin, visitor] of visitors) {\n      this.result.lastPlugin = plugin\n      let promise\n      try {\n        promise = visitor(node, this.helpers)\n      } catch (e) {\n        throw this.handleError(e, node.proxyOf)\n      }\n      if (node.type !== 'root' && node.type !== 'document' && !node.parent) {\n        return true\n      }\n      if (isPromise(promise)) {\n        throw this.getAsyncError()\n      }\n    }\n  }\n\n  visitTick(stack) {\n    let visit = stack[stack.length - 1]\n    let { node, visitors } = visit\n\n    if (node.type !== 'root' && node.type !== 'document' && !node.parent) {\n      stack.pop()\n      return\n    }\n\n    if (visitors.length > 0 && visit.visitorIndex < visitors.length) {\n      let [plugin, visitor] = visitors[visit.visitorIndex]\n      visit.visitorIndex += 1\n      if (visit.visitorIndex === visitors.length) {\n        visit.visitors = []\n        visit.visitorIndex = 0\n      }\n      this.result.lastPlugin = plugin\n      try {\n        return visitor(node.toProxy(), this.helpers)\n      } catch (e) {\n        throw this.handleError(e, node)\n      }\n    }\n\n    if (visit.iterator !== 0) {\n      let iterator = visit.iterator\n      let child\n      while ((child = node.nodes[node.indexes[iterator]])) {\n        node.indexes[iterator] += 1\n        if (!child[isClean]) {\n          child[isClean] = true\n          stack.push(toStack(child))\n          return\n        }\n      }\n      visit.iterator = 0\n      delete node.indexes[iterator]\n    }\n\n    let events = visit.events\n    while (visit.eventIndex < events.length) {\n      let event = events[visit.eventIndex]\n      visit.eventIndex += 1\n      if (event === CHILDREN) {\n        if (node.nodes && node.nodes.length) {\n          node[isClean] = true\n          visit.iterator = node.getIterator()\n        }\n        return\n      } else if (this.listeners[event]) {\n        visit.visitors = this.listeners[event]\n        return\n      }\n    }\n    stack.pop()\n  }\n\n  walkSync(node) {\n    node[isClean] = true\n    let events = getEvents(node)\n    for (let event of events) {\n      if (event === CHILDREN) {\n        if (node.nodes) {\n          node.each(child => {\n            if (!child[isClean]) this.walkSync(child)\n          })\n        }\n      } else {\n        let visitors = this.listeners[event]\n        if (visitors) {\n          if (this.visitSync(visitors, node.toProxy())) return\n        }\n      }\n    }\n  }\n\n  warnings() {\n    return this.sync().warnings()\n  }\n\n  get content() {\n    return this.stringify().content\n  }\n\n  get css() {\n    return this.stringify().css\n  }\n\n  get map() {\n    return this.stringify().map\n  }\n\n  get messages() {\n    return this.sync().messages\n  }\n\n  get opts() {\n    return this.result.opts\n  }\n\n  get processor() {\n    return this.result.processor\n  }\n\n  get root() {\n    return this.sync().root\n  }\n\n  get [Symbol.toStringTag]() {\n    return 'LazyResult'\n  }\n}\n\nLazyResult.registerPostcss = dependant => {\n  postcss = dependant\n}\n\nmodule.exports = LazyResult\nLazyResult.default = LazyResult\n\nRoot.registerLazyResult(LazyResult)\nDocument.registerLazyResult(LazyResult)\n","'use strict'\n\nlet list = {\n  comma(string) {\n    return list.split(string, [','], true)\n  },\n\n  space(string) {\n    let spaces = [' ', '\\n', '\\t']\n    return list.split(string, spaces)\n  },\n\n  split(string, separators, last) {\n    let array = []\n    let current = ''\n    let split = false\n\n    let func = 0\n    let inQuote = false\n    let prevQuote = ''\n    let escape = false\n\n    for (let letter of string) {\n      if (escape) {\n        escape = false\n      } else if (letter === '\\\\') {\n        escape = true\n      } else if (inQuote) {\n        if (letter === prevQuote) {\n          inQuote = false\n        }\n      } else if (letter === '\"' || letter === \"'\") {\n        inQuote = true\n        prevQuote = letter\n      } else if (letter === '(') {\n        func += 1\n      } else if (letter === ')') {\n        if (func > 0) func -= 1\n      } else if (func === 0) {\n        if (separators.includes(letter)) split = true\n      }\n\n      if (split) {\n        if (current !== '') array.push(current.trim())\n        current = ''\n        split = false\n      } else {\n        current += letter\n      }\n    }\n\n    if (last || current !== '') array.push(current.trim())\n    return array\n  }\n}\n\nmodule.exports = list\nlist.default = list\n","'use strict'\n\nlet { dirname, relative, resolve, sep } = require('path')\nlet { SourceMapConsumer, SourceMapGenerator } = require('source-map-js')\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.originalCSS = cssString\n    this.usesFileUrls = !this.mapOpts.from && this.mapOpts.absolute\n\n    this.memoizedFileURLs = new Map()\n    this.memoizedPaths = new Map()\n    this.memoizedURLs = new Map()\n  }\n\n  addAnnotation() {\n    let content\n\n    if (this.isInline()) {\n      content =\n        'data:application/json;base64,' + this.toBase64(this.map.toString())\n    } else if (typeof this.mapOpts.annotation === 'string') {\n      content = this.mapOpts.annotation\n    } else if (typeof this.mapOpts.annotation === 'function') {\n      content = this.mapOpts.annotation(this.opts.to, this.root)\n    } else {\n      content = this.outputFile() + '.map'\n    }\n    let eol = '\\n'\n    if (this.css.includes('\\r\\n')) eol = '\\r\\n'\n\n    this.css += eol + '/*# sourceMappingURL=' + content + ' */'\n  }\n\n  applyPrevMaps() {\n    for (let prev of this.previous()) {\n      let from = this.toUrl(this.path(prev.file))\n      let root = prev.root || dirname(prev.file)\n      let map\n\n      if (this.mapOpts.sourcesContent === false) {\n        map = new SourceMapConsumer(prev.text)\n        if (map.sourcesContent) {\n          map.sourcesContent = null\n        }\n      } else {\n        map = prev.consumer()\n      }\n\n      this.map.applySourceMap(map, from, this.toUrl(this.path(root)))\n    }\n  }\n\n  clearAnnotation() {\n    if (this.mapOpts.annotation === false) return\n\n    if (this.root) {\n      let node\n      for (let i = this.root.nodes.length - 1; i >= 0; i--) {\n        node = this.root.nodes[i]\n        if (node.type !== 'comment') continue\n        if (node.text.startsWith('# sourceMappingURL=')) {\n          this.root.removeChild(i)\n        }\n      }\n    } else if (this.css) {\n      this.css = this.css.replace(/\\n*\\/\\*#[\\S\\s]*?\\*\\/$/gm, '')\n    }\n  }\n\n  generate() {\n    this.clearAnnotation()\n    if (pathAvailable && sourceMapAvailable && this.isMap()) {\n      return this.generateMap()\n    } else {\n      let result = ''\n      this.stringify(this.root, i => {\n        result += i\n      })\n      return [result]\n    }\n  }\n\n  generateMap() {\n    if (this.root) {\n      this.generateString()\n    } else if (this.previous().length === 1) {\n      let prev = this.previous()[0].consumer()\n      prev.file = this.outputFile()\n      this.map = SourceMapGenerator.fromSourceMap(prev, {\n        ignoreInvalidMapping: true\n      })\n    } else {\n      this.map = new SourceMapGenerator({\n        file: this.outputFile(),\n        ignoreInvalidMapping: true\n      })\n      this.map.addMapping({\n        generated: { column: 0, line: 1 },\n        original: { column: 0, line: 1 },\n        source: this.opts.from\n          ? this.toUrl(this.path(this.opts.from))\n          : '<no source>'\n      })\n    }\n\n    if (this.isSourcesContent()) this.setSourcesContent()\n    if (this.root && this.previous().length > 0) this.applyPrevMaps()\n    if (this.isAnnotation()) this.addAnnotation()\n\n    if (this.isInline()) {\n      return [this.css]\n    } else {\n      return [this.css, this.map]\n    }\n  }\n\n  generateString() {\n    this.css = ''\n    this.map = new SourceMapGenerator({\n      file: this.outputFile(),\n      ignoreInvalidMapping: true\n    })\n\n    let line = 1\n    let column = 1\n\n    let noSource = '<no source>'\n    let mapping = {\n      generated: { column: 0, line: 0 },\n      original: { column: 0, line: 0 },\n      source: ''\n    }\n\n    let last, lines\n    this.stringify(this.root, (str, node, type) => {\n      this.css += str\n\n      if (node && type !== 'end') {\n        mapping.generated.line = line\n        mapping.generated.column = column - 1\n        if (node.source && node.source.start) {\n          mapping.source = this.sourcePath(node)\n          mapping.original.line = node.source.start.line\n          mapping.original.column = node.source.start.column - 1\n          this.map.addMapping(mapping)\n        } else {\n          mapping.source = noSource\n          mapping.original.line = 1\n          mapping.original.column = 0\n          this.map.addMapping(mapping)\n        }\n      }\n\n      lines = str.match(/\\n/g)\n      if (lines) {\n        line += lines.length\n        last = str.lastIndexOf('\\n')\n        column = str.length - last\n      } else {\n        column += str.length\n      }\n\n      if (node && type !== 'start') {\n        let p = node.parent || { raws: {} }\n        let childless =\n          node.type === 'decl' || (node.type === 'atrule' && !node.nodes)\n        if (!childless || node !== p.last || p.raws.semicolon) {\n          if (node.source && node.source.end) {\n            mapping.source = this.sourcePath(node)\n            mapping.original.line = node.source.end.line\n            mapping.original.column = node.source.end.column - 1\n            mapping.generated.line = line\n            mapping.generated.column = column - 2\n            this.map.addMapping(mapping)\n          } else {\n            mapping.source = noSource\n            mapping.original.line = 1\n            mapping.original.column = 0\n            mapping.generated.line = line\n            mapping.generated.column = column - 1\n            this.map.addMapping(mapping)\n          }\n        }\n      }\n    })\n  }\n\n  isAnnotation() {\n    if (this.isInline()) {\n      return true\n    }\n    if (typeof this.mapOpts.annotation !== 'undefined') {\n      return this.mapOpts.annotation\n    }\n    if (this.previous().length) {\n      return this.previous().some(i => i.annotation)\n    }\n    return true\n  }\n\n  isInline() {\n    if (typeof this.mapOpts.inline !== 'undefined') {\n      return this.mapOpts.inline\n    }\n\n    let annotation = this.mapOpts.annotation\n    if (typeof annotation !== 'undefined' && annotation !== true) {\n      return false\n    }\n\n    if (this.previous().length) {\n      return this.previous().some(i => i.inline)\n    }\n    return true\n  }\n\n  isMap() {\n    if (typeof this.opts.map !== 'undefined') {\n      return !!this.opts.map\n    }\n    return this.previous().length > 0\n  }\n\n  isSourcesContent() {\n    if (typeof this.mapOpts.sourcesContent !== 'undefined') {\n      return this.mapOpts.sourcesContent\n    }\n    if (this.previous().length) {\n      return this.previous().some(i => i.withContent())\n    }\n    return true\n  }\n\n  outputFile() {\n    if (this.opts.to) {\n      return this.path(this.opts.to)\n    } else if (this.opts.from) {\n      return this.path(this.opts.from)\n    } else {\n      return 'to.css'\n    }\n  }\n\n  path(file) {\n    if (this.mapOpts.absolute) return file\n    if (file.charCodeAt(0) === 60 /* `<` */) return file\n    if (/^\\w+:\\/\\//.test(file)) return file\n    let cached = this.memoizedPaths.get(file)\n    if (cached) return cached\n\n    let from = this.opts.to ? dirname(this.opts.to) : '.'\n\n    if (typeof this.mapOpts.annotation === 'string') {\n      from = dirname(resolve(from, this.mapOpts.annotation))\n    }\n\n    let path = relative(from, file)\n    this.memoizedPaths.set(file, path)\n\n    return path\n  }\n\n  previous() {\n    if (!this.previousMaps) {\n      this.previousMaps = []\n      if (this.root) {\n        this.root.walk(node => {\n          if (node.source && node.source.input.map) {\n            let map = node.source.input.map\n            if (!this.previousMaps.includes(map)) {\n              this.previousMaps.push(map)\n            }\n          }\n        })\n      } else {\n        let input = new Input(this.originalCSS, this.opts)\n        if (input.map) this.previousMaps.push(input.map)\n      }\n    }\n\n    return this.previousMaps\n  }\n\n  setSourcesContent() {\n    let already = {}\n    if (this.root) {\n      this.root.walk(node => {\n        if (node.source) {\n          let from = node.source.input.from\n          if (from && !already[from]) {\n            already[from] = true\n            let fromUrl = this.usesFileUrls\n              ? this.toFileUrl(from)\n              : this.toUrl(this.path(from))\n            this.map.setSourceContent(fromUrl, node.source.input.css)\n          }\n        }\n      })\n    } else if (this.css) {\n      let from = this.opts.from\n        ? this.toUrl(this.path(this.opts.from))\n        : '<no source>'\n      this.map.setSourceContent(from, this.css)\n    }\n  }\n\n  sourcePath(node) {\n    if (this.mapOpts.from) {\n      return this.toUrl(this.mapOpts.from)\n    } else if (this.usesFileUrls) {\n      return this.toFileUrl(node.source.input.from)\n    } else {\n      return this.toUrl(this.path(node.source.input.from))\n    }\n  }\n\n  toBase64(str) {\n    if (Buffer) {\n      return Buffer.from(str).toString('base64')\n    } else {\n      return window.btoa(unescape(encodeURIComponent(str)))\n    }\n  }\n\n  toFileUrl(path) {\n    let cached = this.memoizedFileURLs.get(path)\n    if (cached) return cached\n\n    if (pathToFileURL) {\n      let fileURL = pathToFileURL(path).toString()\n      this.memoizedFileURLs.set(path, fileURL)\n\n      return fileURL\n    } else {\n      throw new Error(\n        '`map.absolute` option is not available in this PostCSS build'\n      )\n    }\n  }\n\n  toUrl(path) {\n    let cached = this.memoizedURLs.get(path)\n    if (cached) return cached\n\n    if (sep === '\\\\') {\n      path = path.replace(/\\\\/g, '/')\n    }\n\n    let url = encodeURI(path).replace(/[#?]/g, encodeURIComponent)\n    this.memoizedURLs.set(path, url)\n\n    return url\n  }\n}\n\nmodule.exports = MapGenerator\n","'use strict'\n\nlet MapGenerator = require('./map-generator')\nlet parse = require('./parse')\nconst Result = require('./result')\nlet stringify = require('./stringify')\nlet warnOnce = require('./warn-once')\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    } else {\n      map.clearAnnotation()\n      this.result.css = map.css\n    }\n  }\n\n  async() {\n    if (this.error) return Promise.reject(this.error)\n    return Promise.resolve(this.result)\n  }\n\n  catch(onRejected) {\n    return this.async().catch(onRejected)\n  }\n\n  finally(onFinally) {\n    return this.async().then(onFinally, onFinally)\n  }\n\n  sync() {\n    if (this.error) throw this.error\n    return this.result\n  }\n\n  then(onFulfilled, onRejected) {\n    if (process.env.NODE_ENV !== 'production') {\n      if (!('from' in this._opts)) {\n        warnOnce(\n          'Without `from` option PostCSS could generate wrong source map ' +\n            'and will not find Browserslist config. Set it to CSS file path ' +\n            'or to `undefined` to prevent this warning.'\n        )\n      }\n    }\n\n    return this.async().then(onFulfilled, onRejected)\n  }\n\n  toString() {\n    return this._css\n  }\n\n  warnings() {\n    return []\n  }\n\n  get content() {\n    return this.result.css\n  }\n\n  get css() {\n    return this.result.css\n  }\n\n  get map() {\n    return this.result.map\n  }\n\n  get messages() {\n    return []\n  }\n\n  get opts() {\n    return this.result.opts\n  }\n\n  get processor() {\n    return this.result.processor\n  }\n\n  get root() {\n    if (this._root) {\n      return this._root\n    }\n\n    let root\n    let parser = parse\n\n    try {\n      root = parser(this._css, this._opts)\n    } catch (error) {\n      this.error = error\n    }\n\n    if (this.error) {\n      throw this.error\n    } else {\n      this._root = root\n      return root\n    }\n  }\n\n  get [Symbol.toStringTag]() {\n    return 'NoWorkResult'\n  }\n}\n\nmodule.exports = NoWorkResult\nNoWorkResult.default = NoWorkResult\n","'use strict'\n\nlet CssSyntaxError = require('./css-syntax-error')\nlet Stringifier = require('./stringifier')\nlet stringify = require('./stringify')\nlet { isClean, my } = require('./symbols')\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\nfunction sourceOffset(inputCSS, position) {\n  // Not all custom syntaxes support `offset` in `source.start` and `source.end`\n  if (\n    position &&\n    typeof position.offset !== 'undefined'\n  ) {\n    return position.offset;\n  }\n\n  let column = 1\n  let line = 1\n  let offset = 0\n\n  for (let i = 0; i < inputCSS.length; i++) {\n    if (line === position.line && column === position.column) {\n      offset = i\n      break\n    }\n\n    if (inputCSS[i] === '\\n') {\n      column = 1\n      line += 1\n    } else {\n      column += 1\n    }\n  }\n\n  return offset\n}\n\nclass Node {\n  constructor(defaults = {}) {\n    this.raws = {}\n    this[isClean] = false\n    this[my] = true\n\n    for (let name in defaults) {\n      if (name === 'nodes') {\n        this.nodes = []\n        for (let node of defaults[name]) {\n          if (typeof node.clone === 'function') {\n            this.append(node.clone())\n          } else {\n            this.append(node)\n          }\n        }\n      } else {\n        this[name] = defaults[name]\n      }\n    }\n  }\n\n  addToError(error) {\n    error.postcssNode = this\n    if (error.stack && this.source && /\\n\\s{4}at /.test(error.stack)) {\n      let s = this.source\n      error.stack = error.stack.replace(\n        /\\n\\s{4}at /,\n        `$&${s.input.from}:${s.start.line}:${s.start.column}$&`\n      )\n    }\n    return error\n  }\n\n  after(add) {\n    this.parent.insertAfter(this, add)\n    return this\n  }\n\n  assign(overrides = {}) {\n    for (let name in overrides) {\n      this[name] = overrides[name]\n    }\n    return this\n  }\n\n  before(add) {\n    this.parent.insertBefore(this, add)\n    return this\n  }\n\n  cleanRaws(keepBetween) {\n    delete this.raws.before\n    delete this.raws.after\n    if (!keepBetween) delete this.raws.between\n  }\n\n  clone(overrides = {}) {\n    let cloned = cloneNode(this)\n    for (let name in overrides) {\n      cloned[name] = overrides[name]\n    }\n    return cloned\n  }\n\n  cloneAfter(overrides = {}) {\n    let cloned = this.clone(overrides)\n    this.parent.insertAfter(this, cloned)\n    return cloned\n  }\n\n  cloneBefore(overrides = {}) {\n    let cloned = this.clone(overrides)\n    this.parent.insertBefore(this, cloned)\n    return cloned\n  }\n\n  error(message, opts = {}) {\n    if (this.source) {\n      let { end, start } = this.rangeBy(opts)\n      return this.source.input.error(\n        message,\n        { column: start.column, line: start.line },\n        { column: end.column, line: end.line },\n        opts\n      )\n    }\n    return new CssSyntaxError(message)\n  }\n\n  getProxyProcessor() {\n    return {\n      get(node, prop) {\n        if (prop === 'proxyOf') {\n          return node\n        } else if (prop === 'root') {\n          return () => node.root().toProxy()\n        } else {\n          return node[prop]\n        }\n      },\n\n      set(node, prop, value) {\n        if (node[prop] === value) return true\n        node[prop] = value\n        if (\n          prop === 'prop' ||\n          prop === 'value' ||\n          prop === 'name' ||\n          prop === 'params' ||\n          prop === 'important' ||\n          /* c8 ignore next */\n          prop === 'text'\n        ) {\n          node.markDirty()\n        }\n        return true\n      }\n    }\n  }\n\n  /* c8 ignore next 3 */\n  markClean() {\n    this[isClean] = true\n  }\n\n  markDirty() {\n    if (this[isClean]) {\n      this[isClean] = false\n      let next = this\n      while ((next = next.parent)) {\n        next[isClean] = false\n      }\n    }\n  }\n\n  next() {\n    if (!this.parent) return undefined\n    let index = this.parent.index(this)\n    return this.parent.nodes[index + 1]\n  }\n\n  positionBy(opts) {\n    let pos = this.source.start\n    if (opts.index) {\n      pos = this.positionInside(opts.index)\n    } else if (opts.word) {\n      let inputString = ('document' in this.source.input)\n        ? this.source.input.document\n        : this.source.input.css\n      let stringRepresentation = inputString.slice(\n        sourceOffset(inputString, this.source.start),\n        sourceOffset(inputString, this.source.end)\n      )\n      let index = stringRepresentation.indexOf(opts.word)\n      if (index !== -1) pos = this.positionInside(index)\n    }\n    return pos\n  }\n\n  positionInside(index) {\n    let column = this.source.start.column\n    let line = this.source.start.line\n    let inputString = ('document' in this.source.input)\n      ? this.source.input.document\n      : this.source.input.css\n    let offset = sourceOffset(inputString, this.source.start)\n    let end = offset + index\n\n    for (let i = offset; i < end; i++) {\n      if (inputString[i] === '\\n') {\n        column = 1\n        line += 1\n      } else {\n        column += 1\n      }\n    }\n\n    return { column, line }\n  }\n\n  prev() {\n    if (!this.parent) return undefined\n    let index = this.parent.index(this)\n    return this.parent.nodes[index - 1]\n  }\n\n  rangeBy(opts) {\n    let start = {\n      column: this.source.start.column,\n      line: this.source.start.line\n    }\n    let end = this.source.end\n      ? {\n          column: this.source.end.column + 1,\n          line: this.source.end.line\n        }\n      : {\n          column: start.column + 1,\n          line: start.line\n        }\n\n    if (opts.word) {\n      let inputString = ('document' in this.source.input)\n        ? this.source.input.document\n        : this.source.input.css\n      let stringRepresentation = inputString.slice(\n        sourceOffset(inputString, this.source.start),\n        sourceOffset(inputString, this.source.end)\n      )\n      let index = stringRepresentation.indexOf(opts.word)\n      if (index !== -1) {\n        start = this.positionInside(index)\n        end = this.positionInside(\n          index + opts.word.length,\n        )\n      }\n    } else {\n      if (opts.start) {\n        start = {\n          column: opts.start.column,\n          line: opts.start.line\n        }\n      } else if (opts.index) {\n        start = this.positionInside(opts.index)\n      }\n\n      if (opts.end) {\n        end = {\n          column: opts.end.column,\n          line: opts.end.line\n        }\n      } else if (typeof opts.endIndex === 'number') {\n        end = this.positionInside(opts.endIndex)\n      } else if (opts.index) {\n        end = this.positionInside(opts.index + 1)\n      }\n    }\n\n    if (\n      end.line < start.line ||\n      (end.line === start.line && end.column <= start.column)\n    ) {\n      end = { column: start.column + 1, line: start.line }\n    }\n\n    return { end, start }\n  }\n\n  raw(prop, defaultType) {\n    let str = new Stringifier()\n    return str.raw(this, prop, defaultType)\n  }\n\n  remove() {\n    if (this.parent) {\n      this.parent.removeChild(this)\n    }\n    this.parent = undefined\n    return this\n  }\n\n  replaceWith(...nodes) {\n    if (this.parent) {\n      let bookmark = this\n      let foundSelf = false\n      for (let node of nodes) {\n        if (node === this) {\n          foundSelf = true\n        } else if (foundSelf) {\n          this.parent.insertAfter(bookmark, node)\n          bookmark = node\n        } else {\n          this.parent.insertBefore(bookmark, node)\n        }\n      }\n\n      if (!foundSelf) {\n        this.remove()\n      }\n    }\n\n    return this\n  }\n\n  root() {\n    let result = this\n    while (result.parent && result.parent.type !== 'document') {\n      result = result.parent\n    }\n    return result\n  }\n\n  toJSON(_, inputs) {\n    let fixed = {}\n    let emitInputs = inputs == null\n    inputs = inputs || new Map()\n    let inputsNextIndex = 0\n\n    for (let name in this) {\n      if (!Object.prototype.hasOwnProperty.call(this, name)) {\n        /* c8 ignore next 2 */\n        continue\n      }\n      if (name === 'parent' || name === 'proxyCache') continue\n      let value = this[name]\n\n      if (Array.isArray(value)) {\n        fixed[name] = value.map(i => {\n          if (typeof i === 'object' && i.toJSON) {\n            return i.toJSON(null, inputs)\n          } else {\n            return i\n          }\n        })\n      } else if (typeof value === 'object' && value.toJSON) {\n        fixed[name] = value.toJSON(null, inputs)\n      } else if (name === 'source') {\n        let inputId = inputs.get(value.input)\n        if (inputId == null) {\n          inputId = inputsNextIndex\n          inputs.set(value.input, inputsNextIndex)\n          inputsNextIndex++\n        }\n        fixed[name] = {\n          end: value.end,\n          inputId,\n          start: value.start\n        }\n      } else {\n        fixed[name] = value\n      }\n    }\n\n    if (emitInputs) {\n      fixed.inputs = [...inputs.keys()].map(input => input.toJSON())\n    }\n\n    return fixed\n  }\n\n  toProxy() {\n    if (!this.proxyCache) {\n      this.proxyCache = new Proxy(this, this.getProxyProcessor())\n    }\n    return this.proxyCache\n  }\n\n  toString(stringifier = stringify) {\n    if (stringifier.stringify) stringifier = stringifier.stringify\n    let result = ''\n    stringifier(this, i => {\n      result += i\n    })\n    return result\n  }\n\n  warn(result, text, opts) {\n    let data = { node: this }\n    for (let i in opts) data[i] = opts[i]\n    return result.warn(text, data)\n  }\n\n  get proxyOf() {\n    return this\n  }\n}\n\nmodule.exports = Node\nNode.default = Node\n","'use strict'\n\nlet Container = require('./container')\nlet Input = require('./input')\nlet Parser = require('./parser')\n\nfunction parse(css, opts) {\n  let input = new Input(css, opts)\n  let parser = new Parser(input)\n  try {\n    parser.parse()\n  } catch (e) {\n    if (process.env.NODE_ENV !== 'production') {\n      if (e.name === 'CssSyntaxError' && opts && opts.from) {\n        if (/\\.scss$/i.test(opts.from)) {\n          e.message +=\n            '\\nYou tried to parse SCSS with ' +\n            'the standard CSS parser; ' +\n            'try again with the postcss-scss parser'\n        } else if (/\\.sass/i.test(opts.from)) {\n          e.message +=\n            '\\nYou tried to parse Sass with ' +\n            'the standard CSS parser; ' +\n            'try again with the postcss-sass parser'\n        } else if (/\\.less$/i.test(opts.from)) {\n          e.message +=\n            '\\nYou tried to parse Less with ' +\n            'the standard CSS parser; ' +\n            'try again with the postcss-less parser'\n        }\n      }\n    }\n    throw e\n  }\n\n  return parser.root\n}\n\nmodule.exports = parse\nparse.default = parse\n\nContainer.registerParse(parse)\n","'use strict'\n\nlet AtRule = require('./at-rule')\nlet Comment = require('./comment')\nlet Declaration = require('./declaration')\nlet Root = require('./root')\nlet Rule = require('./rule')\nlet tokenizer = require('./tokenize')\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\n    this.createTokenizer()\n    this.root.source = { input, start: { column: 1, line: 1, offset: 0 } }\n  }\n\n  atrule(token) {\n    let node = new AtRule()\n    node.name = token[1].slice(1)\n    if (node.name === '') {\n      this.unnamedAtrule(node, token)\n    }\n    this.init(node, token[2])\n\n    let type\n    let prev\n    let shift\n    let last = false\n    let open = false\n    let params = []\n    let brackets = []\n\n    while (!this.tokenizer.endOfFile()) {\n      token = this.tokenizer.nextToken()\n      type = token[0]\n\n      if (type === '(' || type === '[') {\n        brackets.push(type === '(' ? ')' : ']')\n      } else if (type === '{' && brackets.length > 0) {\n        brackets.push('}')\n      } else if (type === brackets[brackets.length - 1]) {\n        brackets.pop()\n      }\n\n      if (brackets.length === 0) {\n        if (type === ';') {\n          node.source.end = this.getPosition(token[2])\n          node.source.end.offset++\n          this.semicolon = true\n          break\n        } else if (type === '{') {\n          open = true\n          break\n        } else if (type === '}') {\n          if (params.length > 0) {\n            shift = params.length - 1\n            prev = params[shift]\n            while (prev && prev[0] === 'space') {\n              prev = params[--shift]\n            }\n            if (prev) {\n              node.source.end = this.getPosition(prev[3] || prev[2])\n              node.source.end.offset++\n            }\n          }\n          this.end(token)\n          break\n        } else {\n          params.push(token)\n        }\n      } else {\n        params.push(token)\n      }\n\n      if (this.tokenizer.endOfFile()) {\n        last = true\n        break\n      }\n    }\n\n    node.raws.between = this.spacesAndCommentsFromEnd(params)\n    if (params.length) {\n      node.raws.afterName = this.spacesAndCommentsFromStart(params)\n      this.raw(node, 'params', params)\n      if (last) {\n        token = params[params.length - 1]\n        node.source.end = this.getPosition(token[3] || token[2])\n        node.source.end.offset++\n        this.spaces = node.raws.between\n        node.raws.between = ''\n      }\n    } else {\n      node.raws.afterName = ''\n      node.params = ''\n    }\n\n    if (open) {\n      node.nodes = []\n      this.current = node\n    }\n  }\n\n  checkMissedSemicolon(tokens) {\n    let colon = this.colon(tokens)\n    if (colon === false) return\n\n    let founded = 0\n    let token\n    for (let j = colon - 1; j >= 0; j--) {\n      token = tokens[j]\n      if (token[0] !== 'space') {\n        founded += 1\n        if (founded === 2) break\n      }\n    }\n    // If the token is a word, e.g. `!important`, `red` or any other valid property's value.\n    // Then we need to return the colon after that word token. [3] is the \"end\" colon of that word.\n    // And because we need it after that one we do +1 to get the next one.\n    throw this.input.error(\n      'Missed semicolon',\n      token[0] === 'word' ? token[3] + 1 : token[2]\n    )\n  }\n\n  colon(tokens) {\n    let brackets = 0\n    let prev, token, type\n    for (let [i, element] of tokens.entries()) {\n      token = element\n      type = token[0]\n\n      if (type === '(') {\n        brackets += 1\n      }\n      if (type === ')') {\n        brackets -= 1\n      }\n      if (brackets === 0 && type === ':') {\n        if (!prev) {\n          this.doubleColon(token)\n        } else if (prev[0] === 'word' && prev[1] === 'progid') {\n          continue\n        } else {\n          return i\n        }\n      }\n\n      prev = token\n    }\n    return false\n  }\n\n  comment(token) {\n    let node = new Comment()\n    this.init(node, token[2])\n    node.source.end = this.getPosition(token[3] || token[2])\n    node.source.end.offset++\n\n    let text = token[1].slice(2, -2)\n    if (/^\\s*$/.test(text)) {\n      node.text = ''\n      node.raws.left = text\n      node.raws.right = ''\n    } else {\n      let match = text.match(/^(\\s*)([^]*\\S)(\\s*)$/)\n      node.text = match[2]\n      node.raws.left = match[1]\n      node.raws.right = match[3]\n    }\n  }\n\n  createTokenizer() {\n    this.tokenizer = tokenizer(this.input)\n  }\n\n  decl(tokens, customProperty) {\n    let node = new Declaration()\n    this.init(node, tokens[0][2])\n\n    let last = tokens[tokens.length - 1]\n    if (last[0] === ';') {\n      this.semicolon = true\n      tokens.pop()\n    }\n\n    node.source.end = this.getPosition(\n      last[3] || last[2] || findLastWithPosition(tokens)\n    )\n    node.source.end.offset++\n\n    while (tokens[0][0] !== 'word') {\n      if (tokens.length === 1) this.unknownWord(tokens)\n      node.raws.before += tokens.shift()[1]\n    }\n    node.source.start = this.getPosition(tokens[0][2])\n\n    node.prop = ''\n    while (tokens.length) {\n      let type = tokens[0][0]\n      if (type === ':' || type === 'space' || type === 'comment') {\n        break\n      }\n      node.prop += tokens.shift()[1]\n    }\n\n    node.raws.between = ''\n\n    let token\n    while (tokens.length) {\n      token = tokens.shift()\n\n      if (token[0] === ':') {\n        node.raws.between += token[1]\n        break\n      } else {\n        if (token[0] === 'word' && /\\w/.test(token[1])) {\n          this.unknownWord([token])\n        }\n        node.raws.between += token[1]\n      }\n    }\n\n    if (node.prop[0] === '_' || node.prop[0] === '*') {\n      node.raws.before += node.prop[0]\n      node.prop = node.prop.slice(1)\n    }\n\n    let firstSpaces = []\n    let next\n    while (tokens.length) {\n      next = tokens[0][0]\n      if (next !== 'space' && next !== 'comment') break\n      firstSpaces.push(tokens.shift())\n    }\n\n    this.precheckMissedSemicolon(tokens)\n\n    for (let i = tokens.length - 1; i >= 0; i--) {\n      token = tokens[i]\n      if (token[1].toLowerCase() === '!important') {\n        node.important = true\n        let string = this.stringFrom(tokens, i)\n        string = this.spacesFromEnd(tokens) + string\n        if (string !== ' !important') node.raws.important = string\n        break\n      } else if (token[1].toLowerCase() === 'important') {\n        let cache = tokens.slice(0)\n        let str = ''\n        for (let j = i; j > 0; j--) {\n          let type = cache[j][0]\n          if (str.trim().startsWith('!') && type !== 'space') {\n            break\n          }\n          str = cache.pop()[1] + str\n        }\n        if (str.trim().startsWith('!')) {\n          node.important = true\n          node.raws.important = str\n          tokens = cache\n        }\n      }\n\n      if (token[0] !== 'space' && token[0] !== 'comment') {\n        break\n      }\n    }\n\n    let hasWord = tokens.some(i => i[0] !== 'space' && i[0] !== 'comment')\n\n    if (hasWord) {\n      node.raws.between += firstSpaces.map(i => i[1]).join('')\n      firstSpaces = []\n    }\n    this.raw(node, 'value', firstSpaces.concat(tokens), customProperty)\n\n    if (node.value.includes(':') && !customProperty) {\n      this.checkMissedSemicolon(tokens)\n    }\n  }\n\n  doubleColon(token) {\n    throw this.input.error(\n      'Double colon',\n      { offset: token[2] },\n      { offset: token[2] + token[1].length }\n    )\n  }\n\n  emptyRule(token) {\n    let node = new Rule()\n    this.init(node, token[2])\n    node.selector = ''\n    node.raws.between = ''\n    this.current = node\n  }\n\n  end(token) {\n    if (this.current.nodes && this.current.nodes.length) {\n      this.current.raws.semicolon = this.semicolon\n    }\n    this.semicolon = false\n\n    this.current.raws.after = (this.current.raws.after || '') + this.spaces\n    this.spaces = ''\n\n    if (this.current.parent) {\n      this.current.source.end = this.getPosition(token[2])\n      this.current.source.end.offset++\n      this.current = this.current.parent\n    } else {\n      this.unexpectedClose(token)\n    }\n  }\n\n  endFile() {\n    if (this.current.parent) this.unclosedBlock()\n    if (this.current.nodes && this.current.nodes.length) {\n      this.current.raws.semicolon = this.semicolon\n    }\n    this.current.raws.after = (this.current.raws.after || '') + this.spaces\n    this.root.source.end = this.getPosition(this.tokenizer.position())\n  }\n\n  freeSemicolon(token) {\n    this.spaces += token[1]\n    if (this.current.nodes) {\n      let prev = this.current.nodes[this.current.nodes.length - 1]\n      if (prev && prev.type === 'rule' && !prev.raws.ownSemicolon) {\n        prev.raws.ownSemicolon = this.spaces\n        this.spaces = ''\n      }\n    }\n  }\n\n  // Helpers\n\n  getPosition(offset) {\n    let pos = this.input.fromOffset(offset)\n    return {\n      column: pos.col,\n      line: pos.line,\n      offset\n    }\n  }\n\n  init(node, offset) {\n    this.current.push(node)\n    node.source = {\n      input: this.input,\n      start: this.getPosition(offset)\n    }\n    node.raws.before = this.spaces\n    this.spaces = ''\n    if (node.type !== 'comment') this.semicolon = false\n  }\n\n  other(start) {\n    let end = false\n    let type = null\n    let colon = false\n    let bracket = null\n    let brackets = []\n    let customProperty = start[1].startsWith('--')\n\n    let tokens = []\n    let token = start\n    while (token) {\n      type = token[0]\n      tokens.push(token)\n\n      if (type === '(' || type === '[') {\n        if (!bracket) bracket = token\n        brackets.push(type === '(' ? ')' : ']')\n      } else if (customProperty && colon && type === '{') {\n        if (!bracket) bracket = token\n        brackets.push('}')\n      } else if (brackets.length === 0) {\n        if (type === ';') {\n          if (colon) {\n            this.decl(tokens, customProperty)\n            return\n          } else {\n            break\n          }\n        } else if (type === '{') {\n          this.rule(tokens)\n          return\n        } else if (type === '}') {\n          this.tokenizer.back(tokens.pop())\n          end = true\n          break\n        } else if (type === ':') {\n          colon = true\n        }\n      } else if (type === brackets[brackets.length - 1]) {\n        brackets.pop()\n        if (brackets.length === 0) bracket = null\n      }\n\n      token = this.tokenizer.nextToken()\n    }\n\n    if (this.tokenizer.endOfFile()) end = true\n    if (brackets.length > 0) this.unclosedBracket(bracket)\n\n    if (end && colon) {\n      if (!customProperty) {\n        while (tokens.length) {\n          token = tokens[tokens.length - 1][0]\n          if (token !== 'space' && token !== 'comment') break\n          this.tokenizer.back(tokens.pop())\n        }\n      }\n      this.decl(tokens, customProperty)\n    } else {\n      this.unknownWord(tokens)\n    }\n  }\n\n  parse() {\n    let token\n    while (!this.tokenizer.endOfFile()) {\n      token = this.tokenizer.nextToken()\n\n      switch (token[0]) {\n        case 'space':\n          this.spaces += token[1]\n          break\n\n        case ';':\n          this.freeSemicolon(token)\n          break\n\n        case '}':\n          this.end(token)\n          break\n\n        case 'comment':\n          this.comment(token)\n          break\n\n        case 'at-word':\n          this.atrule(token)\n          break\n\n        case '{':\n          this.emptyRule(token)\n          break\n\n        default:\n          this.other(token)\n          break\n      }\n    }\n    this.endFile()\n  }\n\n  precheckMissedSemicolon(/* tokens */) {\n    // Hook for Safe Parser\n  }\n\n  raw(node, prop, tokens, customProperty) {\n    let token, type\n    let length = tokens.length\n    let value = ''\n    let clean = true\n    let next, prev\n\n    for (let i = 0; i < length; i += 1) {\n      token = tokens[i]\n      type = token[0]\n      if (type === 'space' && i === length - 1 && !customProperty) {\n        clean = false\n      } else if (type === 'comment') {\n        prev = tokens[i - 1] ? tokens[i - 1][0] : 'empty'\n        next = tokens[i + 1] ? tokens[i + 1][0] : 'empty'\n        if (!SAFE_COMMENT_NEIGHBOR[prev] && !SAFE_COMMENT_NEIGHBOR[next]) {\n          if (value.slice(-1) === ',') {\n            clean = false\n          } else {\n            value += token[1]\n          }\n        } else {\n          clean = false\n        }\n      } else {\n        value += token[1]\n      }\n    }\n    if (!clean) {\n      let raw = tokens.reduce((all, i) => all + i[1], '')\n      node.raws[prop] = { raw, value }\n    }\n    node[prop] = value\n  }\n\n  rule(tokens) {\n    tokens.pop()\n\n    let node = new Rule()\n    this.init(node, tokens[0][2])\n\n    node.raws.between = this.spacesAndCommentsFromEnd(tokens)\n    this.raw(node, 'selector', tokens)\n    this.current = node\n  }\n\n  spacesAndCommentsFromEnd(tokens) {\n    let lastTokenType\n    let spaces = ''\n    while (tokens.length) {\n      lastTokenType = tokens[tokens.length - 1][0]\n      if (lastTokenType !== 'space' && lastTokenType !== 'comment') break\n      spaces = tokens.pop()[1] + spaces\n    }\n    return spaces\n  }\n\n  // Errors\n\n  spacesAndCommentsFromStart(tokens) {\n    let next\n    let spaces = ''\n    while (tokens.length) {\n      next = tokens[0][0]\n      if (next !== 'space' && next !== 'comment') break\n      spaces += tokens.shift()[1]\n    }\n    return spaces\n  }\n\n  spacesFromEnd(tokens) {\n    let lastTokenType\n    let spaces = ''\n    while (tokens.length) {\n      lastTokenType = tokens[tokens.length - 1][0]\n      if (lastTokenType !== 'space') break\n      spaces = tokens.pop()[1] + spaces\n    }\n    return spaces\n  }\n\n  stringFrom(tokens, from) {\n    let result = ''\n    for (let i = from; i < tokens.length; i++) {\n      result += tokens[i][1]\n    }\n    tokens.splice(from, tokens.length - from)\n    return result\n  }\n\n  unclosedBlock() {\n    let pos = this.current.source.start\n    throw this.input.error('Unclosed block', pos.line, pos.column)\n  }\n\n  unclosedBracket(bracket) {\n    throw this.input.error(\n      'Unclosed bracket',\n      { offset: bracket[2] },\n      { offset: bracket[2] + 1 }\n    )\n  }\n\n  unexpectedClose(token) {\n    throw this.input.error(\n      'Unexpected }',\n      { offset: token[2] },\n      { offset: token[2] + 1 }\n    )\n  }\n\n  unknownWord(tokens) {\n    throw this.input.error(\n      'Unknown word',\n      { offset: tokens[0][2] },\n      { offset: tokens[0][2] + tokens[0][1].length }\n    )\n  }\n\n  unnamedAtrule(node, token) {\n    throw this.input.error(\n      'At-rule without name',\n      { offset: token[2] },\n      { offset: token[2] + token[1].length }\n    )\n  }\n}\n\nmodule.exports = Parser\n","'use strict'\n\nlet AtRule = require('./at-rule')\nlet Comment = require('./comment')\nlet Container = require('./container')\nlet CssSyntaxError = require('./css-syntax-error')\nlet Declaration = require('./declaration')\nlet Document = require('./document')\nlet fromJSON = require('./fromJSON')\nlet Input = require('./input')\nlet LazyResult = require('./lazy-result')\nlet list = require('./list')\nlet Node = require('./node')\nlet parse = require('./parse')\nlet Processor = require('./processor')\nlet Result = require('./result.js')\nlet Root = require('./root')\nlet Rule = require('./rule')\nlet stringify = require('./stringify')\nlet Warning = require('./warning')\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","'use strict'\n\nlet { existsSync, readFileSync } = require('fs')\nlet { dirname, join } = require('path')\nlet { SourceMapConsumer, SourceMapGenerator } = require('source-map-js')\n\nfunction fromBase64(str) {\n  if (Buffer) {\n    return Buffer.from(str, 'base64').toString()\n  } else {\n    /* c8 ignore next 2 */\n    return window.atob(str)\n  }\n}\n\nclass PreviousMap {\n  constructor(css, opts) {\n    if (opts.map === false) return\n    this.loadAnnotation(css)\n    this.inline = this.startWith(this.annotation, 'data:')\n\n    let prev = opts.map ? opts.map.prev : undefined\n    let text = this.loadMap(opts.from, prev)\n    if (!this.mapFile && opts.from) {\n      this.mapFile = opts.from\n    }\n    if (this.mapFile) this.root = dirname(this.mapFile)\n    if (text) this.text = text\n  }\n\n  consumer() {\n    if (!this.consumerCache) {\n      this.consumerCache = new SourceMapConsumer(this.text)\n    }\n    return this.consumerCache\n  }\n\n  decodeInline(text) {\n    let baseCharsetUri = /^data:application\\/json;charset=utf-?8;base64,/\n    let baseUri = /^data:application\\/json;base64,/\n    let charsetUri = /^data:application\\/json;charset=utf-?8,/\n    let uri = /^data:application\\/json,/\n\n    let uriMatch = text.match(charsetUri) || text.match(uri)\n    if (uriMatch) {\n      return decodeURIComponent(text.substr(uriMatch[0].length))\n    }\n\n    let baseUriMatch = text.match(baseCharsetUri) || text.match(baseUri)\n    if (baseUriMatch) {\n      return fromBase64(text.substr(baseUriMatch[0].length))\n    }\n\n    let encoding = text.match(/data:application\\/json;([^,]+),/)[1]\n    throw new Error('Unsupported source map encoding ' + encoding)\n  }\n\n  getAnnotationURL(sourceMapString) {\n    return sourceMapString.replace(/^\\/\\*\\s*# sourceMappingURL=/, '').trim()\n  }\n\n  isMap(map) {\n    if (typeof map !== 'object') return false\n    return (\n      typeof map.mappings === 'string' ||\n      typeof map._mappings === 'string' ||\n      Array.isArray(map.sections)\n    )\n  }\n\n  loadAnnotation(css) {\n    let comments = css.match(/\\/\\*\\s*# sourceMappingURL=/g)\n    if (!comments) return\n\n    // sourceMappingURLs from comments, strings, etc.\n    let start = css.lastIndexOf(comments.pop())\n    let end = css.indexOf('*/', start)\n\n    if (start > -1 && end > -1) {\n      // Locate the last sourceMappingURL to avoid pickin\n      this.annotation = this.getAnnotationURL(css.substring(start, end))\n    }\n  }\n\n  loadFile(path) {\n    this.root = dirname(path)\n    if (existsSync(path)) {\n      this.mapFile = path\n      return readFileSync(path, 'utf-8').toString().trim()\n    }\n  }\n\n  loadMap(file, prev) {\n    if (prev === false) return false\n\n    if (prev) {\n      if (typeof prev === 'string') {\n        return prev\n      } else if (typeof prev === 'function') {\n        let prevPath = prev(file)\n        if (prevPath) {\n          let map = this.loadFile(prevPath)\n          if (!map) {\n            throw new Error(\n              'Unable to load previous source map: ' + prevPath.toString()\n            )\n          }\n          return map\n        }\n      } else if (prev instanceof SourceMapConsumer) {\n        return SourceMapGenerator.fromSourceMap(prev).toString()\n      } else if (prev instanceof SourceMapGenerator) {\n        return prev.toString()\n      } else if (this.isMap(prev)) {\n        return JSON.stringify(prev)\n      } else {\n        throw new Error(\n          'Unsupported previous source map format: ' + prev.toString()\n        )\n      }\n    } else if (this.inline) {\n      return this.decodeInline(this.annotation)\n    } else if (this.annotation) {\n      let map = this.annotation\n      if (file) map = join(dirname(file), map)\n      return this.loadFile(map)\n    }\n  }\n\n  startWith(string, start) {\n    if (!string) return false\n    return string.substr(0, start.length) === start\n  }\n\n  withContent() {\n    return !!(\n      this.consumer().sourcesContent &&\n      this.consumer().sourcesContent.length > 0\n    )\n  }\n}\n\nmodule.exports = PreviousMap\nPreviousMap.default = PreviousMap\n","'use strict'\n\nlet Document = require('./document')\nlet LazyResult = require('./lazy-result')\nlet NoWorkResult = require('./no-work-result')\nlet Root = require('./root')\n\nclass Processor {\n  constructor(plugins = []) {\n    this.version = '8.5.1'\n    this.plugins = this.normalize(plugins)\n  }\n\n  normalize(plugins) {\n    let normalized = []\n    for (let i of plugins) {\n      if (i.postcss === true) {\n        i = i()\n      } else if (i.postcss) {\n        i = i.postcss\n      }\n\n      if (typeof i === 'object' && Array.isArray(i.plugins)) {\n        normalized = normalized.concat(i.plugins)\n      } else if (typeof i === 'object' && i.postcssPlugin) {\n        normalized.push(i)\n      } else if (typeof i === 'function') {\n        normalized.push(i)\n      } else if (typeof i === 'object' && (i.parse || i.stringify)) {\n        if (process.env.NODE_ENV !== 'production') {\n          throw new Error(\n            'PostCSS syntaxes cannot be used as plugins. Instead, please use ' +\n              'one of the syntax/parser/stringifier options as outlined ' +\n              'in your PostCSS runner documentation.'\n          )\n        }\n      } else {\n        throw new Error(i + ' is not a PostCSS plugin')\n      }\n    }\n    return normalized\n  }\n\n  process(css, opts = {}) {\n    if (\n      !this.plugins.length &&\n      !opts.parser &&\n      !opts.stringifier &&\n      !opts.syntax\n    ) {\n      return new NoWorkResult(this, css, opts)\n    } else {\n      return new LazyResult(this, css, opts)\n    }\n  }\n\n  use(plugin) {\n    this.plugins = this.plugins.concat(this.normalize([plugin]))\n    return this\n  }\n}\n\nmodule.exports = Processor\nProcessor.default = Processor\n\nRoot.registerProcessor(Processor)\nDocument.registerProcessor(Processor)\n","'use strict'\n\nlet Warning = require('./warning')\n\nclass Result {\n  constructor(processor, root, opts) {\n    this.processor = processor\n    this.messages = []\n    this.root = root\n    this.opts = opts\n    this.css = undefined\n    this.map = undefined\n  }\n\n  toString() {\n    return this.css\n  }\n\n  warn(text, opts = {}) {\n    if (!opts.plugin) {\n      if (this.lastPlugin && this.lastPlugin.postcssPlugin) {\n        opts.plugin = this.lastPlugin.postcssPlugin\n      }\n    }\n\n    let warning = new Warning(text, opts)\n    this.messages.push(warning)\n\n    return warning\n  }\n\n  warnings() {\n    return this.messages.filter(i => i.type === 'warning')\n  }\n\n  get content() {\n    return this.css\n  }\n}\n\nmodule.exports = Result\nResult.default = Result\n","'use strict'\n\nlet Container = require('./container')\n\nlet LazyResult, Processor\n\nclass Root extends Container {\n  constructor(defaults) {\n    super(defaults)\n    this.type = 'root'\n    if (!this.nodes) this.nodes = []\n  }\n\n  normalize(child, sample, type) {\n    let nodes = super.normalize(child)\n\n    if (sample) {\n      if (type === 'prepend') {\n        if (this.nodes.length > 1) {\n          sample.raws.before = this.nodes[1].raws.before\n        } else {\n          delete sample.raws.before\n        }\n      } else if (this.first !== sample) {\n        for (let node of nodes) {\n          node.raws.before = sample.raws.before\n        }\n      }\n    }\n\n    return nodes\n  }\n\n  removeChild(child, ignore) {\n    let index = this.index(child)\n\n    if (!ignore && index === 0 && this.nodes.length > 1) {\n      this.nodes[1].raws.before = this.nodes[index].raws.before\n    }\n\n    return super.removeChild(child)\n  }\n\n  toResult(opts = {}) {\n    let lazy = new LazyResult(new Processor(), this, opts)\n    return lazy.stringify()\n  }\n}\n\nRoot.registerLazyResult = dependant => {\n  LazyResult = dependant\n}\n\nRoot.registerProcessor = dependant => {\n  Processor = dependant\n}\n\nmodule.exports = Root\nRoot.default = Root\n\nContainer.registerRoot(Root)\n","'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\nconst DEFAULT_RAW = {\n  after: '\\n',\n  beforeClose: '\\n',\n  beforeComment: '\\n',\n  beforeDecl: '\\n',\n  beforeOpen: ' ',\n  beforeRule: '\\n',\n  colon: ': ',\n  commentLeft: ' ',\n  commentRight: ' ',\n  emptyBody: '',\n  indent: '    ',\n  semicolon: false\n}\n\nfunction capitalize(str) {\n  return str[0].toUpperCase() + str.slice(1)\n}\n\nclass Stringifier {\n  constructor(builder) {\n    this.builder = builder\n  }\n\n  atrule(node, semicolon) {\n    let name = '@' + node.name\n    let params = node.params ? this.rawValue(node, 'params') : ''\n\n    if (typeof node.raws.afterName !== 'undefined') {\n      name += node.raws.afterName\n    } else if (params) {\n      name += ' '\n    }\n\n    if (node.nodes) {\n      this.block(node, name + params)\n    } else {\n      let end = (node.raws.between || '') + (semicolon ? ';' : '')\n      this.builder(name + params + end, node)\n    }\n  }\n\n  beforeAfter(node, detect) {\n    let value\n    if (node.type === 'decl') {\n      value = this.raw(node, null, 'beforeDecl')\n    } else if (node.type === 'comment') {\n      value = this.raw(node, null, 'beforeComment')\n    } else if (detect === 'before') {\n      value = this.raw(node, null, 'beforeRule')\n    } else {\n      value = this.raw(node, null, 'beforeClose')\n    }\n\n    let buf = node.parent\n    let depth = 0\n    while (buf && buf.type !== 'root') {\n      depth += 1\n      buf = buf.parent\n    }\n\n    if (value.includes('\\n')) {\n      let indent = this.raw(node, null, 'indent')\n      if (indent.length) {\n        for (let step = 0; step < depth; step++) value += indent\n      }\n    }\n\n    return value\n  }\n\n  block(node, start) {\n    let between = this.raw(node, 'between', 'beforeOpen')\n    this.builder(start + between + '{', node, 'start')\n\n    let after\n    if (node.nodes && node.nodes.length) {\n      this.body(node)\n      after = this.raw(node, 'after')\n    } else {\n      after = this.raw(node, 'after', 'emptyBody')\n    }\n\n    if (after) this.builder(after)\n    this.builder('}', node, 'end')\n  }\n\n  body(node) {\n    let last = node.nodes.length - 1\n    while (last > 0) {\n      if (node.nodes[last].type !== 'comment') break\n      last -= 1\n    }\n\n    let semicolon = this.raw(node, 'semicolon')\n    for (let i = 0; i < node.nodes.length; i++) {\n      let child = node.nodes[i]\n      let before = this.raw(child, 'before')\n      if (before) this.builder(before)\n      this.stringify(child, last !== i || semicolon)\n    }\n  }\n\n  comment(node) {\n    let left = this.raw(node, 'left', 'commentLeft')\n    let right = this.raw(node, 'right', 'commentRight')\n    this.builder('/*' + left + node.text + right + '*/', node)\n  }\n\n  decl(node, semicolon) {\n    let between = this.raw(node, 'between', 'colon')\n    let string = node.prop + between + this.rawValue(node, 'value')\n\n    if (node.important) {\n      string += node.raws.important || ' !important'\n    }\n\n    if (semicolon) string += ';'\n    this.builder(string, node)\n  }\n\n  document(node) {\n    this.body(node)\n  }\n\n  raw(node, own, detect) {\n    let value\n    if (!detect) detect = own\n\n    // Already had\n    if (own) {\n      value = node.raws[own]\n      if (typeof value !== 'undefined') return value\n    }\n\n    let parent = node.parent\n\n    if (detect === 'before') {\n      // Hack for first rule in CSS\n      if (!parent || (parent.type === 'root' && parent.first === node)) {\n        return ''\n      }\n\n      // `root` nodes in `document` should use only their own raws\n      if (parent && parent.type === 'document') {\n        return ''\n      }\n    }\n\n    // Floating child without parent\n    if (!parent) return DEFAULT_RAW[detect]\n\n    // Detect style by other nodes\n    let root = node.root()\n    if (!root.rawCache) root.rawCache = {}\n    if (typeof root.rawCache[detect] !== 'undefined') {\n      return root.rawCache[detect]\n    }\n\n    if (detect === 'before' || detect === 'after') {\n      return this.beforeAfter(node, detect)\n    } else {\n      let method = 'raw' + capitalize(detect)\n      if (this[method]) {\n        value = this[method](root, node)\n      } else {\n        root.walk(i => {\n          value = i.raws[own]\n          if (typeof value !== 'undefined') return false\n        })\n      }\n    }\n\n    if (typeof value === 'undefined') value = DEFAULT_RAW[detect]\n\n    root.rawCache[detect] = value\n    return value\n  }\n\n  rawBeforeClose(root) {\n    let value\n    root.walk(i => {\n      if (i.nodes && i.nodes.length > 0) {\n        if (typeof i.raws.after !== 'undefined') {\n          value = i.raws.after\n          if (value.includes('\\n')) {\n            value = value.replace(/[^\\n]+$/, '')\n          }\n          return false\n        }\n      }\n    })\n    if (value) value = value.replace(/\\S/g, '')\n    return value\n  }\n\n  rawBeforeComment(root, node) {\n    let value\n    root.walkComments(i => {\n      if (typeof i.raws.before !== 'undefined') {\n        value = i.raws.before\n        if (value.includes('\\n')) {\n          value = value.replace(/[^\\n]+$/, '')\n        }\n        return false\n      }\n    })\n    if (typeof value === 'undefined') {\n      value = this.raw(node, null, 'beforeDecl')\n    } else if (value) {\n      value = value.replace(/\\S/g, '')\n    }\n    return value\n  }\n\n  rawBeforeDecl(root, node) {\n    let value\n    root.walkDecls(i => {\n      if (typeof i.raws.before !== 'undefined') {\n        value = i.raws.before\n        if (value.includes('\\n')) {\n          value = value.replace(/[^\\n]+$/, '')\n        }\n        return false\n      }\n    })\n    if (typeof value === 'undefined') {\n      value = this.raw(node, null, 'beforeRule')\n    } else if (value) {\n      value = value.replace(/\\S/g, '')\n    }\n    return value\n  }\n\n  rawBeforeOpen(root) {\n    let value\n    root.walk(i => {\n      if (i.type !== 'decl') {\n        value = i.raws.between\n        if (typeof value !== 'undefined') return false\n      }\n    })\n    return value\n  }\n\n  rawBeforeRule(root) {\n    let value\n    root.walk(i => {\n      if (i.nodes && (i.parent !== root || root.first !== i)) {\n        if (typeof i.raws.before !== 'undefined') {\n          value = i.raws.before\n          if (value.includes('\\n')) {\n            value = value.replace(/[^\\n]+$/, '')\n          }\n          return false\n        }\n      }\n    })\n    if (value) value = value.replace(/\\S/g, '')\n    return value\n  }\n\n  rawColon(root) {\n    let value\n    root.walkDecls(i => {\n      if (typeof i.raws.between !== 'undefined') {\n        value = i.raws.between.replace(/[^\\s:]/g, '')\n        return false\n      }\n    })\n    return value\n  }\n\n  rawEmptyBody(root) {\n    let value\n    root.walk(i => {\n      if (i.nodes && i.nodes.length === 0) {\n        value = i.raws.after\n        if (typeof value !== 'undefined') return false\n      }\n    })\n    return value\n  }\n\n  rawIndent(root) {\n    if (root.raws.indent) return root.raws.indent\n    let value\n    root.walk(i => {\n      let p = i.parent\n      if (p && p !== root && p.parent && p.parent === root) {\n        if (typeof i.raws.before !== 'undefined') {\n          let parts = i.raws.before.split('\\n')\n          value = parts[parts.length - 1]\n          value = value.replace(/\\S/g, '')\n          return false\n        }\n      }\n    })\n    return value\n  }\n\n  rawSemicolon(root) {\n    let value\n    root.walk(i => {\n      if (i.nodes && i.nodes.length && i.last.type === 'decl') {\n        value = i.raws.semicolon\n        if (typeof value !== 'undefined') return false\n      }\n    })\n    return value\n  }\n\n  rawValue(node, prop) {\n    let value = node[prop]\n    let raw = node.raws[prop]\n    if (raw && raw.value === value) {\n      return raw.raw\n    }\n\n    return value\n  }\n\n  root(node) {\n    this.body(node)\n    if (node.raws.after) this.builder(node.raws.after)\n  }\n\n  rule(node) {\n    this.block(node, this.rawValue(node, 'selector'))\n    if (node.raws.ownSemicolon) {\n      this.builder(node.raws.ownSemicolon, node, 'end')\n    }\n  }\n\n  stringify(node, semicolon) {\n    /* c8 ignore start */\n    if (!this[node.type]) {\n      throw new Error(\n        'Unknown AST node type ' +\n          node.type +\n          '. ' +\n          'Maybe you need to change PostCSS stringifier.'\n      )\n    }\n    /* c8 ignore stop */\n    this[node.type](node, semicolon)\n  }\n}\n\nmodule.exports = Stringifier\nStringifier.default = Stringifier\n","'use strict'\n\nlet 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\nmodule.exports.isClean = Symbol('isClean')\n\nmodule.exports.my = Symbol('my')\n","'use strict'\n\nconst SINGLE_QUOTE = \"'\".charCodeAt(0)\nconst DOUBLE_QUOTE = '\"'.charCodeAt(0)\nconst BACKSLASH = '\\\\'.charCodeAt(0)\nconst SLASH = '/'.charCodeAt(0)\nconst NEWLINE = '\\n'.charCodeAt(0)\nconst SPACE = ' '.charCodeAt(0)\nconst FEED = '\\f'.charCodeAt(0)\nconst TAB = '\\t'.charCodeAt(0)\nconst CR = '\\r'.charCodeAt(0)\nconst OPEN_SQUARE = '['.charCodeAt(0)\nconst CLOSE_SQUARE = ']'.charCodeAt(0)\nconst OPEN_PARENTHESES = '('.charCodeAt(0)\nconst CLOSE_PARENTHESES = ')'.charCodeAt(0)\nconst OPEN_CURLY = '{'.charCodeAt(0)\nconst CLOSE_CURLY = '}'.charCodeAt(0)\nconst SEMICOLON = ';'.charCodeAt(0)\nconst ASTERISK = '*'.charCodeAt(0)\nconst COLON = ':'.charCodeAt(0)\nconst AT = '@'.charCodeAt(0)\n\nconst RE_AT_END = /[\\t\\n\\f\\r \"#'()/;[\\\\\\]{}]/g\nconst RE_WORD_END = /[\\t\\n\\f\\r !\"#'():;@[\\\\\\]{}]|\\/(?=\\*)/g\nconst RE_BAD_BRACKET = /.[\\r\\n\"'(/\\\\]/\nconst RE_HEX_ESCAPE = /[\\da-f]/i\n\nmodule.exports = function tokenizer(input, options = {}) {\n  let css = input.css.valueOf()\n  let ignore = options.ignoreErrors\n\n  let code, content, escape, next, quote\n  let currentToken, escaped, escapePos, n, prev\n\n  let length = css.length\n  let pos = 0\n  let buffer = []\n  let returned = []\n\n  function position() {\n    return pos\n  }\n\n  function unclosed(what) {\n    throw input.error('Unclosed ' + what, pos)\n  }\n\n  function endOfFile() {\n    return returned.length === 0 && pos >= length\n  }\n\n  function nextToken(opts) {\n    if (returned.length) return returned.pop()\n    if (pos >= length) return\n\n    let ignoreUnclosed = opts ? opts.ignoreUnclosed : false\n\n    code = css.charCodeAt(pos)\n\n    switch (code) {\n      case NEWLINE:\n      case SPACE:\n      case TAB:\n      case CR:\n      case FEED: {\n        next = pos\n        do {\n          next += 1\n          code = css.charCodeAt(next)\n        } while (\n          code === SPACE ||\n          code === NEWLINE ||\n          code === TAB ||\n          code === CR ||\n          code === FEED\n        )\n\n        currentToken = ['space', css.slice(pos, next)]\n        pos = next - 1\n        break\n      }\n\n      case OPEN_SQUARE:\n      case CLOSE_SQUARE:\n      case OPEN_CURLY:\n      case CLOSE_CURLY:\n      case COLON:\n      case SEMICOLON:\n      case CLOSE_PARENTHESES: {\n        let controlChar = String.fromCharCode(code)\n        currentToken = [controlChar, controlChar, pos]\n        break\n      }\n\n      case OPEN_PARENTHESES: {\n        prev = buffer.length ? buffer.pop()[1] : ''\n        n = css.charCodeAt(pos + 1)\n        if (\n          prev === 'url' &&\n          n !== SINGLE_QUOTE &&\n          n !== DOUBLE_QUOTE &&\n          n !== SPACE &&\n          n !== NEWLINE &&\n          n !== TAB &&\n          n !== FEED &&\n          n !== CR\n        ) {\n          next = pos\n          do {\n            escaped = false\n            next = css.indexOf(')', next + 1)\n            if (next === -1) {\n              if (ignore || ignoreUnclosed) {\n                next = pos\n                break\n              } else {\n                unclosed('bracket')\n              }\n            }\n            escapePos = next\n            while (css.charCodeAt(escapePos - 1) === BACKSLASH) {\n              escapePos -= 1\n              escaped = !escaped\n            }\n          } while (escaped)\n\n          currentToken = ['brackets', css.slice(pos, next + 1), pos, next]\n\n          pos = next\n        } else {\n          next = css.indexOf(')', pos + 1)\n          content = css.slice(pos, next + 1)\n\n          if (next === -1 || RE_BAD_BRACKET.test(content)) {\n            currentToken = ['(', '(', pos]\n          } else {\n            currentToken = ['brackets', content, pos, next]\n            pos = next\n          }\n        }\n\n        break\n      }\n\n      case SINGLE_QUOTE:\n      case DOUBLE_QUOTE: {\n        quote = code === SINGLE_QUOTE ? \"'\" : '\"'\n        next = pos\n        do {\n          escaped = false\n          next = css.indexOf(quote, next + 1)\n          if (next === -1) {\n            if (ignore || ignoreUnclosed) {\n              next = pos + 1\n              break\n            } else {\n              unclosed('string')\n            }\n          }\n          escapePos = next\n          while (css.charCodeAt(escapePos - 1) === BACKSLASH) {\n            escapePos -= 1\n            escaped = !escaped\n          }\n        } while (escaped)\n\n        currentToken = ['string', css.slice(pos, next + 1), pos, next]\n        pos = next\n        break\n      }\n\n      case AT: {\n        RE_AT_END.lastIndex = pos + 1\n        RE_AT_END.test(css)\n        if (RE_AT_END.lastIndex === 0) {\n          next = css.length - 1\n        } else {\n          next = RE_AT_END.lastIndex - 2\n        }\n\n        currentToken = ['at-word', css.slice(pos, next + 1), pos, next]\n\n        pos = next\n        break\n      }\n\n      case BACKSLASH: {\n        next = pos\n        escape = true\n        while (css.charCodeAt(next + 1) === BACKSLASH) {\n          next += 1\n          escape = !escape\n        }\n        code = css.charCodeAt(next + 1)\n        if (\n          escape &&\n          code !== SLASH &&\n          code !== SPACE &&\n          code !== NEWLINE &&\n          code !== TAB &&\n          code !== CR &&\n          code !== FEED\n        ) {\n          next += 1\n          if (RE_HEX_ESCAPE.test(css.charAt(next))) {\n            while (RE_HEX_ESCAPE.test(css.charAt(next + 1))) {\n              next += 1\n            }\n            if (css.charCodeAt(next + 1) === SPACE) {\n              next += 1\n            }\n          }\n        }\n\n        currentToken = ['word', css.slice(pos, next + 1), pos, next]\n\n        pos = next\n        break\n      }\n\n      default: {\n        if (code === SLASH && css.charCodeAt(pos + 1) === ASTERISK) {\n          next = css.indexOf('*/', pos + 2) + 1\n          if (next === 0) {\n            if (ignore || ignoreUnclosed) {\n              next = css.length\n            } else {\n              unclosed('comment')\n            }\n          }\n\n          currentToken = ['comment', css.slice(pos, next + 1), pos, next]\n          pos = next\n        } else {\n          RE_WORD_END.lastIndex = pos + 1\n          RE_WORD_END.test(css)\n          if (RE_WORD_END.lastIndex === 0) {\n            next = css.length - 1\n          } else {\n            next = RE_WORD_END.lastIndex - 2\n          }\n\n          currentToken = ['word', css.slice(pos, next + 1), pos, next]\n          buffer.push(currentToken)\n          pos = next\n        }\n\n        break\n      }\n    }\n\n    pos++\n    return currentToken\n  }\n\n  function back(token) {\n    returned.push(token)\n  }\n\n  return {\n    back,\n    endOfFile,\n    nextToken,\n    position\n  }\n}\n","/* eslint-disable no-console */\n'use strict'\n\nlet printed = {}\n\nmodule.exports = function warnOnce(message) {\n  if (printed[message]) return\n  printed[message] = true\n\n  if (typeof console !== 'undefined' && console.warn) {\n    console.warn(message)\n  }\n}\n","'use strict'\n\nclass Warning {\n  constructor(text, opts = {}) {\n    this.type = 'warning'\n    this.text = text\n\n    if (opts.node && opts.node.source) {\n      let range = opts.node.rangeBy(opts)\n      this.line = range.start.line\n      this.column = range.start.column\n      this.endLine = range.end.line\n      this.endColumn = range.end.column\n    }\n\n    for (let opt in opts) this[opt] = opts[opt]\n  }\n\n  toString() {\n    if (this.node) {\n      return this.node.error(this.text, {\n        index: this.index,\n        plugin: this.plugin,\n        word: this.word\n      }).message\n    }\n\n    if (this.plugin) {\n      return this.plugin + ': ' + this.text\n    }\n\n    return this.text\n  }\n}\n\nmodule.exports = Warning\nWarning.default = Warning\n","import postcss from './postcss.js'\n\nexport default postcss\n\nexport const stringify = postcss.stringify\nexport const fromJSON = postcss.fromJSON\nexport const plugin = postcss.plugin\nexport const parse = postcss.parse\nexport const list = postcss.list\n\nexport const document = postcss.document\nexport const comment = postcss.comment\nexport const atRule = postcss.atRule\nexport const rule = postcss.rule\nexport const decl = postcss.decl\nexport const root = postcss.root\n\nexport const CssSyntaxError = postcss.CssSyntaxError\nexport const Declaration = postcss.Declaration\nexport const Container = postcss.Container\nexport const Processor = postcss.Processor\nexport const Document = postcss.Document\nexport const Comment = postcss.Comment\nexport const Warning = postcss.Warning\nexport const AtRule = postcss.AtRule\nexport const Result = postcss.Result\nexport const Input = postcss.Input\nexport const Rule = postcss.Rule\nexport const Root = postcss.Root\nexport const Node = postcss.Node\n"],"names":["Container","require","AtRule","constructor","defaults","super","this","type","append","proxyOf","nodes","arguments","prepend","module","exports","default","registerAtRule","Node","Comment","parse","Root","Rule","Declaration","isClean","my","cleanSource","map","i","source","markTreeDirty","node","_len","length","children","Array","_key","child","normalize","last","push","markDirty","cleanRaws","keepBetween","each","callback","index","result","iterator","getIterator","indexes","every","condition","lastEach","getProxyProcessor","get","prop","startsWith","_len2","args","_key2","toProxy","cb","_len3","other","_key3","root","set","value","indexOf","insertAfter","exist","add","existIndex","reverse","splice","id","insertBefore","sample","isArray","slice","parent","removeChild","Error","String","selector","selectors","name","text","rebuild","raws","before","replace","_len4","_key4","first","unshift","removeAll","undefined","replaceValues","pattern","opts","walkDecls","decl","props","includes","fast","some","walk","e","addToError","walkAtRules","RegExp","test","walkComments","walkRules","registerParse","dependant","registerRule","registerRoot","Object","setPrototypeOf","prototype","forEach","pico","terminalHighlight","CssSyntaxError","message","line","column","file","plugin","reason","endLine","endColumn","setMessage","captureStackTrace","showSourceCode","color","css","isColorSupported","aside","mark","highlight","bold","gray","red","createColors","lines","split","start","Math","max","end","min","maxWidth","number","gutter","padding","subLineStart","subLineEnd","subLine","spacing","join","toString","code","_objectSpread","variable","LazyResult","Processor","Document","toResult","stringify","registerLazyResult","registerProcessor","_objectWithoutProperties","_excluded","_excluded2","Input","PreviousMap","fromJSON","json","inputs","n","ownInputs","input","inputHydrated","__proto__","_defaults$source","inputId","nanoid","isAbsolute","resolve","SourceMapConsumer","SourceMapGenerator","fileURLToPath","pathToFileURL","fromOffsetCache","Symbol","sourceMapAvailable","Boolean","pathAvailable","concat","hasBOM","document","from","consumer","mapResolve","error","offset","pos","fromOffset","col","origin","url","lastLine","lineToIndex","prevIndex","l","mid","sourceRoot","to","fromUrl","originalPositionFor","URL","mapFile","protocol","sourceContentFor","toJSON","consumerCache","registerInput","MapGenerator","Result","TYPE_TO_CLASS_NAME","atrule","comment","rule","PLUGIN_PROPS","AtRuleExit","CommentExit","DeclarationExit","DocumentExit","Once","OnceExit","postcssPlugin","prepare","RootExit","RuleExit","NOT_VISITORS","isPromise","obj","then","getEvents","key","toLowerCase","toStack","events","eventIndex","visitorIndex","visitors","cleanMarks","postcss","processor","stringified","processed","inline","prev","parser","syntax","helpers","plugins","async","Promise","reject","processing","runAsync","catch","onRejected","finally","onFinally","getAsyncError","handleError","lastPlugin","postcssVersion","err","console","prepareVisitors","listeners","event","version","filter","hasListener","keys","promise","runOnRoot","stack","visitTick","visitor","roots","subRoot","all","sync","str","stringifier","data","generate","walkSync","visitSync","onFulfilled","visit","pop","warnings","content","messages","toStringTag","registerPostcss","list","comma","string","space","separators","array","current","func","inQuote","prevQuote","escape","letter","trim","dirname","relative","sep","cssString","mapOpts","originalCSS","usesFileUrls","absolute","memoizedFileURLs","Map","memoizedPaths","memoizedURLs","addAnnotation","isInline","toBase64","annotation","outputFile","eol","applyPrevMaps","previous","toUrl","path","sourcesContent","applySourceMap","clearAnnotation","isMap","generateMap","generateString","fromSourceMap","ignoreInvalidMapping","addMapping","generated","original","isSourcesContent","setSourcesContent","isAnnotation","noSource","mapping","sourcePath","match","lastIndexOf","p","semicolon","withContent","charCodeAt","cached","previousMaps","already","toFileUrl","setSourceContent","Buffer","window","btoa","unescape","encodeURIComponent","fileURL","encodeURI","NoWorkResult","_processor","_css","_opts","_map","self","defineProperty","generatedCSS","generatedMap","_root","Stringifier","cloneNode","cloned","hasOwnProperty","call","j","sourceOffset","inputCSS","position","clone","postcssNode","s","after","assign","overrides","between","cloneAfter","cloneBefore","rangeBy","markClean","next","positionBy","positionInside","word","inputString","endIndex","raw","defaultType","remove","replaceWith","bookmark","foundSelf","_","fixed","emitInputs","inputsNextIndex","proxyCache","Proxy","warn","Parser","tokenizer","SAFE_COMMENT_NEIGHBOR","empty","spaces","createTokenizer","token","shift","unnamedAtrule","init","open","params","brackets","endOfFile","nextToken","getPosition","spacesAndCommentsFromEnd","afterName","spacesAndCommentsFromStart","checkMissedSemicolon","tokens","colon","founded","element","entries","doubleColon","left","right","customProperty","findLastWithPosition","unknownWord","firstSpaces","precheckMissedSemicolon","important","stringFrom","spacesFromEnd","cache","emptyRule","unexpectedClose","endFile","unclosedBlock","freeSemicolon","ownSemicolon","bracket","back","unclosedBracket","clean","reduce","lastTokenType","Warning","initializer","warningPrinted","creator","process","LANG","transformer","processOpts","pluginOpts","atRule","existsSync","readFileSync","loadAnnotation","startWith","loadMap","decodeInline","uriMatch","decodeURIComponent","substr","baseUriMatch","atob","encoding","getAnnotationURL","sourceMapString","mappings","_mappings","sections","comments","substring","loadFile","JSON","prevPath","normalized","use","warning","ignore","values","DEFAULT_RAW","beforeClose","beforeComment","beforeDecl","beforeOpen","beforeRule","commentLeft","commentRight","emptyBody","indent","builder","rawValue","block","beforeAfter","detect","buf","depth","step","body","own","rawCache","method","toUpperCase","rawBeforeClose","rawBeforeComment","rawBeforeDecl","rawBeforeOpen","rawBeforeRule","rawColon","rawEmptyBody","rawIndent","parts","rawSemicolon","SINGLE_QUOTE","DOUBLE_QUOTE","BACKSLASH","SLASH","NEWLINE","SPACE","FEED","TAB","CR","OPEN_SQUARE","CLOSE_SQUARE","OPEN_PARENTHESES","CLOSE_PARENTHESES","OPEN_CURLY","CLOSE_CURLY","SEMICOLON","ASTERISK","COLON","AT","RE_AT_END","RE_WORD_END","RE_BAD_BRACKET","RE_HEX_ESCAPE","quote","currentToken","escaped","escapePos","options","valueOf","ignoreErrors","buffer","returned","unclosed","what","ignoreUnclosed","controlChar","fromCharCode","lastIndex","charAt","printed","range","opt"],"sourceRoot":""}