{"version":3,"file":"js/chunk-vendors-fa70753b.e85677aa.js","mappings":"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AGsD,EAAM,GACY,qBAA1CogB,EAAMrF,IAAI6H,UAAU6G,KAAK,IAAMhI,KAErCgG,IACErH,EAAMrF,IAAI6H,UAAUlc,OAAQ0Z,EAAMrF,IAAI6H,UAAUlc,KAAO,IAExD0Z,EAAMrF,IAAI6H,UAAU6G,KAAK,IAAMhI,GAAS,GAC1CmM,EAAaxN,EAAMrF,IAAI6H,UAAUlc,KAAKhQ,OACtC0pB,EAAMrF,IAAI6H,UAAUlc,KAAKknB,GAAc,CAAEnM,MAAOA,EAAOoB,MAAO,GAC9DzC,EAAMrF,IAAI6H,UAAU6G,KAAK,IAAMhI,GAASmM,GAExCA,EAAaxN,EAAMrF,IAAI6H,UAAU6G,KAAK,IAAMhI,GAG9CqM,EAAgB1N,EAAMrF,IAAI6H,UAAUlc,KAAKknB,GAAY/K,MACrDzC,EAAMrF,IAAI6H,UAAUlc,KAAKknB,GAAY/K,QAErCzC,EAAMrqB,KAAK,CACT3B,KAAM,eACN4D,GAAI41B,EACJxO,MAAO0O,EACPxN,MAAOF,EAAME,SAIjBF,EAAMpgB,IAAMA,EACZogB,EAAMM,OAAS9jB,GACR,IACT,CAKA,IAAImxB,GAAc,CAChB,OACA,MACA,aACA,MACA,OACA,QACA,OACA,MACA,MACA,OACA,OACA,MACA,OACA,MACA,OACA,MACA,MACA,KACA,SACA,OACA,OACA,QACA,MACA,OACA,KACA,OACA,OACA,MACA,OACA,YACA,WACA,YACA,WACA,OACA,SACA,MACA,OACA,QACA,OACA,UACA,OACA,MACA,KACA,MACA,OACA,kBACA,MACA,OACA,OACA,UACA,UACA,QACA,QACA,MACA,OACA,MACA,OACA,YACA,aACA,MACA,MACA,SACA,OACA,cACA,SACA,MACA,KACA,MACA,QACA,KACA,MACA,OACA,cACA,cACA,eACA,OACA,UACA,UACA,YACA,MACA,MACA,MACA,MACA,aACA,KACA,UACA,UACA,OACA,SACA,SACA,mBACA,0BACA,UACA,MACA,kBACA,qBACA,MACA,MACA,OACA,WACA,OACA,SACA,OACA,KACA,MACA,eACA,QACA,MACA,OACA,MACA,MACA,OACA,OA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","sources":["webpack://i4proportal/./node_modules/postcss/lib/at-rule.js","webpack://i4proportal/./node_modules/postcss/lib/comment.js","webpack://i4proportal/./node_modules/postcss/lib/container.js","webpack://i4proportal/./node_modules/postcss/lib/css-syntax-error.js","webpack://i4proportal/./node_modules/postcss/lib/declaration.js","webpack://i4proportal/./node_modules/postcss/lib/document.js","webpack://i4proportal/./node_modules/postcss/lib/fromJSON.js","webpack://i4proportal/./node_modules/postcss/lib/input.js","webpack://i4proportal/./node_modules/postcss/lib/lazy-result.js","webpack://i4proportal/./node_modules/postcss/lib/list.js","webpack://i4proportal/./node_modules/postcss/lib/map-generator.js","webpack://i4proportal/./node_modules/postcss/lib/no-work-result.js","webpack://i4proportal/./node_modules/postcss/lib/node.js","webpack://i4proportal/./node_modules/postcss/lib/parse.js","webpack://i4proportal/./node_modules/postcss/lib/parser.js","webpack://i4proportal/./node_modules/postcss/lib/postcss.js","webpack://i4proportal/./node_modules/postcss/lib/previous-map.js","webpack://i4proportal/./node_modules/postcss/lib/processor.js","webpack://i4proportal/./node_modules/postcss/lib/result.js","webpack://i4proportal/./node_modules/postcss/lib/root.js","webpack://i4proportal/./node_modules/postcss/lib/rule.js","webpack://i4proportal/./node_modules/postcss/lib/stringifier.js","webpack://i4proportal/./node_modules/postcss/lib/stringify.js","webpack://i4proportal/./node_modules/postcss/lib/symbols.js","webpack://i4proportal/./node_modules/postcss/lib/tokenize.js","webpack://i4proportal/./node_modules/postcss/lib/warn-once.js","webpack://i4proportal/./node_modules/postcss/lib/warning.js","webpack://i4proportal/./node_modules/remarkable/dist/esm/index.browser.js"],"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    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 stringRepresentation = this.source.input.css.slice(\n        sourceOffset(this.source.input.css, this.source.start),\n        sourceOffset(this.source.input.css, 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 offset = sourceOffset(this.source.input.css, this.source.start)\n    let end = offset + index\n\n    for (let i = offset; i < end; i++) {\n      if (this.source.input.css[i] === '\\n') {\n        column = 1\n        line += 1\n      } else {\n        column += 1\n      }\n    }\n\n    return { column, line }\n  }\n\n  prev() {\n    if (!this.parent) return undefined\n    let index = this.parent.index(this)\n    return this.parent.nodes[index - 1]\n  }\n\n  rangeBy(opts) {\n    let start = {\n      column: this.source.start.column,\n      line: this.source.start.line\n    }\n    let end = this.source.end\n      ? {\n          column: this.source.end.column + 1,\n          line: this.source.end.line\n        }\n      : {\n          column: start.column + 1,\n          line: start.line\n        }\n\n    if (opts.word) {\n      let stringRepresentation = this.source.input.css.slice(\n        sourceOffset(this.source.input.css, this.source.start),\n        sourceOffset(this.source.input.css, 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.4.49'\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","var textarea;\n\nfunction decodeEntity(name) {\n  textarea = textarea || document.createElement('textarea');\n  textarea.innerHTML = '&' + name;\n  return textarea.value;\n}\n\n/**\n * Utility functions\n */\n\nfunction typeOf(obj) {\n  return Object.prototype.toString.call(obj);\n}\n\nfunction isString(obj) {\n  return typeOf(obj) === '[object String]';\n}\n\nvar hasOwn = Object.prototype.hasOwnProperty;\n\nfunction has(object, key) {\n  return object\n    ? hasOwn.call(object, key)\n    : false;\n}\n\n// Extend objects\n//\nfunction assign(obj /*from1, from2, from3, ...*/) {\n  var sources = [].slice.call(arguments, 1);\n\n  sources.forEach(function (source) {\n    if (!source) { return; }\n\n    if (typeof source !== 'object') {\n      throw new TypeError(source + 'must be object');\n    }\n\n    Object.keys(source).forEach(function (key) {\n      obj[key] = source[key];\n    });\n  });\n\n  return obj;\n}\n\n////////////////////////////////////////////////////////////////////////////////\n\nvar UNESCAPE_MD_RE = /\\\\([\\\\!\"#$%&'()*+,.\\/:;<=>?@[\\]^_`{|}~-])/g;\n\nfunction unescapeMd(str) {\n  if (str.indexOf('\\\\') < 0) { return str; }\n  return str.replace(UNESCAPE_MD_RE, '$1');\n}\n\n////////////////////////////////////////////////////////////////////////////////\n\nfunction isValidEntityCode(c) {\n  /*eslint no-bitwise:0*/\n  // broken sequence\n  if (c >= 0xD800 && c <= 0xDFFF) { return false; }\n  // never used\n  if (c >= 0xFDD0 && c <= 0xFDEF) { return false; }\n  if ((c & 0xFFFF) === 0xFFFF || (c & 0xFFFF) === 0xFFFE) { return false; }\n  // control codes\n  if (c >= 0x00 && c <= 0x08) { return false; }\n  if (c === 0x0B) { return false; }\n  if (c >= 0x0E && c <= 0x1F) { return false; }\n  if (c >= 0x7F && c <= 0x9F) { return false; }\n  // out of range\n  if (c > 0x10FFFF) { return false; }\n  return true;\n}\n\nfunction fromCodePoint(c) {\n  /*eslint no-bitwise:0*/\n  if (c > 0xffff) {\n    c -= 0x10000;\n    var surrogate1 = 0xd800 + (c >> 10),\n        surrogate2 = 0xdc00 + (c & 0x3ff);\n\n    return String.fromCharCode(surrogate1, surrogate2);\n  }\n  return String.fromCharCode(c);\n}\n\nvar NAMED_ENTITY_RE   = /&([a-z#][a-z0-9]{1,31});/gi;\nvar DIGITAL_ENTITY_TEST_RE = /^#((?:x[a-f0-9]{1,8}|[0-9]{1,8}))/i;\n\nfunction replaceEntityPattern(match, name) {\n  var code = 0;\n  var decoded = decodeEntity(name);\n\n  if (name !== decoded) {\n    return decoded;\n  } else if (name.charCodeAt(0) === 0x23/* # */ && DIGITAL_ENTITY_TEST_RE.test(name)) {\n    code = name[1].toLowerCase() === 'x' ?\n      parseInt(name.slice(2), 16)\n    :\n      parseInt(name.slice(1), 10);\n    if (isValidEntityCode(code)) {\n      return fromCodePoint(code);\n    }\n  }\n  return match;\n}\n\nfunction replaceEntities(str) {\n  if (str.indexOf('&') < 0) { return str; }\n\n  return str.replace(NAMED_ENTITY_RE, replaceEntityPattern);\n}\n\n////////////////////////////////////////////////////////////////////////////////\n\nvar HTML_ESCAPE_TEST_RE = /[&<>\"]/;\nvar HTML_ESCAPE_REPLACE_RE = /[&<>\"]/g;\nvar HTML_REPLACEMENTS = {\n  '&': '&amp;',\n  '<': '&lt;',\n  '>': '&gt;',\n  '\"': '&quot;'\n};\n\nfunction replaceUnsafeChar(ch) {\n  return HTML_REPLACEMENTS[ch];\n}\n\nfunction escapeHtml(str) {\n  if (HTML_ESCAPE_TEST_RE.test(str)) {\n    return str.replace(HTML_ESCAPE_REPLACE_RE, replaceUnsafeChar);\n  }\n  return str;\n}\n\nvar utils = /*#__PURE__*/Object.freeze({\n  isString: isString,\n  has: has,\n  assign: assign,\n  unescapeMd: unescapeMd,\n  isValidEntityCode: isValidEntityCode,\n  fromCodePoint: fromCodePoint,\n  replaceEntities: replaceEntities,\n  escapeHtml: escapeHtml\n});\n\n/**\n * Renderer rules cache\n */\n\nvar rules = {};\n\n/**\n * Blockquotes\n */\n\nrules.blockquote_open = function(/* tokens, idx, options, env */) {\n  return '<blockquote>\\n';\n};\n\nrules.blockquote_close = function(tokens, idx /*, options, env */) {\n  return '</blockquote>' + getBreak(tokens, idx);\n};\n\n/**\n * Code\n */\n\nrules.code = function(tokens, idx /*, options, env */) {\n  if (tokens[idx].block) {\n    return '<pre><code>' + escapeHtml(tokens[idx].content) + '</code></pre>' + getBreak(tokens, idx);\n  }\n  return '<code>' + escapeHtml(tokens[idx].content) + '</code>';\n};\n\n/**\n * Fenced code blocks\n */\n\nrules.fence = function(tokens, idx, options, env, instance) {\n  var token = tokens[idx];\n  var langClass = '';\n  var langPrefix = options.langPrefix;\n  var langName = '', fences, fenceName;\n  var highlighted;\n\n  if (token.params) {\n\n    //\n    // ```foo bar\n    //\n    // Try custom renderer \"foo\" first. That will simplify overwrite\n    // for diagrams, latex, and any other fenced block with custom look\n    //\n\n    fences = token.params.split(/\\s+/g);\n    fenceName = fences.join(' ');\n\n    if (has(instance.rules.fence_custom, fences[0])) {\n      return instance.rules.fence_custom[fences[0]](tokens, idx, options, env, instance);\n    }\n\n    langName = escapeHtml(replaceEntities(unescapeMd(fenceName)));\n    langClass = ' class=\"' + langPrefix + langName + '\"';\n  }\n\n  if (options.highlight) {\n    highlighted = options.highlight.apply(options.highlight, [ token.content ].concat(fences))\n      || escapeHtml(token.content);\n  } else {\n    highlighted = escapeHtml(token.content);\n  }\n\n  return '<pre><code' + langClass + '>'\n        + highlighted\n        + '</code></pre>'\n        + getBreak(tokens, idx);\n};\n\nrules.fence_custom = {};\n\n/**\n * Headings\n */\n\nrules.heading_open = function(tokens, idx /*, options, env */) {\n  return '<h' + tokens[idx].hLevel + '>';\n};\nrules.heading_close = function(tokens, idx /*, options, env */) {\n  return '</h' + tokens[idx].hLevel + '>\\n';\n};\n\n/**\n * Horizontal rules\n */\n\nrules.hr = function(tokens, idx, options /*, env */) {\n  return (options.xhtmlOut ? '<hr />' : '<hr>') + getBreak(tokens, idx);\n};\n\n/**\n * Bullets\n */\n\nrules.bullet_list_open = function(/* tokens, idx, options, env */) {\n  return '<ul>\\n';\n};\nrules.bullet_list_close = function(tokens, idx /*, options, env */) {\n  return '</ul>' + getBreak(tokens, idx);\n};\n\n/**\n * List items\n */\n\nrules.list_item_open = function(/* tokens, idx, options, env */) {\n  return '<li>';\n};\nrules.list_item_close = function(/* tokens, idx, options, env */) {\n  return '</li>\\n';\n};\n\n/**\n * Ordered list items\n */\n\nrules.ordered_list_open = function(tokens, idx /*, options, env */) {\n  var token = tokens[idx];\n  var order = token.order > 1 ? ' start=\"' + token.order + '\"' : '';\n  return '<ol' + order + '>\\n';\n};\nrules.ordered_list_close = function(tokens, idx /*, options, env */) {\n  return '</ol>' + getBreak(tokens, idx);\n};\n\n/**\n * Paragraphs\n */\n\nrules.paragraph_open = function(tokens, idx /*, options, env */) {\n  return tokens[idx].tight ? '' : '<p>';\n};\nrules.paragraph_close = function(tokens, idx /*, options, env */) {\n  var addBreak = !(tokens[idx].tight && idx && tokens[idx - 1].type === 'inline' && !tokens[idx - 1].content);\n  return (tokens[idx].tight ? '' : '</p>') + (addBreak ? getBreak(tokens, idx) : '');\n};\n\n/**\n * Links\n */\n\nrules.link_open = function(tokens, idx, options /* env */) {\n  var title = tokens[idx].title ? (' title=\"' + escapeHtml(replaceEntities(tokens[idx].title)) + '\"') : '';\n  var target = options.linkTarget ? (' target=\"' + options.linkTarget + '\"') : '';\n  return '<a href=\"' + escapeHtml(tokens[idx].href) + '\"' + title + target + '>';\n};\nrules.link_close = function(/* tokens, idx, options, env */) {\n  return '</a>';\n};\n\n/**\n * Images\n */\n\nrules.image = function(tokens, idx, options /*, env */) {\n  var src = ' src=\"' + escapeHtml(tokens[idx].src) + '\"';\n  var title = tokens[idx].title ? (' title=\"' + escapeHtml(replaceEntities(tokens[idx].title)) + '\"') : '';\n  var alt = ' alt=\"' + (tokens[idx].alt ? escapeHtml(replaceEntities(unescapeMd(tokens[idx].alt))) : '') + '\"';\n  var suffix = options.xhtmlOut ? ' /' : '';\n  return '<img' + src + alt + title + suffix + '>';\n};\n\n/**\n * Tables\n */\n\nrules.table_open = function(/* tokens, idx, options, env */) {\n  return '<table>\\n';\n};\nrules.table_close = function(/* tokens, idx, options, env */) {\n  return '</table>\\n';\n};\nrules.thead_open = function(/* tokens, idx, options, env */) {\n  return '<thead>\\n';\n};\nrules.thead_close = function(/* tokens, idx, options, env */) {\n  return '</thead>\\n';\n};\nrules.tbody_open = function(/* tokens, idx, options, env */) {\n  return '<tbody>\\n';\n};\nrules.tbody_close = function(/* tokens, idx, options, env */) {\n  return '</tbody>\\n';\n};\nrules.tr_open = function(/* tokens, idx, options, env */) {\n  return '<tr>';\n};\nrules.tr_close = function(/* tokens, idx, options, env */) {\n  return '</tr>\\n';\n};\nrules.th_open = function(tokens, idx /*, options, env */) {\n  var token = tokens[idx];\n  return '<th'\n    + (token.align ? ' style=\"text-align:' + token.align + '\"' : '')\n    + '>';\n};\nrules.th_close = function(/* tokens, idx, options, env */) {\n  return '</th>';\n};\nrules.td_open = function(tokens, idx /*, options, env */) {\n  var token = tokens[idx];\n  return '<td'\n    + (token.align ? ' style=\"text-align:' + token.align + '\"' : '')\n    + '>';\n};\nrules.td_close = function(/* tokens, idx, options, env */) {\n  return '</td>';\n};\n\n/**\n * Bold\n */\n\nrules.strong_open = function(/* tokens, idx, options, env */) {\n  return '<strong>';\n};\nrules.strong_close = function(/* tokens, idx, options, env */) {\n  return '</strong>';\n};\n\n/**\n * Italicize\n */\n\nrules.em_open = function(/* tokens, idx, options, env */) {\n  return '<em>';\n};\nrules.em_close = function(/* tokens, idx, options, env */) {\n  return '</em>';\n};\n\n/**\n * Strikethrough\n */\n\nrules.del_open = function(/* tokens, idx, options, env */) {\n  return '<del>';\n};\nrules.del_close = function(/* tokens, idx, options, env */) {\n  return '</del>';\n};\n\n/**\n * Insert\n */\n\nrules.ins_open = function(/* tokens, idx, options, env */) {\n  return '<ins>';\n};\nrules.ins_close = function(/* tokens, idx, options, env */) {\n  return '</ins>';\n};\n\n/**\n * Highlight\n */\n\nrules.mark_open = function(/* tokens, idx, options, env */) {\n  return '<mark>';\n};\nrules.mark_close = function(/* tokens, idx, options, env */) {\n  return '</mark>';\n};\n\n/**\n * Super- and sub-script\n */\n\nrules.sub = function(tokens, idx /*, options, env */) {\n  return '<sub>' + escapeHtml(tokens[idx].content) + '</sub>';\n};\nrules.sup = function(tokens, idx /*, options, env */) {\n  return '<sup>' + escapeHtml(tokens[idx].content) + '</sup>';\n};\n\n/**\n * Breaks\n */\n\nrules.hardbreak = function(tokens, idx, options /*, env */) {\n  return options.xhtmlOut ? '<br />\\n' : '<br>\\n';\n};\nrules.softbreak = function(tokens, idx, options /*, env */) {\n  return options.breaks ? (options.xhtmlOut ? '<br />\\n' : '<br>\\n') : '\\n';\n};\n\n/**\n * Text\n */\n\nrules.text = function(tokens, idx /*, options, env */) {\n  return escapeHtml(tokens[idx].content);\n};\n\n/**\n * Content\n */\n\nrules.htmlblock = function(tokens, idx /*, options, env */) {\n  return tokens[idx].content;\n};\nrules.htmltag = function(tokens, idx /*, options, env */) {\n  return tokens[idx].content;\n};\n\n/**\n * Abbreviations, initialism\n */\n\nrules.abbr_open = function(tokens, idx /*, options, env */) {\n  return '<abbr title=\"' + escapeHtml(replaceEntities(tokens[idx].title)) + '\">';\n};\nrules.abbr_close = function(/* tokens, idx, options, env */) {\n  return '</abbr>';\n};\n\n/**\n * Footnotes\n */\n\nrules.footnote_ref = function(tokens, idx) {\n  var n = Number(tokens[idx].id + 1).toString();\n  var id = 'fnref' + n;\n  if (tokens[idx].subId > 0) {\n    id += ':' + tokens[idx].subId;\n  }\n  return '<sup class=\"footnote-ref\"><a href=\"#fn' + n + '\" id=\"' + id + '\">[' + n + ']</a></sup>';\n};\nrules.footnote_block_open = function(tokens, idx, options) {\n  var hr = options.xhtmlOut\n    ? '<hr class=\"footnotes-sep\" />\\n'\n    : '<hr class=\"footnotes-sep\">\\n';\n  return hr + '<section class=\"footnotes\">\\n<ol class=\"footnotes-list\">\\n';\n};\nrules.footnote_block_close = function() {\n  return '</ol>\\n</section>\\n';\n};\nrules.footnote_open = function(tokens, idx) {\n  var id = Number(tokens[idx].id + 1).toString();\n  return '<li id=\"fn' + id + '\"  class=\"footnote-item\">';\n};\nrules.footnote_close = function() {\n  return '</li>\\n';\n};\nrules.footnote_anchor = function(tokens, idx) {\n  var n = Number(tokens[idx].id + 1).toString();\n  var id = 'fnref' + n;\n  if (tokens[idx].subId > 0) {\n    id += ':' + tokens[idx].subId;\n  }\n  return ' <a href=\"#' + id + '\" class=\"footnote-backref\">↩</a>';\n};\n\n/**\n * Definition lists\n */\n\nrules.dl_open = function() {\n  return '<dl>\\n';\n};\nrules.dt_open = function() {\n  return '<dt>';\n};\nrules.dd_open = function() {\n  return '<dd>';\n};\nrules.dl_close = function() {\n  return '</dl>\\n';\n};\nrules.dt_close = function() {\n  return '</dt>\\n';\n};\nrules.dd_close = function() {\n  return '</dd>\\n';\n};\n\n/**\n * Helper functions\n */\n\nfunction nextToken(tokens, idx) {\n  if (++idx >= tokens.length - 2) {\n    return idx;\n  }\n  if ((tokens[idx].type === 'paragraph_open' && tokens[idx].tight) &&\n      (tokens[idx + 1].type === 'inline' && tokens[idx + 1].content.length === 0) &&\n      (tokens[idx + 2].type === 'paragraph_close' && tokens[idx + 2].tight)) {\n    return nextToken(tokens, idx + 2);\n  }\n  return idx;\n}\n\n/**\n * Check to see if `\\n` is needed before the next token.\n *\n * @param  {Array} `tokens`\n * @param  {Number} `idx`\n * @return {String} Empty string or newline\n * @api private\n */\n\nvar getBreak = rules.getBreak = function getBreak(tokens, idx) {\n  idx = nextToken(tokens, idx);\n  if (idx < tokens.length && tokens[idx].type === 'list_item_close') {\n    return '';\n  }\n  return '\\n';\n};\n\n/**\n * Renderer class. Renders HTML and exposes `rules` to allow\n * local modifications.\n */\n\nfunction Renderer() {\n  this.rules = assign({}, rules);\n\n  // exported helper, for custom rules only\n  this.getBreak = rules.getBreak;\n}\n\n/**\n * Render a string of inline HTML with the given `tokens` and\n * `options`.\n *\n * @param  {Array} `tokens`\n * @param  {Object} `options`\n * @param  {Object} `env`\n * @return {String}\n * @api public\n */\n\nRenderer.prototype.renderInline = function (tokens, options, env) {\n  var _rules = this.rules;\n  var len = tokens.length, i = 0;\n  var result = '';\n\n  while (len--) {\n    result += _rules[tokens[i].type](tokens, i++, options, env, this);\n  }\n\n  return result;\n};\n\n/**\n * Render a string of HTML with the given `tokens` and\n * `options`.\n *\n * @param  {Array} `tokens`\n * @param  {Object} `options`\n * @param  {Object} `env`\n * @return {String}\n * @api public\n */\n\nRenderer.prototype.render = function (tokens, options, env) {\n  var _rules = this.rules;\n  var len = tokens.length, i = -1;\n  var result = '';\n\n  while (++i < len) {\n    if (tokens[i].type === 'inline') {\n      result += this.renderInline(tokens[i].children, options, env);\n    } else {\n      result += _rules[tokens[i].type](tokens, i, options, env, this);\n    }\n  }\n  return result;\n};\n\n/**\n * Ruler is a helper class for building responsibility chains from\n * parse rules. It allows:\n *\n *   - easy stack rules chains\n *   - getting main chain and named chains content (as arrays of functions)\n *\n * Helper methods, should not be used directly.\n * @api private\n */\n\nfunction Ruler() {\n  // List of added rules. Each element is:\n  //\n  // { name: XXX,\n  //   enabled: Boolean,\n  //   fn: Function(),\n  //   alt: [ name2, name3 ] }\n  //\n  this.__rules__ = [];\n\n  // Cached rule chains.\n  //\n  // First level - chain name, '' for default.\n  // Second level - digital anchor for fast filtering by charcodes.\n  //\n  this.__cache__ = null;\n}\n\n/**\n * Find the index of a rule by `name`.\n *\n * @param  {String} `name`\n * @return {Number} Index of the given `name`\n * @api private\n */\n\nRuler.prototype.__find__ = function (name) {\n  var len = this.__rules__.length;\n  var i = -1;\n\n  while (len--) {\n    if (this.__rules__[++i].name === name) {\n      return i;\n    }\n  }\n  return -1;\n};\n\n/**\n * Build the rules lookup cache\n *\n * @api private\n */\n\nRuler.prototype.__compile__ = function () {\n  var self = this;\n  var chains = [ '' ];\n\n  // collect unique names\n  self.__rules__.forEach(function (rule) {\n    if (!rule.enabled) {\n      return;\n    }\n\n    rule.alt.forEach(function (altName) {\n      if (chains.indexOf(altName) < 0) {\n        chains.push(altName);\n      }\n    });\n  });\n\n  self.__cache__ = {};\n\n  chains.forEach(function (chain) {\n    self.__cache__[chain] = [];\n    self.__rules__.forEach(function (rule) {\n      if (!rule.enabled) {\n        return;\n      }\n\n      if (chain && rule.alt.indexOf(chain) < 0) {\n        return;\n      }\n      self.__cache__[chain].push(rule.fn);\n    });\n  });\n};\n\n/**\n * Ruler public methods\n * ------------------------------------------------\n */\n\n/**\n * Replace rule function\n *\n * @param  {String} `name` Rule name\n * @param  {Function `fn`\n * @param  {Object} `options`\n * @api private\n */\n\nRuler.prototype.at = function (name, fn, options) {\n  var idx = this.__find__(name);\n  var opt = options || {};\n\n  if (idx === -1) {\n    throw new Error('Parser rule not found: ' + name);\n  }\n\n  this.__rules__[idx].fn = fn;\n  this.__rules__[idx].alt = opt.alt || [];\n  this.__cache__ = null;\n};\n\n/**\n * Add a rule to the chain before given the `ruleName`.\n *\n * @param  {String}   `beforeName`\n * @param  {String}   `ruleName`\n * @param  {Function} `fn`\n * @param  {Object}   `options`\n * @api private\n */\n\nRuler.prototype.before = function (beforeName, ruleName, fn, options) {\n  var idx = this.__find__(beforeName);\n  var opt = options || {};\n\n  if (idx === -1) {\n    throw new Error('Parser rule not found: ' + beforeName);\n  }\n\n  this.__rules__.splice(idx, 0, {\n    name: ruleName,\n    enabled: true,\n    fn: fn,\n    alt: opt.alt || []\n  });\n\n  this.__cache__ = null;\n};\n\n/**\n * Add a rule to the chain after the given `ruleName`.\n *\n * @param  {String}   `afterName`\n * @param  {String}   `ruleName`\n * @param  {Function} `fn`\n * @param  {Object}   `options`\n * @api private\n */\n\nRuler.prototype.after = function (afterName, ruleName, fn, options) {\n  var idx = this.__find__(afterName);\n  var opt = options || {};\n\n  if (idx === -1) {\n    throw new Error('Parser rule not found: ' + afterName);\n  }\n\n  this.__rules__.splice(idx + 1, 0, {\n    name: ruleName,\n    enabled: true,\n    fn: fn,\n    alt: opt.alt || []\n  });\n\n  this.__cache__ = null;\n};\n\n/**\n * Add a rule to the end of chain.\n *\n * @param  {String}   `ruleName`\n * @param  {Function} `fn`\n * @param  {Object}   `options`\n * @return {String}\n */\n\nRuler.prototype.push = function (ruleName, fn, options) {\n  var opt = options || {};\n\n  this.__rules__.push({\n    name: ruleName,\n    enabled: true,\n    fn: fn,\n    alt: opt.alt || []\n  });\n\n  this.__cache__ = null;\n};\n\n/**\n * Enable a rule or list of rules.\n *\n * @param  {String|Array} `list` Name or array of rule names to enable\n * @param  {Boolean} `strict` If `true`, all non listed rules will be disabled.\n * @api private\n */\n\nRuler.prototype.enable = function (list, strict) {\n  list = !Array.isArray(list)\n    ? [ list ]\n    : list;\n\n  // In strict mode disable all existing rules first\n  if (strict) {\n    this.__rules__.forEach(function (rule) {\n      rule.enabled = false;\n    });\n  }\n\n  // Search by name and enable\n  list.forEach(function (name) {\n    var idx = this.__find__(name);\n    if (idx < 0) {\n      throw new Error('Rules manager: invalid rule name ' + name);\n    }\n    this.__rules__[idx].enabled = true;\n  }, this);\n\n  this.__cache__ = null;\n};\n\n\n/**\n * Disable a rule or list of rules.\n *\n * @param  {String|Array} `list` Name or array of rule names to disable\n * @api private\n */\n\nRuler.prototype.disable = function (list) {\n  list = !Array.isArray(list)\n    ? [ list ]\n    : list;\n\n  // Search by name and disable\n  list.forEach(function (name) {\n    var idx = this.__find__(name);\n    if (idx < 0) {\n      throw new Error('Rules manager: invalid rule name ' + name);\n    }\n    this.__rules__[idx].enabled = false;\n  }, this);\n\n  this.__cache__ = null;\n};\n\n/**\n * Get a rules list as an array of functions.\n *\n * @param  {String} `chainName`\n * @return {Object}\n * @api private\n */\n\nRuler.prototype.getRules = function (chainName) {\n  if (this.__cache__ === null) {\n    this.__compile__();\n  }\n  return this.__cache__[chainName] || [];\n};\n\nfunction block(state) {\n\n  if (state.inlineMode) {\n    state.tokens.push({\n      type: 'inline',\n      content: state.src.replace(/\\n/g, ' ').trim(),\n      level: 0,\n      lines: [ 0, 1 ],\n      children: []\n    });\n\n  } else {\n    state.block.parse(state.src, state.options, state.env, state.tokens);\n  }\n}\n\n// Inline parser state\n\nfunction StateInline(src, parserInline, options, env, outTokens) {\n  this.src = src;\n  this.env = env;\n  this.options = options;\n  this.parser = parserInline;\n  this.tokens = outTokens;\n  this.pos = 0;\n  this.posMax = this.src.length;\n  this.level = 0;\n  this.pending = '';\n  this.pendingLevel = 0;\n\n  this.cache = [];        // Stores { start: end } pairs. Useful for backtrack\n                          // optimization of pairs parse (emphasis, strikes).\n\n  // Link parser state vars\n\n  this.isInLabel = false; // Set true when seek link label - we should disable\n                          // \"paired\" rules (emphasis, strikes) to not skip\n                          // tailing `]`\n\n  this.linkLevel = 0;     // Increment for each nesting link. Used to prevent\n                          // nesting in definitions\n\n  this.linkContent = '';  // Temporary storage for link url\n\n  this.labelUnmatchedScopes = 0; // Track unpaired `[` for link labels\n                                 // (backtrack optimization)\n}\n\n// Flush pending text\n//\nStateInline.prototype.pushPending = function () {\n  this.tokens.push({\n    type: 'text',\n    content: this.pending,\n    level: this.pendingLevel\n  });\n  this.pending = '';\n};\n\n// Push new token to \"stream\".\n// If pending text exists - flush it as text token\n//\nStateInline.prototype.push = function (token) {\n  if (this.pending) {\n    this.pushPending();\n  }\n\n  this.tokens.push(token);\n  this.pendingLevel = this.level;\n};\n\n// Store value to cache.\n// !!! Implementation has parser-specific optimizations\n// !!! keys MUST be integer, >= 0; values MUST be integer, > 0\n//\nStateInline.prototype.cacheSet = function (key, val) {\n  for (var i = this.cache.length; i <= key; i++) {\n    this.cache.push(0);\n  }\n\n  this.cache[key] = val;\n};\n\n// Get cache value\n//\nStateInline.prototype.cacheGet = function (key) {\n  return key < this.cache.length ? this.cache[key] : 0;\n};\n\n/**\n * Parse link labels\n *\n * This function assumes that first character (`[`) already matches;\n * returns the end of the label.\n *\n * @param  {Object} state\n * @param  {Number} start\n * @api private\n */\n\nfunction parseLinkLabel(state, start) {\n  var level, found, marker,\n      labelEnd = -1,\n      max = state.posMax,\n      oldPos = state.pos,\n      oldFlag = state.isInLabel;\n\n  if (state.isInLabel) { return -1; }\n\n  if (state.labelUnmatchedScopes) {\n    state.labelUnmatchedScopes--;\n    return -1;\n  }\n\n  state.pos = start + 1;\n  state.isInLabel = true;\n  level = 1;\n\n  while (state.pos < max) {\n    marker = state.src.charCodeAt(state.pos);\n    if (marker === 0x5B /* [ */) {\n      level++;\n    } else if (marker === 0x5D /* ] */) {\n      level--;\n      if (level === 0) {\n        found = true;\n        break;\n      }\n    }\n\n    state.parser.skipToken(state);\n  }\n\n  if (found) {\n    labelEnd = state.pos;\n    state.labelUnmatchedScopes = 0;\n  } else {\n    state.labelUnmatchedScopes = level - 1;\n  }\n\n  // restore old state\n  state.pos = oldPos;\n  state.isInLabel = oldFlag;\n\n  return labelEnd;\n}\n\n// Parse abbreviation definitions, i.e. `*[abbr]: description`\n\n\nfunction parseAbbr(str, parserInline, options, env) {\n  var state, labelEnd, pos, max, label, title;\n\n  if (str.charCodeAt(0) !== 0x2A/* * */) { return -1; }\n  if (str.charCodeAt(1) !== 0x5B/* [ */) { return -1; }\n\n  if (str.indexOf(']:') === -1) { return -1; }\n\n  state = new StateInline(str, parserInline, options, env, []);\n  labelEnd = parseLinkLabel(state, 1);\n\n  if (labelEnd < 0 || str.charCodeAt(labelEnd + 1) !== 0x3A/* : */) { return -1; }\n\n  max = state.posMax;\n\n  // abbr title is always one line, so looking for ending \"\\n\" here\n  for (pos = labelEnd + 2; pos < max; pos++) {\n    if (state.src.charCodeAt(pos) === 0x0A) { break; }\n  }\n\n  label = str.slice(2, labelEnd);\n  title = str.slice(labelEnd + 2, pos).trim();\n  if (title.length === 0) { return -1; }\n  if (!env.abbreviations) { env.abbreviations = {}; }\n  // prepend ':' to avoid conflict with Object.prototype members\n  if (typeof env.abbreviations[':' + label] === 'undefined') {\n    env.abbreviations[':' + label] = title;\n  }\n\n  return pos;\n}\n\nfunction abbr(state) {\n  var tokens = state.tokens, i, l, content, pos;\n\n  if (state.inlineMode) {\n    return;\n  }\n\n  // Parse inlines\n  for (i = 1, l = tokens.length - 1; i < l; i++) {\n    if (tokens[i - 1].type === 'paragraph_open' &&\n        tokens[i].type === 'inline' &&\n        tokens[i + 1].type === 'paragraph_close') {\n\n      content = tokens[i].content;\n      while (content.length) {\n        pos = parseAbbr(content, state.inline, state.options, state.env);\n        if (pos < 0) { break; }\n        content = content.slice(pos).trim();\n      }\n\n      tokens[i].content = content;\n      if (!content.length) {\n        tokens[i - 1].tight = true;\n        tokens[i + 1].tight = true;\n      }\n    }\n  }\n}\n\nfunction normalizeLink(url) {\n  var normalized = replaceEntities(url);\n  // We shouldn't care about the result of malformed URIs,\n  // and should not throw an exception.\n  try {\n    normalized = decodeURI(normalized);\n  } catch (err) {}\n  return encodeURI(normalized);\n}\n\n/**\n * Parse link destination\n *\n *   - on success it returns a string and updates state.pos;\n *   - on failure it returns null\n *\n * @param  {Object} state\n * @param  {Number} pos\n * @api private\n */\n\nfunction parseLinkDestination(state, pos) {\n  var code, level, link,\n      start = pos,\n      max = state.posMax;\n\n  if (state.src.charCodeAt(pos) === 0x3C /* < */) {\n    pos++;\n    while (pos < max) {\n      code = state.src.charCodeAt(pos);\n      if (code === 0x0A /* \\n */) { return false; }\n      if (code === 0x3E /* > */) {\n        link = normalizeLink(unescapeMd(state.src.slice(start + 1, pos)));\n        if (!state.parser.validateLink(link)) { return false; }\n        state.pos = pos + 1;\n        state.linkContent = link;\n        return true;\n      }\n      if (code === 0x5C /* \\ */ && pos + 1 < max) {\n        pos += 2;\n        continue;\n      }\n\n      pos++;\n    }\n\n    // no closing '>'\n    return false;\n  }\n\n  // this should be ... } else { ... branch\n\n  level = 0;\n  while (pos < max) {\n    code = state.src.charCodeAt(pos);\n\n    if (code === 0x20) { break; }\n\n    // ascii control chars\n    if (code < 0x20 || code === 0x7F) { break; }\n\n    if (code === 0x5C /* \\ */ && pos + 1 < max) {\n      pos += 2;\n      continue;\n    }\n\n    if (code === 0x28 /* ( */) {\n      level++;\n      if (level > 1) { break; }\n    }\n\n    if (code === 0x29 /* ) */) {\n      level--;\n      if (level < 0) { break; }\n    }\n\n    pos++;\n  }\n\n  if (start === pos) { return false; }\n\n  link = unescapeMd(state.src.slice(start, pos));\n  if (!state.parser.validateLink(link)) { return false; }\n\n  state.linkContent = link;\n  state.pos = pos;\n  return true;\n}\n\n/**\n * Parse link title\n *\n *   - on success it returns a string and updates state.pos;\n *   - on failure it returns null\n *\n * @param  {Object} state\n * @param  {Number} pos\n * @api private\n */\n\nfunction parseLinkTitle(state, pos) {\n  var code,\n      start = pos,\n      max = state.posMax,\n      marker = state.src.charCodeAt(pos);\n\n  if (marker !== 0x22 /* \" */ && marker !== 0x27 /* ' */ && marker !== 0x28 /* ( */) { return false; }\n\n  pos++;\n\n  // if opening marker is \"(\", switch it to closing marker \")\"\n  if (marker === 0x28) { marker = 0x29; }\n\n  while (pos < max) {\n    code = state.src.charCodeAt(pos);\n    if (code === marker) {\n      state.pos = pos + 1;\n      state.linkContent = unescapeMd(state.src.slice(start + 1, pos));\n      return true;\n    }\n    if (code === 0x5C /* \\ */ && pos + 1 < max) {\n      pos += 2;\n      continue;\n    }\n\n    pos++;\n  }\n\n  return false;\n}\n\nfunction normalizeReference(str) {\n  // use .toUpperCase() instead of .toLowerCase()\n  // here to avoid a conflict with Object.prototype\n  // members (most notably, `__proto__`)\n  return str.trim().replace(/\\s+/g, ' ').toUpperCase();\n}\n\nfunction parseReference(str, parser, options, env) {\n  var state, labelEnd, pos, max, code, start, href, title, label;\n\n  if (str.charCodeAt(0) !== 0x5B/* [ */) { return -1; }\n\n  if (str.indexOf(']:') === -1) { return -1; }\n\n  state = new StateInline(str, parser, options, env, []);\n  labelEnd = parseLinkLabel(state, 0);\n\n  if (labelEnd < 0 || str.charCodeAt(labelEnd + 1) !== 0x3A/* : */) { return -1; }\n\n  max = state.posMax;\n\n  // [label]:   destination   'title'\n  //         ^^^ skip optional whitespace here\n  for (pos = labelEnd + 2; pos < max; pos++) {\n    code = state.src.charCodeAt(pos);\n    if (code !== 0x20 && code !== 0x0A) { break; }\n  }\n\n  // [label]:   destination   'title'\n  //            ^^^^^^^^^^^ parse this\n  if (!parseLinkDestination(state, pos)) { return -1; }\n  href = state.linkContent;\n  pos = state.pos;\n\n  // [label]:   destination   'title'\n  //                       ^^^ skipping those spaces\n  start = pos;\n  for (pos = pos + 1; pos < max; pos++) {\n    code = state.src.charCodeAt(pos);\n    if (code !== 0x20 && code !== 0x0A) { break; }\n  }\n\n  // [label]:   destination   'title'\n  //                          ^^^^^^^ parse this\n  if (pos < max && start !== pos && parseLinkTitle(state, pos)) {\n    title = state.linkContent;\n    pos = state.pos;\n  } else {\n    title = '';\n    pos = start;\n  }\n\n  // ensure that the end of the line is empty\n  while (pos < max && state.src.charCodeAt(pos) === 0x20/* space */) { pos++; }\n  if (pos < max && state.src.charCodeAt(pos) !== 0x0A) { return -1; }\n\n  label = normalizeReference(str.slice(1, labelEnd));\n  if (typeof env.references[label] === 'undefined') {\n    env.references[label] = { title: title, href: href };\n  }\n\n  return pos;\n}\n\n\nfunction references(state) {\n  var tokens = state.tokens, i, l, content, pos;\n\n  state.env.references = state.env.references || {};\n\n  if (state.inlineMode) {\n    return;\n  }\n\n  // Scan definitions in paragraph inlines\n  for (i = 1, l = tokens.length - 1; i < l; i++) {\n    if (tokens[i].type === 'inline' &&\n        tokens[i - 1].type === 'paragraph_open' &&\n        tokens[i + 1].type === 'paragraph_close') {\n\n      content = tokens[i].content;\n      while (content.length) {\n        pos = parseReference(content, state.inline, state.options, state.env);\n        if (pos < 0) { break; }\n        content = content.slice(pos).trim();\n      }\n\n      tokens[i].content = content;\n      if (!content.length) {\n        tokens[i - 1].tight = true;\n        tokens[i + 1].tight = true;\n      }\n    }\n  }\n}\n\nfunction inline(state) {\n  var tokens = state.tokens, tok, i, l;\n\n  // Parse inlines\n  for (i = 0, l = tokens.length; i < l; i++) {\n    tok = tokens[i];\n    if (tok.type === 'inline') {\n      state.inline.parse(tok.content, state.options, state.env, tok.children);\n    }\n  }\n}\n\nfunction footnote_block(state) {\n  var i, l, j, t, lastParagraph, list, tokens, current, currentLabel,\n      level = 0,\n      insideRef = false,\n      refTokens = {};\n\n  if (!state.env.footnotes) { return; }\n\n  state.tokens = state.tokens.filter(function(tok) {\n    if (tok.type === 'footnote_reference_open') {\n      insideRef = true;\n      current = [];\n      currentLabel = tok.label;\n      return false;\n    }\n    if (tok.type === 'footnote_reference_close') {\n      insideRef = false;\n      // prepend ':' to avoid conflict with Object.prototype members\n      refTokens[':' + currentLabel] = current;\n      return false;\n    }\n    if (insideRef) { current.push(tok); }\n    return !insideRef;\n  });\n\n  if (!state.env.footnotes.list) { return; }\n  list = state.env.footnotes.list;\n\n  state.tokens.push({\n    type: 'footnote_block_open',\n    level: level++\n  });\n  for (i = 0, l = list.length; i < l; i++) {\n    state.tokens.push({\n      type: 'footnote_open',\n      id: i,\n      level: level++\n    });\n\n    if (list[i].tokens) {\n      tokens = [];\n      tokens.push({\n        type: 'paragraph_open',\n        tight: false,\n        level: level++\n      });\n      tokens.push({\n        type: 'inline',\n        content: '',\n        level: level,\n        children: list[i].tokens\n      });\n      tokens.push({\n        type: 'paragraph_close',\n        tight: false,\n        level: --level\n      });\n    } else if (list[i].label) {\n      tokens = refTokens[':' + list[i].label];\n    }\n\n    state.tokens = state.tokens.concat(tokens);\n    if (state.tokens[state.tokens.length - 1].type === 'paragraph_close') {\n      lastParagraph = state.tokens.pop();\n    } else {\n      lastParagraph = null;\n    }\n\n    t = list[i].count > 0 ? list[i].count : 1;\n    for (j = 0; j < t; j++) {\n      state.tokens.push({\n        type: 'footnote_anchor',\n        id: i,\n        subId: j,\n        level: level\n      });\n    }\n\n    if (lastParagraph) {\n      state.tokens.push(lastParagraph);\n    }\n\n    state.tokens.push({\n      type: 'footnote_close',\n      level: --level\n    });\n  }\n  state.tokens.push({\n    type: 'footnote_block_close',\n    level: --level\n  });\n}\n\n// Enclose abbreviations in <abbr> tags\n//\n\nvar PUNCT_CHARS = ' \\n()[]\\'\".,!?-';\n\n\n// from Google closure library\n// http://closure-library.googlecode.com/git-history/docs/local_closure_goog_string_string.js.source.html#line1021\nfunction regEscape(s) {\n  return s.replace(/([-()\\[\\]{}+?*.$\\^|,:#<!\\\\])/g, '\\\\$1');\n}\n\n\nfunction abbr2(state) {\n  var i, j, l, tokens, token, text, nodes, pos, level, reg, m, regText,\n      blockTokens = state.tokens;\n\n  if (!state.env.abbreviations) { return; }\n  if (!state.env.abbrRegExp) {\n    regText = '(^|[' + PUNCT_CHARS.split('').map(regEscape).join('') + '])'\n            + '(' + Object.keys(state.env.abbreviations).map(function (x) {\n                      return x.substr(1);\n                    }).sort(function (a, b) {\n                      return b.length - a.length;\n                    }).map(regEscape).join('|') + ')'\n            + '($|[' + PUNCT_CHARS.split('').map(regEscape).join('') + '])';\n    state.env.abbrRegExp = new RegExp(regText, 'g');\n  }\n  reg = state.env.abbrRegExp;\n\n  for (j = 0, l = blockTokens.length; j < l; j++) {\n    if (blockTokens[j].type !== 'inline') { continue; }\n    tokens = blockTokens[j].children;\n\n    // We scan from the end, to keep position when new tags added.\n    for (i = tokens.length - 1; i >= 0; i--) {\n      token = tokens[i];\n      if (token.type !== 'text') { continue; }\n\n      pos = 0;\n      text = token.content;\n      reg.lastIndex = 0;\n      level = token.level;\n      nodes = [];\n\n      while ((m = reg.exec(text))) {\n        if (reg.lastIndex > pos) {\n          nodes.push({\n            type: 'text',\n            content: text.slice(pos, m.index + m[1].length),\n            level: level\n          });\n        }\n\n        nodes.push({\n          type: 'abbr_open',\n          title: state.env.abbreviations[':' + m[2]],\n          level: level++\n        });\n        nodes.push({\n          type: 'text',\n          content: m[2],\n          level: level\n        });\n        nodes.push({\n          type: 'abbr_close',\n          level: --level\n        });\n        pos = reg.lastIndex - m[3].length;\n      }\n\n      if (!nodes.length) { continue; }\n\n      if (pos < text.length) {\n        nodes.push({\n          type: 'text',\n          content: text.slice(pos),\n          level: level\n        });\n      }\n\n      // replace current node\n      blockTokens[j].children = tokens = [].concat(tokens.slice(0, i), nodes, tokens.slice(i + 1));\n    }\n  }\n}\n\n// Simple typographical replacements\n//\n// TODO:\n// - fractionals 1/2, 1/4, 3/4 -> ½, ¼, ¾\n// - miltiplication 2 x 4 -> 2 × 4\n\nvar RARE_RE = /\\+-|\\.\\.|\\?\\?\\?\\?|!!!!|,,|--/;\n\nvar SCOPED_ABBR_RE = /\\((c|tm|r|p)\\)/ig;\nvar SCOPED_ABBR = {\n  'c': '©',\n  'r': '®',\n  'p': '§',\n  'tm': '™'\n};\n\nfunction replaceScopedAbbr(str) {\n  if (str.indexOf('(') < 0) { return str; }\n\n  return str.replace(SCOPED_ABBR_RE, function(match, name) {\n    return SCOPED_ABBR[name.toLowerCase()];\n  });\n}\n\n\nfunction replace(state) {\n  var i, token, text, inlineTokens, blkIdx;\n\n  if (!state.options.typographer) { return; }\n\n  for (blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) {\n\n    if (state.tokens[blkIdx].type !== 'inline') { continue; }\n\n    inlineTokens = state.tokens[blkIdx].children;\n\n    for (i = inlineTokens.length - 1; i >= 0; i--) {\n      token = inlineTokens[i];\n      if (token.type === 'text') {\n        text = token.content;\n\n        text = replaceScopedAbbr(text);\n\n        if (RARE_RE.test(text)) {\n          text = text\n            .replace(/\\+-/g, '±')\n            // .., ..., ....... -> …\n            // but ?..... & !..... -> ?.. & !..\n            .replace(/\\.{2,}/g, '…').replace(/([?!])…/g, '$1..')\n            .replace(/([?!]){4,}/g, '$1$1$1').replace(/,{2,}/g, ',')\n            // em-dash\n            .replace(/(^|[^-])---([^-]|$)/mg, '$1\\u2014$2')\n            // en-dash\n            .replace(/(^|\\s)--(\\s|$)/mg, '$1\\u2013$2')\n            .replace(/(^|[^-\\s])--([^-\\s]|$)/mg, '$1\\u2013$2');\n        }\n\n        token.content = text;\n      }\n    }\n  }\n}\n\n// Convert straight quotation marks to typographic ones\n//\n\nvar QUOTE_TEST_RE = /['\"]/;\nvar QUOTE_RE = /['\"]/g;\nvar PUNCT_RE = /[-\\s()\\[\\]]/;\nvar APOSTROPHE = '’';\n\n// This function returns true if the character at `pos`\n// could be inside a word.\nfunction isLetter(str, pos) {\n  if (pos < 0 || pos >= str.length) { return false; }\n  return !PUNCT_RE.test(str[pos]);\n}\n\n\nfunction replaceAt(str, index, ch) {\n  return str.substr(0, index) + ch + str.substr(index + 1);\n}\n\n\nfunction smartquotes(state) {\n  /*eslint max-depth:0*/\n  var i, token, text, t, pos, max, thisLevel, lastSpace, nextSpace, item,\n      canOpen, canClose, j, isSingle, blkIdx, tokens,\n      stack;\n\n  if (!state.options.typographer) { return; }\n\n  stack = [];\n\n  for (blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) {\n\n    if (state.tokens[blkIdx].type !== 'inline') { continue; }\n\n    tokens = state.tokens[blkIdx].children;\n    stack.length = 0;\n\n    for (i = 0; i < tokens.length; i++) {\n      token = tokens[i];\n\n      if (token.type !== 'text' || QUOTE_TEST_RE.test(token.text)) { continue; }\n\n      thisLevel = tokens[i].level;\n\n      for (j = stack.length - 1; j >= 0; j--) {\n        if (stack[j].level <= thisLevel) { break; }\n      }\n      stack.length = j + 1;\n\n      text = token.content;\n      pos = 0;\n      max = text.length;\n\n      /*eslint no-labels:0,block-scoped-var:0*/\n      OUTER:\n      while (pos < max) {\n        QUOTE_RE.lastIndex = pos;\n        t = QUOTE_RE.exec(text);\n        if (!t) { break; }\n\n        lastSpace = !isLetter(text, t.index - 1);\n        pos = t.index + 1;\n        isSingle = (t[0] === \"'\");\n        nextSpace = !isLetter(text, pos);\n\n        if (!nextSpace && !lastSpace) {\n          // middle of word\n          if (isSingle) {\n            token.content = replaceAt(token.content, t.index, APOSTROPHE);\n          }\n          continue;\n        }\n\n        canOpen = !nextSpace;\n        canClose = !lastSpace;\n\n        if (canClose) {\n          // this could be a closing quote, rewind the stack to get a match\n          for (j = stack.length - 1; j >= 0; j--) {\n            item = stack[j];\n            if (stack[j].level < thisLevel) { break; }\n            if (item.single === isSingle && stack[j].level === thisLevel) {\n              item = stack[j];\n              if (isSingle) {\n                tokens[item.token].content = replaceAt(tokens[item.token].content, item.pos, state.options.quotes[2]);\n                token.content = replaceAt(token.content, t.index, state.options.quotes[3]);\n              } else {\n                tokens[item.token].content = replaceAt(tokens[item.token].content, item.pos, state.options.quotes[0]);\n                token.content = replaceAt(token.content, t.index, state.options.quotes[1]);\n              }\n              stack.length = j;\n              continue OUTER;\n            }\n          }\n        }\n\n        if (canOpen) {\n          stack.push({\n            token: i,\n            pos: t.index,\n            single: isSingle,\n            level: thisLevel\n          });\n        } else if (canClose && isSingle) {\n          token.content = replaceAt(token.content, t.index, APOSTROPHE);\n        }\n      }\n    }\n  }\n}\n\n/**\n * Core parser `rules`\n */\n\nvar _rules = [\n  [ 'block',          block          ],\n  [ 'abbr',           abbr           ],\n  [ 'references',     references     ],\n  [ 'inline',         inline         ],\n  [ 'footnote_tail',  footnote_block  ],\n  [ 'abbr2',          abbr2          ],\n  [ 'replacements',   replace   ],\n  [ 'smartquotes',    smartquotes    ],\n];\n\n/**\n * Class for top level (`core`) parser rules\n *\n * @api private\n */\n\nfunction Core() {\n  this.options = {};\n  this.ruler = new Ruler();\n  for (var i = 0; i < _rules.length; i++) {\n    this.ruler.push(_rules[i][0], _rules[i][1]);\n  }\n}\n\n/**\n * Process rules with the given `state`\n *\n * @param  {Object} `state`\n * @api private\n */\n\nCore.prototype.process = function (state) {\n  var i, l, rules;\n  rules = this.ruler.getRules('');\n  for (i = 0, l = rules.length; i < l; i++) {\n    rules[i](state);\n  }\n};\n\n// Parser state class\n\nfunction StateBlock(src, parser, options, env, tokens) {\n  var ch, s, start, pos, len, indent, indent_found;\n\n  this.src = src;\n\n  // Shortcuts to simplify nested calls\n  this.parser = parser;\n\n  this.options = options;\n\n  this.env = env;\n\n  //\n  // Internal state vartiables\n  //\n\n  this.tokens = tokens;\n\n  this.bMarks = [];  // line begin offsets for fast jumps\n  this.eMarks = [];  // line end offsets for fast jumps\n  this.tShift = [];  // indent for each line\n\n  // block parser variables\n  this.blkIndent  = 0; // required block content indent\n                       // (for example, if we are in list)\n  this.line       = 0; // line index in src\n  this.lineMax    = 0; // lines count\n  this.tight      = false;  // loose/tight mode for lists\n  this.parentType = 'root'; // if `list`, block parser stops on two newlines\n  this.ddIndent   = -1; // indent of the current dd block (-1 if there isn't any)\n\n  this.level = 0;\n\n  // renderer\n  this.result = '';\n\n  // Create caches\n  // Generate markers.\n  s = this.src;\n  indent = 0;\n  indent_found = false;\n\n  for (start = pos = indent = 0, len = s.length; pos < len; pos++) {\n    ch = s.charCodeAt(pos);\n\n    if (!indent_found) {\n      if (ch === 0x20/* space */) {\n        indent++;\n        continue;\n      } else {\n        indent_found = true;\n      }\n    }\n\n    if (ch === 0x0A || pos === len - 1) {\n      if (ch !== 0x0A) { pos++; }\n      this.bMarks.push(start);\n      this.eMarks.push(pos);\n      this.tShift.push(indent);\n\n      indent_found = false;\n      indent = 0;\n      start = pos + 1;\n    }\n  }\n\n  // Push fake entry to simplify cache bounds checks\n  this.bMarks.push(s.length);\n  this.eMarks.push(s.length);\n  this.tShift.push(0);\n\n  this.lineMax = this.bMarks.length - 1; // don't count last fake line\n}\n\nStateBlock.prototype.isEmpty = function isEmpty(line) {\n  return this.bMarks[line] + this.tShift[line] >= this.eMarks[line];\n};\n\nStateBlock.prototype.skipEmptyLines = function skipEmptyLines(from) {\n  for (var max = this.lineMax; from < max; from++) {\n    if (this.bMarks[from] + this.tShift[from] < this.eMarks[from]) {\n      break;\n    }\n  }\n  return from;\n};\n\n// Skip spaces from given position.\nStateBlock.prototype.skipSpaces = function skipSpaces(pos) {\n  for (var max = this.src.length; pos < max; pos++) {\n    if (this.src.charCodeAt(pos) !== 0x20/* space */) { break; }\n  }\n  return pos;\n};\n\n// Skip char codes from given position\nStateBlock.prototype.skipChars = function skipChars(pos, code) {\n  for (var max = this.src.length; pos < max; pos++) {\n    if (this.src.charCodeAt(pos) !== code) { break; }\n  }\n  return pos;\n};\n\n// Skip char codes reverse from given position - 1\nStateBlock.prototype.skipCharsBack = function skipCharsBack(pos, code, min) {\n  if (pos <= min) { return pos; }\n\n  while (pos > min) {\n    if (code !== this.src.charCodeAt(--pos)) { return pos + 1; }\n  }\n  return pos;\n};\n\n// cut lines range from source.\nStateBlock.prototype.getLines = function getLines(begin, end, indent, keepLastLF) {\n  var i, first, last, queue, shift,\n      line = begin;\n\n  if (begin >= end) {\n    return '';\n  }\n\n  // Opt: don't use push queue for single line;\n  if (line + 1 === end) {\n    first = this.bMarks[line] + Math.min(this.tShift[line], indent);\n    last = keepLastLF ? this.eMarks[line] + 1 : this.eMarks[line];\n    return this.src.slice(first, last);\n  }\n\n  queue = new Array(end - begin);\n\n  for (i = 0; line < end; line++, i++) {\n    shift = this.tShift[line];\n    if (shift > indent) { shift = indent; }\n    if (shift < 0) { shift = 0; }\n\n    first = this.bMarks[line] + shift;\n\n    if (line + 1 < end || keepLastLF) {\n      // No need for bounds check because we have fake entry on tail.\n      last = this.eMarks[line] + 1;\n    } else {\n      last = this.eMarks[line];\n    }\n\n    queue[i] = this.src.slice(first, last);\n  }\n\n  return queue.join('');\n};\n\n// Code block (4 spaces padded)\n\nfunction code(state, startLine, endLine/*, silent*/) {\n  var nextLine, last;\n\n  if (state.tShift[startLine] - state.blkIndent < 4) { return false; }\n\n  last = nextLine = startLine + 1;\n\n  while (nextLine < endLine) {\n    if (state.isEmpty(nextLine)) {\n      nextLine++;\n      continue;\n    }\n    if (state.tShift[nextLine] - state.blkIndent >= 4) {\n      nextLine++;\n      last = nextLine;\n      continue;\n    }\n    break;\n  }\n\n  state.line = nextLine;\n  state.tokens.push({\n    type: 'code',\n    content: state.getLines(startLine, last, 4 + state.blkIndent, true),\n    block: true,\n    lines: [ startLine, state.line ],\n    level: state.level\n  });\n\n  return true;\n}\n\n// fences (``` lang, ~~~ lang)\n\nfunction fences(state, startLine, endLine, silent) {\n  var marker, len, params, nextLine, mem,\n      haveEndMarker = false,\n      pos = state.bMarks[startLine] + state.tShift[startLine],\n      max = state.eMarks[startLine];\n\n  if (pos + 3 > max) { return false; }\n\n  marker = state.src.charCodeAt(pos);\n\n  if (marker !== 0x7E/* ~ */ && marker !== 0x60 /* ` */) {\n    return false;\n  }\n\n  // scan marker length\n  mem = pos;\n  pos = state.skipChars(pos, marker);\n\n  len = pos - mem;\n\n  if (len < 3) { return false; }\n\n  params = state.src.slice(pos, max).trim();\n\n  if (params.indexOf('`') >= 0) { return false; }\n\n  // Since start is found, we can report success here in validation mode\n  if (silent) { return true; }\n\n  // search end of block\n  nextLine = startLine;\n\n  for (;;) {\n    nextLine++;\n    if (nextLine >= endLine) {\n      // unclosed block should be autoclosed by end of document.\n      // also block seems to be autoclosed by end of parent\n      break;\n    }\n\n    pos = mem = state.bMarks[nextLine] + state.tShift[nextLine];\n    max = state.eMarks[nextLine];\n\n    if (pos < max && state.tShift[nextLine] < state.blkIndent) {\n      // non-empty line with negative indent should stop the list:\n      // - ```\n      //  test\n      break;\n    }\n\n    if (state.src.charCodeAt(pos) !== marker) { continue; }\n\n    if (state.tShift[nextLine] - state.blkIndent >= 4) {\n      // closing fence should be indented less than 4 spaces\n      continue;\n    }\n\n    pos = state.skipChars(pos, marker);\n\n    // closing code fence must be at least as long as the opening one\n    if (pos - mem < len) { continue; }\n\n    // make sure tail has spaces only\n    pos = state.skipSpaces(pos);\n\n    if (pos < max) { continue; }\n\n    haveEndMarker = true;\n    // found!\n    break;\n  }\n\n  // If a fence has heading spaces, they should be removed from its inner block\n  len = state.tShift[startLine];\n\n  state.line = nextLine + (haveEndMarker ? 1 : 0);\n  state.tokens.push({\n    type: 'fence',\n    params: params,\n    content: state.getLines(startLine + 1, nextLine, len, true),\n    lines: [ startLine, state.line ],\n    level: state.level\n  });\n\n  return true;\n}\n\n// Block quotes\n\nfunction blockquote(state, startLine, endLine, silent) {\n  var nextLine, lastLineEmpty, oldTShift, oldBMarks, oldIndent, oldParentType, lines,\n      terminatorRules,\n      i, l, terminate,\n      pos = state.bMarks[startLine] + state.tShift[startLine],\n      max = state.eMarks[startLine];\n\n  if (pos > max) { return false; }\n\n  // check the block quote marker\n  if (state.src.charCodeAt(pos++) !== 0x3E/* > */) { return false; }\n\n  if (state.level >= state.options.maxNesting) { return false; }\n\n  // we know that it's going to be a valid blockquote,\n  // so no point trying to find the end of it in silent mode\n  if (silent) { return true; }\n\n  // skip one optional space after '>'\n  if (state.src.charCodeAt(pos) === 0x20) { pos++; }\n\n  oldIndent = state.blkIndent;\n  state.blkIndent = 0;\n\n  oldBMarks = [ state.bMarks[startLine] ];\n  state.bMarks[startLine] = pos;\n\n  // check if we have an empty blockquote\n  pos = pos < max ? state.skipSpaces(pos) : pos;\n  lastLineEmpty = pos >= max;\n\n  oldTShift = [ state.tShift[startLine] ];\n  state.tShift[startLine] = pos - state.bMarks[startLine];\n\n  terminatorRules = state.parser.ruler.getRules('blockquote');\n\n  // Search the end of the block\n  //\n  // Block ends with either:\n  //  1. an empty line outside:\n  //     ```\n  //     > test\n  //\n  //     ```\n  //  2. an empty line inside:\n  //     ```\n  //     >\n  //     test\n  //     ```\n  //  3. another tag\n  //     ```\n  //     > test\n  //      - - -\n  //     ```\n  for (nextLine = startLine + 1; nextLine < endLine; nextLine++) {\n    pos = state.bMarks[nextLine] + state.tShift[nextLine];\n    max = state.eMarks[nextLine];\n\n    if (pos >= max) {\n      // Case 1: line is not inside the blockquote, and this line is empty.\n      break;\n    }\n\n    if (state.src.charCodeAt(pos++) === 0x3E/* > */) {\n      // This line is inside the blockquote.\n\n      // skip one optional space after '>'\n      if (state.src.charCodeAt(pos) === 0x20) { pos++; }\n\n      oldBMarks.push(state.bMarks[nextLine]);\n      state.bMarks[nextLine] = pos;\n\n      pos = pos < max ? state.skipSpaces(pos) : pos;\n      lastLineEmpty = pos >= max;\n\n      oldTShift.push(state.tShift[nextLine]);\n      state.tShift[nextLine] = pos - state.bMarks[nextLine];\n      continue;\n    }\n\n    // Case 2: line is not inside the blockquote, and the last line was empty.\n    if (lastLineEmpty) { break; }\n\n    // Case 3: another tag found.\n    terminate = false;\n    for (i = 0, l = terminatorRules.length; i < l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true;\n        break;\n      }\n    }\n    if (terminate) { break; }\n\n    oldBMarks.push(state.bMarks[nextLine]);\n    oldTShift.push(state.tShift[nextLine]);\n\n    // A negative number means that this is a paragraph continuation;\n    //\n    // Any negative number will do the job here, but it's better for it\n    // to be large enough to make any bugs obvious.\n    state.tShift[nextLine] = -1337;\n  }\n\n  oldParentType = state.parentType;\n  state.parentType = 'blockquote';\n  state.tokens.push({\n    type: 'blockquote_open',\n    lines: lines = [ startLine, 0 ],\n    level: state.level++\n  });\n  state.parser.tokenize(state, startLine, nextLine);\n  state.tokens.push({\n    type: 'blockquote_close',\n    level: --state.level\n  });\n  state.parentType = oldParentType;\n  lines[1] = state.line;\n\n  // Restore original tShift; this might not be necessary since the parser\n  // has already been here, but just to make sure we can do that.\n  for (i = 0; i < oldTShift.length; i++) {\n    state.bMarks[i + startLine] = oldBMarks[i];\n    state.tShift[i + startLine] = oldTShift[i];\n  }\n  state.blkIndent = oldIndent;\n\n  return true;\n}\n\n// Horizontal rule\n\nfunction hr(state, startLine, endLine, silent) {\n  var marker, cnt, ch,\n      pos = state.bMarks[startLine],\n      max = state.eMarks[startLine];\n\n  pos += state.tShift[startLine];\n\n  if (pos > max) { return false; }\n\n  marker = state.src.charCodeAt(pos++);\n\n  // Check hr marker\n  if (marker !== 0x2A/* * */ &&\n      marker !== 0x2D/* - */ &&\n      marker !== 0x5F/* _ */) {\n    return false;\n  }\n\n  // markers can be mixed with spaces, but there should be at least 3 one\n\n  cnt = 1;\n  while (pos < max) {\n    ch = state.src.charCodeAt(pos++);\n    if (ch !== marker && ch !== 0x20/* space */) { return false; }\n    if (ch === marker) { cnt++; }\n  }\n\n  if (cnt < 3) { return false; }\n\n  if (silent) { return true; }\n\n  state.line = startLine + 1;\n  state.tokens.push({\n    type: 'hr',\n    lines: [ startLine, state.line ],\n    level: state.level\n  });\n\n  return true;\n}\n\n// Lists\n\n// Search `[-+*][\\n ]`, returns next pos arter marker on success\n// or -1 on fail.\nfunction skipBulletListMarker(state, startLine) {\n  var marker, pos, max;\n\n  pos = state.bMarks[startLine] + state.tShift[startLine];\n  max = state.eMarks[startLine];\n\n  if (pos >= max) { return -1; }\n\n  marker = state.src.charCodeAt(pos++);\n  // Check bullet\n  if (marker !== 0x2A/* * */ &&\n      marker !== 0x2D/* - */ &&\n      marker !== 0x2B/* + */) {\n    return -1;\n  }\n\n  if (pos < max && state.src.charCodeAt(pos) !== 0x20) {\n    // \" 1.test \" - is not a list item\n    return -1;\n  }\n\n  return pos;\n}\n\n// Search `\\d+[.)][\\n ]`, returns next pos arter marker on success\n// or -1 on fail.\nfunction skipOrderedListMarker(state, startLine) {\n  var ch,\n      pos = state.bMarks[startLine] + state.tShift[startLine],\n      max = state.eMarks[startLine];\n\n  if (pos + 1 >= max) { return -1; }\n\n  ch = state.src.charCodeAt(pos++);\n\n  if (ch < 0x30/* 0 */ || ch > 0x39/* 9 */) { return -1; }\n\n  for (;;) {\n    // EOL -> fail\n    if (pos >= max) { return -1; }\n\n    ch = state.src.charCodeAt(pos++);\n\n    if (ch >= 0x30/* 0 */ && ch <= 0x39/* 9 */) {\n      continue;\n    }\n\n    // found valid marker\n    if (ch === 0x29/* ) */ || ch === 0x2e/* . */) {\n      break;\n    }\n\n    return -1;\n  }\n\n\n  if (pos < max && state.src.charCodeAt(pos) !== 0x20/* space */) {\n    // \" 1.test \" - is not a list item\n    return -1;\n  }\n  return pos;\n}\n\nfunction markTightParagraphs(state, idx) {\n  var i, l,\n      level = state.level + 2;\n\n  for (i = idx + 2, l = state.tokens.length - 2; i < l; i++) {\n    if (state.tokens[i].level === level && state.tokens[i].type === 'paragraph_open') {\n      state.tokens[i + 2].tight = true;\n      state.tokens[i].tight = true;\n      i += 2;\n    }\n  }\n}\n\n\nfunction list(state, startLine, endLine, silent) {\n  var nextLine,\n      indent,\n      oldTShift,\n      oldIndent,\n      oldTight,\n      oldParentType,\n      start,\n      posAfterMarker,\n      max,\n      indentAfterMarker,\n      markerValue,\n      markerCharCode,\n      isOrdered,\n      contentStart,\n      listTokIdx,\n      prevEmptyEnd,\n      listLines,\n      itemLines,\n      tight = true,\n      terminatorRules,\n      i, l, terminate;\n\n  // Detect list type and position after marker\n  if ((posAfterMarker = skipOrderedListMarker(state, startLine)) >= 0) {\n    isOrdered = true;\n  } else if ((posAfterMarker = skipBulletListMarker(state, startLine)) >= 0) {\n    isOrdered = false;\n  } else {\n    return false;\n  }\n\n  if (state.level >= state.options.maxNesting) { return false; }\n\n  // We should terminate list on style change. Remember first one to compare.\n  markerCharCode = state.src.charCodeAt(posAfterMarker - 1);\n\n  // For validation mode we can terminate immediately\n  if (silent) { return true; }\n\n  // Start list\n  listTokIdx = state.tokens.length;\n\n  if (isOrdered) {\n    start = state.bMarks[startLine] + state.tShift[startLine];\n    markerValue = Number(state.src.substr(start, posAfterMarker - start - 1));\n\n    state.tokens.push({\n      type: 'ordered_list_open',\n      order: markerValue,\n      lines: listLines = [ startLine, 0 ],\n      level: state.level++\n    });\n\n  } else {\n    state.tokens.push({\n      type: 'bullet_list_open',\n      lines: listLines = [ startLine, 0 ],\n      level: state.level++\n    });\n  }\n\n  //\n  // Iterate list items\n  //\n\n  nextLine = startLine;\n  prevEmptyEnd = false;\n  terminatorRules = state.parser.ruler.getRules('list');\n\n  while (nextLine < endLine) {\n    contentStart = state.skipSpaces(posAfterMarker);\n    max = state.eMarks[nextLine];\n\n    if (contentStart >= max) {\n      // trimming space in \"-    \\n  3\" case, indent is 1 here\n      indentAfterMarker = 1;\n    } else {\n      indentAfterMarker = contentStart - posAfterMarker;\n    }\n\n    // If we have more than 4 spaces, the indent is 1\n    // (the rest is just indented code block)\n    if (indentAfterMarker > 4) { indentAfterMarker = 1; }\n\n    // If indent is less than 1, assume that it's one, example:\n    //  \"-\\n  test\"\n    if (indentAfterMarker < 1) { indentAfterMarker = 1; }\n\n    // \"  -  test\"\n    //  ^^^^^ - calculating total length of this thing\n    indent = (posAfterMarker - state.bMarks[nextLine]) + indentAfterMarker;\n\n    // Run subparser & write tokens\n    state.tokens.push({\n      type: 'list_item_open',\n      lines: itemLines = [ startLine, 0 ],\n      level: state.level++\n    });\n\n    oldIndent = state.blkIndent;\n    oldTight = state.tight;\n    oldTShift = state.tShift[startLine];\n    oldParentType = state.parentType;\n    state.tShift[startLine] = contentStart - state.bMarks[startLine];\n    state.blkIndent = indent;\n    state.tight = true;\n    state.parentType = 'list';\n\n    state.parser.tokenize(state, startLine, endLine, true);\n\n    // If any of list item is tight, mark list as tight\n    if (!state.tight || prevEmptyEnd) {\n      tight = false;\n    }\n    // Item become loose if finish with empty line,\n    // but we should filter last element, because it means list finish\n    prevEmptyEnd = (state.line - startLine) > 1 && state.isEmpty(state.line - 1);\n\n    state.blkIndent = oldIndent;\n    state.tShift[startLine] = oldTShift;\n    state.tight = oldTight;\n    state.parentType = oldParentType;\n\n    state.tokens.push({\n      type: 'list_item_close',\n      level: --state.level\n    });\n\n    nextLine = startLine = state.line;\n    itemLines[1] = nextLine;\n    contentStart = state.bMarks[startLine];\n\n    if (nextLine >= endLine) { break; }\n\n    if (state.isEmpty(nextLine)) {\n      break;\n    }\n\n    //\n    // Try to check if list is terminated or continued.\n    //\n    if (state.tShift[nextLine] < state.blkIndent) { break; }\n\n    // fail if terminating block found\n    terminate = false;\n    for (i = 0, l = terminatorRules.length; i < l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true;\n        break;\n      }\n    }\n    if (terminate) { break; }\n\n    // fail if list has another type\n    if (isOrdered) {\n      posAfterMarker = skipOrderedListMarker(state, nextLine);\n      if (posAfterMarker < 0) { break; }\n    } else {\n      posAfterMarker = skipBulletListMarker(state, nextLine);\n      if (posAfterMarker < 0) { break; }\n    }\n\n    if (markerCharCode !== state.src.charCodeAt(posAfterMarker - 1)) { break; }\n  }\n\n  // Finilize list\n  state.tokens.push({\n    type: isOrdered ? 'ordered_list_close' : 'bullet_list_close',\n    level: --state.level\n  });\n  listLines[1] = nextLine;\n\n  state.line = nextLine;\n\n  // mark paragraphs tight if needed\n  if (tight) {\n    markTightParagraphs(state, listTokIdx);\n  }\n\n  return true;\n}\n\n// Process footnote reference list\n\nfunction footnote(state, startLine, endLine, silent) {\n  var oldBMark, oldTShift, oldParentType, pos, label,\n      start = state.bMarks[startLine] + state.tShift[startLine],\n      max = state.eMarks[startLine];\n\n  // line should be at least 5 chars - \"[^x]:\"\n  if (start + 4 > max) { return false; }\n\n  if (state.src.charCodeAt(start) !== 0x5B/* [ */) { return false; }\n  if (state.src.charCodeAt(start + 1) !== 0x5E/* ^ */) { return false; }\n  if (state.level >= state.options.maxNesting) { return false; }\n\n  for (pos = start + 2; pos < max; pos++) {\n    if (state.src.charCodeAt(pos) === 0x20) { return false; }\n    if (state.src.charCodeAt(pos) === 0x5D /* ] */) {\n      break;\n    }\n  }\n\n  if (pos === start + 2) { return false; } // no empty footnote labels\n  if (pos + 1 >= max || state.src.charCodeAt(++pos) !== 0x3A /* : */) { return false; }\n  if (silent) { return true; }\n  pos++;\n\n  if (!state.env.footnotes) { state.env.footnotes = {}; }\n  if (!state.env.footnotes.refs) { state.env.footnotes.refs = {}; }\n  label = state.src.slice(start + 2, pos - 2);\n  state.env.footnotes.refs[':' + label] = -1;\n\n  state.tokens.push({\n    type: 'footnote_reference_open',\n    label: label,\n    level: state.level++\n  });\n\n  oldBMark = state.bMarks[startLine];\n  oldTShift = state.tShift[startLine];\n  oldParentType = state.parentType;\n  state.tShift[startLine] = state.skipSpaces(pos) - pos;\n  state.bMarks[startLine] = pos;\n  state.blkIndent += 4;\n  state.parentType = 'footnote';\n\n  if (state.tShift[startLine] < state.blkIndent) {\n    state.tShift[startLine] += state.blkIndent;\n    state.bMarks[startLine] -= state.blkIndent;\n  }\n\n  state.parser.tokenize(state, startLine, endLine, true);\n\n  state.parentType = oldParentType;\n  state.blkIndent -= 4;\n  state.tShift[startLine] = oldTShift;\n  state.bMarks[startLine] = oldBMark;\n\n  state.tokens.push({\n    type: 'footnote_reference_close',\n    level: --state.level\n  });\n\n  return true;\n}\n\n// heading (#, ##, ...)\n\nfunction heading(state, startLine, endLine, silent) {\n  var ch, level, tmp,\n      pos = state.bMarks[startLine] + state.tShift[startLine],\n      max = state.eMarks[startLine];\n\n  if (pos >= max) { return false; }\n\n  ch  = state.src.charCodeAt(pos);\n\n  if (ch !== 0x23/* # */ || pos >= max) { return false; }\n\n  // count heading level\n  level = 1;\n  ch = state.src.charCodeAt(++pos);\n  while (ch === 0x23/* # */ && pos < max && level <= 6) {\n    level++;\n    ch = state.src.charCodeAt(++pos);\n  }\n\n  if (level > 6 || (pos < max && ch !== 0x20/* space */)) { return false; }\n\n  if (silent) { return true; }\n\n  // Let's cut tails like '    ###  ' from the end of string\n\n  max = state.skipCharsBack(max, 0x20, pos); // space\n  tmp = state.skipCharsBack(max, 0x23, pos); // #\n  if (tmp > pos && state.src.charCodeAt(tmp - 1) === 0x20/* space */) {\n    max = tmp;\n  }\n\n  state.line = startLine + 1;\n\n  state.tokens.push({ type: 'heading_open',\n    hLevel: level,\n    lines: [ startLine, state.line ],\n    level: state.level\n  });\n\n  // only if header is not empty\n  if (pos < max) {\n    state.tokens.push({\n      type: 'inline',\n      content: state.src.slice(pos, max).trim(),\n      level: state.level + 1,\n      lines: [ startLine, state.line ],\n      children: []\n    });\n  }\n  state.tokens.push({ type: 'heading_close', hLevel: level, level: state.level });\n\n  return true;\n}\n\n// lheading (---, ===)\n\nfunction lheading(state, startLine, endLine/*, silent*/) {\n  var marker, pos, max,\n      next = startLine + 1;\n\n  if (next >= endLine) { return false; }\n  if (state.tShift[next] < state.blkIndent) { return false; }\n\n  // Scan next line\n\n  if (state.tShift[next] - state.blkIndent > 3) { return false; }\n\n  pos = state.bMarks[next] + state.tShift[next];\n  max = state.eMarks[next];\n\n  if (pos >= max) { return false; }\n\n  marker = state.src.charCodeAt(pos);\n\n  if (marker !== 0x2D/* - */ && marker !== 0x3D/* = */) { return false; }\n\n  pos = state.skipChars(pos, marker);\n\n  pos = state.skipSpaces(pos);\n\n  if (pos < max) { return false; }\n\n  pos = state.bMarks[startLine] + state.tShift[startLine];\n\n  state.line = next + 1;\n  state.tokens.push({\n    type: 'heading_open',\n    hLevel: marker === 0x3D/* = */ ? 1 : 2,\n    lines: [ startLine, state.line ],\n    level: state.level\n  });\n  state.tokens.push({\n    type: 'inline',\n    content: state.src.slice(pos, state.eMarks[startLine]).trim(),\n    level: state.level + 1,\n    lines: [ startLine, state.line - 1 ],\n    children: []\n  });\n  state.tokens.push({\n    type: 'heading_close',\n    hLevel: marker === 0x3D/* = */ ? 1 : 2,\n    level: state.level\n  });\n\n  return true;\n}\n\n// List of valid html blocks names, accorting to commonmark spec\n// http://jgm.github.io/CommonMark/spec.html#html-blocks\n\nvar html_blocks = {};\n\n[\n  'article',\n  'aside',\n  'button',\n  'blockquote',\n  'body',\n  'canvas',\n  'caption',\n  'col',\n  'colgroup',\n  'dd',\n  'div',\n  'dl',\n  'dt',\n  'embed',\n  'fieldset',\n  'figcaption',\n  'figure',\n  'footer',\n  'form',\n  'h1',\n  'h2',\n  'h3',\n  'h4',\n  'h5',\n  'h6',\n  'header',\n  'hgroup',\n  'hr',\n  'iframe',\n  'li',\n  'map',\n  'object',\n  'ol',\n  'output',\n  'p',\n  'pre',\n  'progress',\n  'script',\n  'section',\n  'style',\n  'table',\n  'tbody',\n  'td',\n  'textarea',\n  'tfoot',\n  'th',\n  'tr',\n  'thead',\n  'ul',\n  'video'\n].forEach(function (name) { html_blocks[name] = true; });\n\n// HTML block\n\n\nvar HTML_TAG_OPEN_RE = /^<([a-zA-Z]{1,15})[\\s\\/>]/;\nvar HTML_TAG_CLOSE_RE = /^<\\/([a-zA-Z]{1,15})[\\s>]/;\n\nfunction isLetter$1(ch) {\n  /*eslint no-bitwise:0*/\n  var lc = ch | 0x20; // to lower case\n  return (lc >= 0x61/* a */) && (lc <= 0x7a/* z */);\n}\n\nfunction htmlblock(state, startLine, endLine, silent) {\n  var ch, match, nextLine,\n      pos = state.bMarks[startLine],\n      max = state.eMarks[startLine],\n      shift = state.tShift[startLine];\n\n  pos += shift;\n\n  if (!state.options.html) { return false; }\n\n  if (shift > 3 || pos + 2 >= max) { return false; }\n\n  if (state.src.charCodeAt(pos) !== 0x3C/* < */) { return false; }\n\n  ch = state.src.charCodeAt(pos + 1);\n\n  if (ch === 0x21/* ! */ || ch === 0x3F/* ? */) {\n    // Directive start / comment start / processing instruction start\n    if (silent) { return true; }\n\n  } else if (ch === 0x2F/* / */ || isLetter$1(ch)) {\n\n    // Probably start or end of tag\n    if (ch === 0x2F/* \\ */) {\n      // closing tag\n      match = state.src.slice(pos, max).match(HTML_TAG_CLOSE_RE);\n      if (!match) { return false; }\n    } else {\n      // opening tag\n      match = state.src.slice(pos, max).match(HTML_TAG_OPEN_RE);\n      if (!match) { return false; }\n    }\n    // Make sure tag name is valid\n    if (html_blocks[match[1].toLowerCase()] !== true) { return false; }\n    if (silent) { return true; }\n\n  } else {\n    return false;\n  }\n\n  // If we are here - we detected HTML block.\n  // Let's roll down till empty line (block end).\n  nextLine = startLine + 1;\n  while (nextLine < state.lineMax && !state.isEmpty(nextLine)) {\n    nextLine++;\n  }\n\n  state.line = nextLine;\n  state.tokens.push({\n    type: 'htmlblock',\n    level: state.level,\n    lines: [ startLine, state.line ],\n    content: state.getLines(startLine, nextLine, 0, true)\n  });\n\n  return true;\n}\n\n// GFM table, non-standard\n\nfunction getLine(state, line) {\n  var pos = state.bMarks[line] + state.blkIndent,\n      max = state.eMarks[line];\n\n  return state.src.substr(pos, max - pos);\n}\n\nfunction table(state, startLine, endLine, silent) {\n  var ch, lineText, pos, i, nextLine, rows, cell,\n      aligns, t, tableLines, tbodyLines;\n\n  // should have at least three lines\n  if (startLine + 2 > endLine) { return false; }\n\n  nextLine = startLine + 1;\n\n  if (state.tShift[nextLine] < state.blkIndent) { return false; }\n\n  // first character of the second line should be '|' or '-'\n\n  pos = state.bMarks[nextLine] + state.tShift[nextLine];\n  if (pos >= state.eMarks[nextLine]) { return false; }\n\n  ch = state.src.charCodeAt(pos);\n  if (ch !== 0x7C/* | */ && ch !== 0x2D/* - */ && ch !== 0x3A/* : */) { return false; }\n\n  lineText = getLine(state, startLine + 1);\n  if (!/^[-:| ]+$/.test(lineText)) { return false; }\n\n  rows = lineText.split('|');\n  if (rows <= 2) { return false; }\n  aligns = [];\n  for (i = 0; i < rows.length; i++) {\n    t = rows[i].trim();\n    if (!t) {\n      // allow empty columns before and after table, but not in between columns;\n      // e.g. allow ` |---| `, disallow ` ---||--- `\n      if (i === 0 || i === rows.length - 1) {\n        continue;\n      } else {\n        return false;\n      }\n    }\n\n    if (!/^:?-+:?$/.test(t)) { return false; }\n    if (t.charCodeAt(t.length - 1) === 0x3A/* : */) {\n      aligns.push(t.charCodeAt(0) === 0x3A/* : */ ? 'center' : 'right');\n    } else if (t.charCodeAt(0) === 0x3A/* : */) {\n      aligns.push('left');\n    } else {\n      aligns.push('');\n    }\n  }\n\n  lineText = getLine(state, startLine).trim();\n  if (lineText.indexOf('|') === -1) { return false; }\n  rows = lineText.replace(/^\\||\\|$/g, '').split('|');\n  if (aligns.length !== rows.length) { return false; }\n  if (silent) { return true; }\n\n  state.tokens.push({\n    type: 'table_open',\n    lines: tableLines = [ startLine, 0 ],\n    level: state.level++\n  });\n  state.tokens.push({\n    type: 'thead_open',\n    lines: [ startLine, startLine + 1 ],\n    level: state.level++\n  });\n\n  state.tokens.push({\n    type: 'tr_open',\n    lines: [ startLine, startLine + 1 ],\n    level: state.level++\n  });\n  for (i = 0; i < rows.length; i++) {\n    state.tokens.push({\n      type: 'th_open',\n      align: aligns[i],\n      lines: [ startLine, startLine + 1 ],\n      level: state.level++\n    });\n    state.tokens.push({\n      type: 'inline',\n      content: rows[i].trim(),\n      lines: [ startLine, startLine + 1 ],\n      level: state.level,\n      children: []\n    });\n    state.tokens.push({ type: 'th_close', level: --state.level });\n  }\n  state.tokens.push({ type: 'tr_close', level: --state.level });\n  state.tokens.push({ type: 'thead_close', level: --state.level });\n\n  state.tokens.push({\n    type: 'tbody_open',\n    lines: tbodyLines = [ startLine + 2, 0 ],\n    level: state.level++\n  });\n\n  for (nextLine = startLine + 2; nextLine < endLine; nextLine++) {\n    if (state.tShift[nextLine] < state.blkIndent) { break; }\n\n    lineText = getLine(state, nextLine).trim();\n    if (lineText.indexOf('|') === -1) { break; }\n    rows = lineText.replace(/^\\||\\|$/g, '').split('|');\n\n    state.tokens.push({ type: 'tr_open', level: state.level++ });\n    for (i = 0; i < rows.length; i++) {\n      state.tokens.push({ type: 'td_open', align: aligns[i], level: state.level++ });\n      // 0x7c === '|'\n      cell = rows[i].substring(\n          rows[i].charCodeAt(0) === 0x7c ? 1 : 0,\n          rows[i].charCodeAt(rows[i].length - 1) === 0x7c ? rows[i].length - 1 : rows[i].length\n      ).trim();\n      state.tokens.push({\n        type: 'inline',\n        content: cell,\n        level: state.level,\n        children: []\n      });\n      state.tokens.push({ type: 'td_close', level: --state.level });\n    }\n    state.tokens.push({ type: 'tr_close', level: --state.level });\n  }\n  state.tokens.push({ type: 'tbody_close', level: --state.level });\n  state.tokens.push({ type: 'table_close', level: --state.level });\n\n  tableLines[1] = tbodyLines[1] = nextLine;\n  state.line = nextLine;\n  return true;\n}\n\n// Definition lists\n\n// Search `[:~][\\n ]`, returns next pos after marker on success\n// or -1 on fail.\nfunction skipMarker(state, line) {\n  var pos, marker,\n      start = state.bMarks[line] + state.tShift[line],\n      max = state.eMarks[line];\n\n  if (start >= max) { return -1; }\n\n  // Check bullet\n  marker = state.src.charCodeAt(start++);\n  if (marker !== 0x7E/* ~ */ && marker !== 0x3A/* : */) { return -1; }\n\n  pos = state.skipSpaces(start);\n\n  // require space after \":\"\n  if (start === pos) { return -1; }\n\n  // no empty definitions, e.g. \"  : \"\n  if (pos >= max) { return -1; }\n\n  return pos;\n}\n\nfunction markTightParagraphs$1(state, idx) {\n  var i, l,\n      level = state.level + 2;\n\n  for (i = idx + 2, l = state.tokens.length - 2; i < l; i++) {\n    if (state.tokens[i].level === level && state.tokens[i].type === 'paragraph_open') {\n      state.tokens[i + 2].tight = true;\n      state.tokens[i].tight = true;\n      i += 2;\n    }\n  }\n}\n\nfunction deflist(state, startLine, endLine, silent) {\n  var contentStart,\n      ddLine,\n      dtLine,\n      itemLines,\n      listLines,\n      listTokIdx,\n      nextLine,\n      oldIndent,\n      oldDDIndent,\n      oldParentType,\n      oldTShift,\n      oldTight,\n      prevEmptyEnd,\n      tight;\n\n  if (silent) {\n    // quirk: validation mode validates a dd block only, not a whole deflist\n    if (state.ddIndent < 0) { return false; }\n    return skipMarker(state, startLine) >= 0;\n  }\n\n  nextLine = startLine + 1;\n  if (state.isEmpty(nextLine)) {\n    if (++nextLine > endLine) { return false; }\n  }\n\n  if (state.tShift[nextLine] < state.blkIndent) { return false; }\n  contentStart = skipMarker(state, nextLine);\n  if (contentStart < 0) { return false; }\n\n  if (state.level >= state.options.maxNesting) { return false; }\n\n  // Start list\n  listTokIdx = state.tokens.length;\n\n  state.tokens.push({\n    type: 'dl_open',\n    lines: listLines = [ startLine, 0 ],\n    level: state.level++\n  });\n\n  //\n  // Iterate list items\n  //\n\n  dtLine = startLine;\n  ddLine = nextLine;\n\n  // One definition list can contain multiple DTs,\n  // and one DT can be followed by multiple DDs.\n  //\n  // Thus, there is two loops here, and label is\n  // needed to break out of the second one\n  //\n  /*eslint no-labels:0,block-scoped-var:0*/\n  OUTER:\n  for (;;) {\n    tight = true;\n    prevEmptyEnd = false;\n\n    state.tokens.push({\n      type: 'dt_open',\n      lines: [ dtLine, dtLine ],\n      level: state.level++\n    });\n    state.tokens.push({\n      type: 'inline',\n      content: state.getLines(dtLine, dtLine + 1, state.blkIndent, false).trim(),\n      level: state.level + 1,\n      lines: [ dtLine, dtLine ],\n      children: []\n    });\n    state.tokens.push({\n      type: 'dt_close',\n      level: --state.level\n    });\n\n    for (;;) {\n      state.tokens.push({\n        type: 'dd_open',\n        lines: itemLines = [ nextLine, 0 ],\n        level: state.level++\n      });\n\n      oldTight = state.tight;\n      oldDDIndent = state.ddIndent;\n      oldIndent = state.blkIndent;\n      oldTShift = state.tShift[ddLine];\n      oldParentType = state.parentType;\n      state.blkIndent = state.ddIndent = state.tShift[ddLine] + 2;\n      state.tShift[ddLine] = contentStart - state.bMarks[ddLine];\n      state.tight = true;\n      state.parentType = 'deflist';\n\n      state.parser.tokenize(state, ddLine, endLine, true);\n\n      // If any of list item is tight, mark list as tight\n      if (!state.tight || prevEmptyEnd) {\n        tight = false;\n      }\n      // Item become loose if finish with empty line,\n      // but we should filter last element, because it means list finish\n      prevEmptyEnd = (state.line - ddLine) > 1 && state.isEmpty(state.line - 1);\n\n      state.tShift[ddLine] = oldTShift;\n      state.tight = oldTight;\n      state.parentType = oldParentType;\n      state.blkIndent = oldIndent;\n      state.ddIndent = oldDDIndent;\n\n      state.tokens.push({\n        type: 'dd_close',\n        level: --state.level\n      });\n\n      itemLines[1] = nextLine = state.line;\n\n      if (nextLine >= endLine) { break OUTER; }\n\n      if (state.tShift[nextLine] < state.blkIndent) { break OUTER; }\n      contentStart = skipMarker(state, nextLine);\n      if (contentStart < 0) { break; }\n\n      ddLine = nextLine;\n\n      // go to the next loop iteration:\n      // insert DD tag and repeat checking\n    }\n\n    if (nextLine >= endLine) { break; }\n    dtLine = nextLine;\n\n    if (state.isEmpty(dtLine)) { break; }\n    if (state.tShift[dtLine] < state.blkIndent) { break; }\n\n    ddLine = dtLine + 1;\n    if (ddLine >= endLine) { break; }\n    if (state.isEmpty(ddLine)) { ddLine++; }\n    if (ddLine >= endLine) { break; }\n\n    if (state.tShift[ddLine] < state.blkIndent) { break; }\n    contentStart = skipMarker(state, ddLine);\n    if (contentStart < 0) { break; }\n\n    // go to the next loop iteration:\n    // insert DT and DD tags and repeat checking\n  }\n\n  // Finilize list\n  state.tokens.push({\n    type: 'dl_close',\n    level: --state.level\n  });\n  listLines[1] = nextLine;\n\n  state.line = nextLine;\n\n  // mark paragraphs tight if needed\n  if (tight) {\n    markTightParagraphs$1(state, listTokIdx);\n  }\n\n  return true;\n}\n\n// Paragraph\n\nfunction paragraph(state, startLine/*, endLine*/) {\n  var endLine, content, terminate, i, l,\n      nextLine = startLine + 1,\n      terminatorRules;\n\n  endLine = state.lineMax;\n\n  // jump line-by-line until empty one or EOF\n  if (nextLine < endLine && !state.isEmpty(nextLine)) {\n    terminatorRules = state.parser.ruler.getRules('paragraph');\n\n    for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {\n      // this would be a code block normally, but after paragraph\n      // it's considered a lazy continuation regardless of what's there\n      if (state.tShift[nextLine] - state.blkIndent > 3) { continue; }\n\n      // Some tags can terminate paragraph without empty line.\n      terminate = false;\n      for (i = 0, l = terminatorRules.length; i < l; i++) {\n        if (terminatorRules[i](state, nextLine, endLine, true)) {\n          terminate = true;\n          break;\n        }\n      }\n      if (terminate) { break; }\n    }\n  }\n\n  content = state.getLines(startLine, nextLine, state.blkIndent, false).trim();\n\n  state.line = nextLine;\n  if (content.length) {\n    state.tokens.push({\n      type: 'paragraph_open',\n      tight: false,\n      lines: [ startLine, state.line ],\n      level: state.level\n    });\n    state.tokens.push({\n      type: 'inline',\n      content: content,\n      level: state.level + 1,\n      lines: [ startLine, state.line ],\n      children: []\n    });\n    state.tokens.push({\n      type: 'paragraph_close',\n      tight: false,\n      level: state.level\n    });\n  }\n\n  return true;\n}\n\n/**\n * Parser rules\n */\n\nvar _rules$1 = [\n  [ 'code',       code ],\n  [ 'fences',     fences,     [ 'paragraph', 'blockquote', 'list' ] ],\n  [ 'blockquote', blockquote, [ 'paragraph', 'blockquote', 'list' ] ],\n  [ 'hr',         hr,         [ 'paragraph', 'blockquote', 'list' ] ],\n  [ 'list',       list,       [ 'paragraph', 'blockquote' ] ],\n  [ 'footnote',   footnote,   [ 'paragraph' ] ],\n  [ 'heading',    heading,    [ 'paragraph', 'blockquote' ] ],\n  [ 'lheading',   lheading ],\n  [ 'htmlblock',  htmlblock,  [ 'paragraph', 'blockquote' ] ],\n  [ 'table',      table,      [ 'paragraph' ] ],\n  [ 'deflist',    deflist,    [ 'paragraph' ] ],\n  [ 'paragraph',  paragraph ]\n];\n\n/**\n * Block Parser class\n *\n * @api private\n */\n\nfunction ParserBlock() {\n  this.ruler = new Ruler();\n  for (var i = 0; i < _rules$1.length; i++) {\n    this.ruler.push(_rules$1[i][0], _rules$1[i][1], {\n      alt: (_rules$1[i][2] || []).slice()\n    });\n  }\n}\n\n/**\n * Generate tokens for the given input range.\n *\n * @param  {Object} `state` Has properties like `src`, `parser`, `options` etc\n * @param  {Number} `startLine`\n * @param  {Number} `endLine`\n * @api private\n */\n\nParserBlock.prototype.tokenize = function (state, startLine, endLine) {\n  var rules = this.ruler.getRules('');\n  var len = rules.length;\n  var line = startLine;\n  var hasEmptyLines = false;\n  var ok, i;\n\n  while (line < endLine) {\n    state.line = line = state.skipEmptyLines(line);\n    if (line >= endLine) {\n      break;\n    }\n\n    // Termination condition for nested calls.\n    // Nested calls currently used for blockquotes & lists\n    if (state.tShift[line] < state.blkIndent) {\n      break;\n    }\n\n    // Try all possible rules.\n    // On success, rule should:\n    //\n    // - update `state.line`\n    // - update `state.tokens`\n    // - return true\n\n    for (i = 0; i < len; i++) {\n      ok = rules[i](state, line, endLine, false);\n      if (ok) {\n        break;\n      }\n    }\n\n    // set state.tight iff we had an empty line before current tag\n    // i.e. latest empty line should not count\n    state.tight = !hasEmptyLines;\n\n    // paragraph might \"eat\" one newline after it in nested lists\n    if (state.isEmpty(state.line - 1)) {\n      hasEmptyLines = true;\n    }\n\n    line = state.line;\n\n    if (line < endLine && state.isEmpty(line)) {\n      hasEmptyLines = true;\n      line++;\n\n      // two empty lines should stop the parser in list mode\n      if (line < endLine && state.parentType === 'list' && state.isEmpty(line)) { break; }\n      state.line = line;\n    }\n  }\n};\n\nvar TABS_SCAN_RE = /[\\n\\t]/g;\nvar NEWLINES_RE  = /\\r[\\n\\u0085]|[\\u2424\\u2028\\u0085]/g;\nvar SPACES_RE    = /\\u00a0/g;\n\n/**\n * Tokenize the given `str`.\n *\n * @param  {String} `str` Source string\n * @param  {Object} `options`\n * @param  {Object} `env`\n * @param  {Array} `outTokens`\n * @api private\n */\n\nParserBlock.prototype.parse = function (str, options, env, outTokens) {\n  var state, lineStart = 0, lastTabPos = 0;\n  if (!str) { return []; }\n\n  // Normalize spaces\n  str = str.replace(SPACES_RE, ' ');\n\n  // Normalize newlines\n  str = str.replace(NEWLINES_RE, '\\n');\n\n  // Replace tabs with proper number of spaces (1..4)\n  if (str.indexOf('\\t') >= 0) {\n    str = str.replace(TABS_SCAN_RE, function (match, offset) {\n      var result;\n      if (str.charCodeAt(offset) === 0x0A) {\n        lineStart = offset + 1;\n        lastTabPos = 0;\n        return match;\n      }\n      result = '    '.slice((offset - lineStart - lastTabPos) % 4);\n      lastTabPos = offset - lineStart + 1;\n      return result;\n    });\n  }\n\n  state = new StateBlock(str, this, options, env, outTokens);\n  this.tokenize(state, state.line, state.lineMax);\n};\n\n// Skip text characters for text token, place those to pending buffer\n// and increment current pos\n\n// Rule to skip pure text\n// '{}$%@~+=:' reserved for extentions\n\nfunction isTerminatorChar(ch) {\n  switch (ch) {\n    case 0x0A/* \\n */:\n    case 0x5C/* \\ */:\n    case 0x60/* ` */:\n    case 0x2A/* * */:\n    case 0x5F/* _ */:\n    case 0x5E/* ^ */:\n    case 0x5B/* [ */:\n    case 0x5D/* ] */:\n    case 0x21/* ! */:\n    case 0x26/* & */:\n    case 0x3C/* < */:\n    case 0x3E/* > */:\n    case 0x7B/* { */:\n    case 0x7D/* } */:\n    case 0x24/* $ */:\n    case 0x25/* % */:\n    case 0x40/* @ */:\n    case 0x7E/* ~ */:\n    case 0x2B/* + */:\n    case 0x3D/* = */:\n    case 0x3A/* : */:\n      return true;\n    default:\n      return false;\n  }\n}\n\nfunction text(state, silent) {\n  var pos = state.pos;\n\n  while (pos < state.posMax && !isTerminatorChar(state.src.charCodeAt(pos))) {\n    pos++;\n  }\n\n  if (pos === state.pos) { return false; }\n\n  if (!silent) { state.pending += state.src.slice(state.pos, pos); }\n\n  state.pos = pos;\n\n  return true;\n}\n\n// Proceess '\\n'\n\nfunction newline(state, silent) {\n  var pmax, max, pos = state.pos;\n\n  if (state.src.charCodeAt(pos) !== 0x0A/* \\n */) { return false; }\n\n  pmax = state.pending.length - 1;\n  max = state.posMax;\n\n  // '  \\n' -> hardbreak\n  // Lookup in pending chars is bad practice! Don't copy to other rules!\n  // Pending string is stored in concat mode, indexed lookups will cause\n  // convertion to flat mode.\n  if (!silent) {\n    if (pmax >= 0 && state.pending.charCodeAt(pmax) === 0x20) {\n      if (pmax >= 1 && state.pending.charCodeAt(pmax - 1) === 0x20) {\n        // Strip out all trailing spaces on this line.\n        for (var i = pmax - 2; i >= 0; i--) {\n          if (state.pending.charCodeAt(i) !== 0x20) {\n            state.pending = state.pending.substring(0, i + 1);\n            break;\n          }\n        }\n        state.push({\n          type: 'hardbreak',\n          level: state.level\n        });\n      } else {\n        state.pending = state.pending.slice(0, -1);\n        state.push({\n          type: 'softbreak',\n          level: state.level\n        });\n      }\n\n    } else {\n      state.push({\n        type: 'softbreak',\n        level: state.level\n      });\n    }\n  }\n\n  pos++;\n\n  // skip heading spaces for next line\n  while (pos < max && state.src.charCodeAt(pos) === 0x20) { pos++; }\n\n  state.pos = pos;\n  return true;\n}\n\n// Proceess escaped chars and hardbreaks\n\nvar ESCAPED = [];\n\nfor (var i = 0; i < 256; i++) { ESCAPED.push(0); }\n\n'\\\\!\"#$%&\\'()*+,./:;<=>?@[]^_`{|}~-'\n  .split('').forEach(function(ch) { ESCAPED[ch.charCodeAt(0)] = 1; });\n\n\nfunction escape(state, silent) {\n  var ch, pos = state.pos, max = state.posMax;\n\n  if (state.src.charCodeAt(pos) !== 0x5C/* \\ */) { return false; }\n\n  pos++;\n\n  if (pos < max) {\n    ch = state.src.charCodeAt(pos);\n\n    if (ch < 256 && ESCAPED[ch] !== 0) {\n      if (!silent) { state.pending += state.src[pos]; }\n      state.pos += 2;\n      return true;\n    }\n\n    if (ch === 0x0A) {\n      if (!silent) {\n        state.push({\n          type: 'hardbreak',\n          level: state.level\n        });\n      }\n\n      pos++;\n      // skip leading whitespaces from next line\n      while (pos < max && state.src.charCodeAt(pos) === 0x20) { pos++; }\n\n      state.pos = pos;\n      return true;\n    }\n  }\n\n  if (!silent) { state.pending += '\\\\'; }\n  state.pos++;\n  return true;\n}\n\n// Parse backticks\n\nfunction backticks(state, silent) {\n  var start, max, marker, matchStart, matchEnd,\n      pos = state.pos,\n      ch = state.src.charCodeAt(pos);\n\n  if (ch !== 0x60/* ` */) { return false; }\n\n  start = pos;\n  pos++;\n  max = state.posMax;\n\n  while (pos < max && state.src.charCodeAt(pos) === 0x60/* ` */) { pos++; }\n\n  marker = state.src.slice(start, pos);\n\n  matchStart = matchEnd = pos;\n\n  while ((matchStart = state.src.indexOf('`', matchEnd)) !== -1) {\n    matchEnd = matchStart + 1;\n\n    while (matchEnd < max && state.src.charCodeAt(matchEnd) === 0x60/* ` */) { matchEnd++; }\n\n    if (matchEnd - matchStart === marker.length) {\n      if (!silent) {\n        state.push({\n          type: 'code',\n          content: state.src.slice(pos, matchStart)\n                              .replace(/[ \\n]+/g, ' ')\n                              .trim(),\n          block: false,\n          level: state.level\n        });\n      }\n      state.pos = matchEnd;\n      return true;\n    }\n  }\n\n  if (!silent) { state.pending += marker; }\n  state.pos += marker.length;\n  return true;\n}\n\n// Process ~~deleted text~~\n\nfunction del(state, silent) {\n  var found,\n      pos,\n      stack,\n      max = state.posMax,\n      start = state.pos,\n      lastChar,\n      nextChar;\n\n  if (state.src.charCodeAt(start) !== 0x7E/* ~ */) { return false; }\n  if (silent) { return false; } // don't run any pairs in validation mode\n  if (start + 4 >= max) { return false; }\n  if (state.src.charCodeAt(start + 1) !== 0x7E/* ~ */) { return false; }\n  if (state.level >= state.options.maxNesting) { return false; }\n\n  lastChar = start > 0 ? state.src.charCodeAt(start - 1) : -1;\n  nextChar = state.src.charCodeAt(start + 2);\n\n  if (lastChar === 0x7E/* ~ */) { return false; }\n  if (nextChar === 0x7E/* ~ */) { return false; }\n  if (nextChar === 0x20 || nextChar === 0x0A) { return false; }\n\n  pos = start + 2;\n  while (pos < max && state.src.charCodeAt(pos) === 0x7E/* ~ */) { pos++; }\n  if (pos > start + 3) {\n    // sequence of 4+ markers taking as literal, same as in a emphasis\n    state.pos += pos - start;\n    if (!silent) { state.pending += state.src.slice(start, pos); }\n    return true;\n  }\n\n  state.pos = start + 2;\n  stack = 1;\n\n  while (state.pos + 1 < max) {\n    if (state.src.charCodeAt(state.pos) === 0x7E/* ~ */) {\n      if (state.src.charCodeAt(state.pos + 1) === 0x7E/* ~ */) {\n        lastChar = state.src.charCodeAt(state.pos - 1);\n        nextChar = state.pos + 2 < max ? state.src.charCodeAt(state.pos + 2) : -1;\n        if (nextChar !== 0x7E/* ~ */ && lastChar !== 0x7E/* ~ */) {\n          if (lastChar !== 0x20 && lastChar !== 0x0A) {\n            // closing '~~'\n            stack--;\n          } else if (nextChar !== 0x20 && nextChar !== 0x0A) {\n            // opening '~~'\n            stack++;\n          } // else {\n            //  // standalone ' ~~ ' indented with spaces\n            // }\n          if (stack <= 0) {\n            found = true;\n            break;\n          }\n        }\n      }\n    }\n\n    state.parser.skipToken(state);\n  }\n\n  if (!found) {\n    // parser failed to find ending tag, so it's not valid emphasis\n    state.pos = start;\n    return false;\n  }\n\n  // found!\n  state.posMax = state.pos;\n  state.pos = start + 2;\n\n  if (!silent) {\n    state.push({ type: 'del_open', level: state.level++ });\n    state.parser.tokenize(state);\n    state.push({ type: 'del_close', level: --state.level });\n  }\n\n  state.pos = state.posMax + 2;\n  state.posMax = max;\n  return true;\n}\n\n// Process ++inserted text++\n\nfunction ins(state, silent) {\n  var found,\n      pos,\n      stack,\n      max = state.posMax,\n      start = state.pos,\n      lastChar,\n      nextChar;\n\n  if (state.src.charCodeAt(start) !== 0x2B/* + */) { return false; }\n  if (silent) { return false; } // don't run any pairs in validation mode\n  if (start + 4 >= max) { return false; }\n  if (state.src.charCodeAt(start + 1) !== 0x2B/* + */) { return false; }\n  if (state.level >= state.options.maxNesting) { return false; }\n\n  lastChar = start > 0 ? state.src.charCodeAt(start - 1) : -1;\n  nextChar = state.src.charCodeAt(start + 2);\n\n  if (lastChar === 0x2B/* + */) { return false; }\n  if (nextChar === 0x2B/* + */) { return false; }\n  if (nextChar === 0x20 || nextChar === 0x0A) { return false; }\n\n  pos = start + 2;\n  while (pos < max && state.src.charCodeAt(pos) === 0x2B/* + */) { pos++; }\n  if (pos !== start + 2) {\n    // sequence of 3+ markers taking as literal, same as in a emphasis\n    state.pos += pos - start;\n    if (!silent) { state.pending += state.src.slice(start, pos); }\n    return true;\n  }\n\n  state.pos = start + 2;\n  stack = 1;\n\n  while (state.pos + 1 < max) {\n    if (state.src.charCodeAt(state.pos) === 0x2B/* + */) {\n      if (state.src.charCodeAt(state.pos + 1) === 0x2B/* + */) {\n        lastChar = state.src.charCodeAt(state.pos - 1);\n        nextChar = state.pos + 2 < max ? state.src.charCodeAt(state.pos + 2) : -1;\n        if (nextChar !== 0x2B/* + */ && lastChar !== 0x2B/* + */) {\n          if (lastChar !== 0x20 && lastChar !== 0x0A) {\n            // closing '++'\n            stack--;\n          } else if (nextChar !== 0x20 && nextChar !== 0x0A) {\n            // opening '++'\n            stack++;\n          } // else {\n            //  // standalone ' ++ ' indented with spaces\n            // }\n          if (stack <= 0) {\n            found = true;\n            break;\n          }\n        }\n      }\n    }\n\n    state.parser.skipToken(state);\n  }\n\n  if (!found) {\n    // parser failed to find ending tag, so it's not valid emphasis\n    state.pos = start;\n    return false;\n  }\n\n  // found!\n  state.posMax = state.pos;\n  state.pos = start + 2;\n\n  if (!silent) {\n    state.push({ type: 'ins_open', level: state.level++ });\n    state.parser.tokenize(state);\n    state.push({ type: 'ins_close', level: --state.level });\n  }\n\n  state.pos = state.posMax + 2;\n  state.posMax = max;\n  return true;\n}\n\n// Process ==highlighted text==\n\nfunction mark(state, silent) {\n  var found,\n      pos,\n      stack,\n      max = state.posMax,\n      start = state.pos,\n      lastChar,\n      nextChar;\n\n  if (state.src.charCodeAt(start) !== 0x3D/* = */) { return false; }\n  if (silent) { return false; } // don't run any pairs in validation mode\n  if (start + 4 >= max) { return false; }\n  if (state.src.charCodeAt(start + 1) !== 0x3D/* = */) { return false; }\n  if (state.level >= state.options.maxNesting) { return false; }\n\n  lastChar = start > 0 ? state.src.charCodeAt(start - 1) : -1;\n  nextChar = state.src.charCodeAt(start + 2);\n\n  if (lastChar === 0x3D/* = */) { return false; }\n  if (nextChar === 0x3D/* = */) { return false; }\n  if (nextChar === 0x20 || nextChar === 0x0A) { return false; }\n\n  pos = start + 2;\n  while (pos < max && state.src.charCodeAt(pos) === 0x3D/* = */) { pos++; }\n  if (pos !== start + 2) {\n    // sequence of 3+ markers taking as literal, same as in a emphasis\n    state.pos += pos - start;\n    if (!silent) { state.pending += state.src.slice(start, pos); }\n    return true;\n  }\n\n  state.pos = start + 2;\n  stack = 1;\n\n  while (state.pos + 1 < max) {\n    if (state.src.charCodeAt(state.pos) === 0x3D/* = */) {\n      if (state.src.charCodeAt(state.pos + 1) === 0x3D/* = */) {\n        lastChar = state.src.charCodeAt(state.pos - 1);\n        nextChar = state.pos + 2 < max ? state.src.charCodeAt(state.pos + 2) : -1;\n        if (nextChar !== 0x3D/* = */ && lastChar !== 0x3D/* = */) {\n          if (lastChar !== 0x20 && lastChar !== 0x0A) {\n            // closing '=='\n            stack--;\n          } else if (nextChar !== 0x20 && nextChar !== 0x0A) {\n            // opening '=='\n            stack++;\n          } // else {\n            //  // standalone ' == ' indented with spaces\n            // }\n          if (stack <= 0) {\n            found = true;\n            break;\n          }\n        }\n      }\n    }\n\n    state.parser.skipToken(state);\n  }\n\n  if (!found) {\n    // parser failed to find ending tag, so it's not valid emphasis\n    state.pos = start;\n    return false;\n  }\n\n  // found!\n  state.posMax = state.pos;\n  state.pos = start + 2;\n\n  if (!silent) {\n    state.push({ type: 'mark_open', level: state.level++ });\n    state.parser.tokenize(state);\n    state.push({ type: 'mark_close', level: --state.level });\n  }\n\n  state.pos = state.posMax + 2;\n  state.posMax = max;\n  return true;\n}\n\n// Process *this* and _that_\n\nfunction isAlphaNum(code) {\n  return (code >= 0x30 /* 0 */ && code <= 0x39 /* 9 */) ||\n         (code >= 0x41 /* A */ && code <= 0x5A /* Z */) ||\n         (code >= 0x61 /* a */ && code <= 0x7A /* z */);\n}\n\n// parse sequence of emphasis markers,\n// \"start\" should point at a valid marker\nfunction scanDelims(state, start) {\n  var pos = start, lastChar, nextChar, count,\n      can_open = true,\n      can_close = true,\n      max = state.posMax,\n      marker = state.src.charCodeAt(start);\n\n  lastChar = start > 0 ? state.src.charCodeAt(start - 1) : -1;\n\n  while (pos < max && state.src.charCodeAt(pos) === marker) { pos++; }\n  if (pos >= max) { can_open = false; }\n  count = pos - start;\n\n  if (count >= 4) {\n    // sequence of four or more unescaped markers can't start/end an emphasis\n    can_open = can_close = false;\n  } else {\n    nextChar = pos < max ? state.src.charCodeAt(pos) : -1;\n\n    // check whitespace conditions\n    if (nextChar === 0x20 || nextChar === 0x0A) { can_open = false; }\n    if (lastChar === 0x20 || lastChar === 0x0A) { can_close = false; }\n\n    if (marker === 0x5F /* _ */) {\n      // check if we aren't inside the word\n      if (isAlphaNum(lastChar)) { can_open = false; }\n      if (isAlphaNum(nextChar)) { can_close = false; }\n    }\n  }\n\n  return {\n    can_open: can_open,\n    can_close: can_close,\n    delims: count\n  };\n}\n\nfunction emphasis(state, silent) {\n  var startCount,\n      count,\n      found,\n      oldCount,\n      newCount,\n      stack,\n      res,\n      max = state.posMax,\n      start = state.pos,\n      marker = state.src.charCodeAt(start);\n\n  if (marker !== 0x5F/* _ */ && marker !== 0x2A /* * */) { return false; }\n  if (silent) { return false; } // don't run any pairs in validation mode\n\n  res = scanDelims(state, start);\n  startCount = res.delims;\n  if (!res.can_open) {\n    state.pos += startCount;\n    if (!silent) { state.pending += state.src.slice(start, state.pos); }\n    return true;\n  }\n\n  if (state.level >= state.options.maxNesting) { return false; }\n\n  state.pos = start + startCount;\n  stack = [ startCount ];\n\n  while (state.pos < max) {\n    if (state.src.charCodeAt(state.pos) === marker) {\n      res = scanDelims(state, state.pos);\n      count = res.delims;\n      if (res.can_close) {\n        oldCount = stack.pop();\n        newCount = count;\n\n        while (oldCount !== newCount) {\n          if (newCount < oldCount) {\n            stack.push(oldCount - newCount);\n            break;\n          }\n\n          // assert(newCount > oldCount)\n          newCount -= oldCount;\n\n          if (stack.length === 0) { break; }\n          state.pos += oldCount;\n          oldCount = stack.pop();\n        }\n\n        if (stack.length === 0) {\n          startCount = oldCount;\n          found = true;\n          break;\n        }\n        state.pos += count;\n        continue;\n      }\n\n      if (res.can_open) { stack.push(count); }\n      state.pos += count;\n      continue;\n    }\n\n    state.parser.skipToken(state);\n  }\n\n  if (!found) {\n    // parser failed to find ending tag, so it's not valid emphasis\n    state.pos = start;\n    return false;\n  }\n\n  // found!\n  state.posMax = state.pos;\n  state.pos = start + startCount;\n\n  if (!silent) {\n    if (startCount === 2 || startCount === 3) {\n      state.push({ type: 'strong_open', level: state.level++ });\n    }\n    if (startCount === 1 || startCount === 3) {\n      state.push({ type: 'em_open', level: state.level++ });\n    }\n\n    state.parser.tokenize(state);\n\n    if (startCount === 1 || startCount === 3) {\n      state.push({ type: 'em_close', level: --state.level });\n    }\n    if (startCount === 2 || startCount === 3) {\n      state.push({ type: 'strong_close', level: --state.level });\n    }\n  }\n\n  state.pos = state.posMax + startCount;\n  state.posMax = max;\n  return true;\n}\n\n// Process ~subscript~\n\n// same as UNESCAPE_MD_RE plus a space\nvar UNESCAPE_RE = /\\\\([ \\\\!\"#$%&'()*+,.\\/:;<=>?@[\\]^_`{|}~-])/g;\n\nfunction sub(state, silent) {\n  var found,\n      content,\n      max = state.posMax,\n      start = state.pos;\n\n  if (state.src.charCodeAt(start) !== 0x7E/* ~ */) { return false; }\n  if (silent) { return false; } // don't run any pairs in validation mode\n  if (start + 2 >= max) { return false; }\n  if (state.level >= state.options.maxNesting) { return false; }\n\n  state.pos = start + 1;\n\n  while (state.pos < max) {\n    if (state.src.charCodeAt(state.pos) === 0x7E/* ~ */) {\n      found = true;\n      break;\n    }\n\n    state.parser.skipToken(state);\n  }\n\n  if (!found || start + 1 === state.pos) {\n    state.pos = start;\n    return false;\n  }\n\n  content = state.src.slice(start + 1, state.pos);\n\n  // don't allow unescaped spaces/newlines inside\n  if (content.match(/(^|[^\\\\])(\\\\\\\\)*\\s/)) {\n    state.pos = start;\n    return false;\n  }\n\n  // found!\n  state.posMax = state.pos;\n  state.pos = start + 1;\n\n  if (!silent) {\n    state.push({\n      type: 'sub',\n      level: state.level,\n      content: content.replace(UNESCAPE_RE, '$1')\n    });\n  }\n\n  state.pos = state.posMax + 1;\n  state.posMax = max;\n  return true;\n}\n\n// Process ^superscript^\n\n// same as UNESCAPE_MD_RE plus a space\nvar UNESCAPE_RE$1 = /\\\\([ \\\\!\"#$%&'()*+,.\\/:;<=>?@[\\]^_`{|}~-])/g;\n\nfunction sup(state, silent) {\n  var found,\n      content,\n      max = state.posMax,\n      start = state.pos;\n\n  if (state.src.charCodeAt(start) !== 0x5E/* ^ */) { return false; }\n  if (silent) { return false; } // don't run any pairs in validation mode\n  if (start + 2 >= max) { return false; }\n  if (state.level >= state.options.maxNesting) { return false; }\n\n  state.pos = start + 1;\n\n  while (state.pos < max) {\n    if (state.src.charCodeAt(state.pos) === 0x5E/* ^ */) {\n      found = true;\n      break;\n    }\n\n    state.parser.skipToken(state);\n  }\n\n  if (!found || start + 1 === state.pos) {\n    state.pos = start;\n    return false;\n  }\n\n  content = state.src.slice(start + 1, state.pos);\n\n  // don't allow unescaped spaces/newlines inside\n  if (content.match(/(^|[^\\\\])(\\\\\\\\)*\\s/)) {\n    state.pos = start;\n    return false;\n  }\n\n  // found!\n  state.posMax = state.pos;\n  state.pos = start + 1;\n\n  if (!silent) {\n    state.push({\n      type: 'sup',\n      level: state.level,\n      content: content.replace(UNESCAPE_RE$1, '$1')\n    });\n  }\n\n  state.pos = state.posMax + 1;\n  state.posMax = max;\n  return true;\n}\n\n// Process [links](<to> \"stuff\")\n\n\nfunction links(state, silent) {\n  var labelStart,\n      labelEnd,\n      label,\n      href,\n      title,\n      pos,\n      ref,\n      code,\n      isImage = false,\n      oldPos = state.pos,\n      max = state.posMax,\n      start = state.pos,\n      marker = state.src.charCodeAt(start);\n\n  if (marker === 0x21/* ! */) {\n    isImage = true;\n    marker = state.src.charCodeAt(++start);\n  }\n\n  if (marker !== 0x5B/* [ */) { return false; }\n  if (state.level >= state.options.maxNesting) { return false; }\n\n  labelStart = start + 1;\n  labelEnd = parseLinkLabel(state, start);\n\n  // parser failed to find ']', so it's not a valid link\n  if (labelEnd < 0) { return false; }\n\n  pos = labelEnd + 1;\n  if (pos < max && state.src.charCodeAt(pos) === 0x28/* ( */) {\n    //\n    // Inline link\n    //\n\n    // [link](  <href>  \"title\"  )\n    //        ^^ skipping these spaces\n    pos++;\n    for (; pos < max; pos++) {\n      code = state.src.charCodeAt(pos);\n      if (code !== 0x20 && code !== 0x0A) { break; }\n    }\n    if (pos >= max) { return false; }\n\n    // [link](  <href>  \"title\"  )\n    //          ^^^^^^ parsing link destination\n    start = pos;\n    if (parseLinkDestination(state, pos)) {\n      href = state.linkContent;\n      pos = state.pos;\n    } else {\n      href = '';\n    }\n\n    // [link](  <href>  \"title\"  )\n    //                ^^ skipping these spaces\n    start = pos;\n    for (; pos < max; pos++) {\n      code = state.src.charCodeAt(pos);\n      if (code !== 0x20 && code !== 0x0A) { break; }\n    }\n\n    // [link](  <href>  \"title\"  )\n    //                  ^^^^^^^ parsing link title\n    if (pos < max && start !== pos && parseLinkTitle(state, pos)) {\n      title = state.linkContent;\n      pos = state.pos;\n\n      // [link](  <href>  \"title\"  )\n      //                         ^^ skipping these spaces\n      for (; pos < max; pos++) {\n        code = state.src.charCodeAt(pos);\n        if (code !== 0x20 && code !== 0x0A) { break; }\n      }\n    } else {\n      title = '';\n    }\n\n    if (pos >= max || state.src.charCodeAt(pos) !== 0x29/* ) */) {\n      state.pos = oldPos;\n      return false;\n    }\n    pos++;\n  } else {\n    //\n    // Link reference\n    //\n\n    // do not allow nested reference links\n    if (state.linkLevel > 0) { return false; }\n\n    // [foo]  [bar]\n    //      ^^ optional whitespace (can include newlines)\n    for (; pos < max; pos++) {\n      code = state.src.charCodeAt(pos);\n      if (code !== 0x20 && code !== 0x0A) { break; }\n    }\n\n    if (pos < max && state.src.charCodeAt(pos) === 0x5B/* [ */) {\n      start = pos + 1;\n      pos = parseLinkLabel(state, pos);\n      if (pos >= 0) {\n        label = state.src.slice(start, pos++);\n      } else {\n        pos = start - 1;\n      }\n    }\n\n    // covers label === '' and label === undefined\n    // (collapsed reference link and shortcut reference link respectively)\n    if (!label) {\n      if (typeof label === 'undefined') {\n        pos = labelEnd + 1;\n      }\n      label = state.src.slice(labelStart, labelEnd);\n    }\n\n    ref = state.env.references[normalizeReference(label)];\n    if (!ref) {\n      state.pos = oldPos;\n      return false;\n    }\n    href = ref.href;\n    title = ref.title;\n  }\n\n  //\n  // We found the end of the link, and know for a fact it's a valid link;\n  // so all that's left to do is to call tokenizer.\n  //\n  if (!silent) {\n    state.pos = labelStart;\n    state.posMax = labelEnd;\n\n    if (isImage) {\n      state.push({\n        type: 'image',\n        src: href,\n        title: title,\n        alt: state.src.substr(labelStart, labelEnd - labelStart),\n        level: state.level\n      });\n    } else {\n      state.push({\n        type: 'link_open',\n        href: href,\n        title: title,\n        level: state.level++\n      });\n      state.linkLevel++;\n      state.parser.tokenize(state);\n      state.linkLevel--;\n      state.push({ type: 'link_close', level: --state.level });\n    }\n  }\n\n  state.pos = pos;\n  state.posMax = max;\n  return true;\n}\n\n// Process inline footnotes (^[...])\n\n\nfunction footnote_inline(state, silent) {\n  var labelStart,\n      labelEnd,\n      footnoteId,\n      oldLength,\n      max = state.posMax,\n      start = state.pos;\n\n  if (start + 2 >= max) { return false; }\n  if (state.src.charCodeAt(start) !== 0x5E/* ^ */) { return false; }\n  if (state.src.charCodeAt(start + 1) !== 0x5B/* [ */) { return false; }\n  if (state.level >= state.options.maxNesting) { return false; }\n\n  labelStart = start + 2;\n  labelEnd = parseLinkLabel(state, start + 1);\n\n  // parser failed to find ']', so it's not a valid note\n  if (labelEnd < 0) { return false; }\n\n  // We found the end of the link, and know for a fact it's a valid link;\n  // so all that's left to do is to call tokenizer.\n  //\n  if (!silent) {\n    if (!state.env.footnotes) { state.env.footnotes = {}; }\n    if (!state.env.footnotes.list) { state.env.footnotes.list = []; }\n    footnoteId = state.env.footnotes.list.length;\n\n    state.pos = labelStart;\n    state.posMax = labelEnd;\n\n    state.push({\n      type: 'footnote_ref',\n      id: footnoteId,\n      level: state.level\n    });\n    state.linkLevel++;\n    oldLength = state.tokens.length;\n    state.parser.tokenize(state);\n    state.env.footnotes.list[footnoteId] = { tokens: state.tokens.splice(oldLength) };\n    state.linkLevel--;\n  }\n\n  state.pos = labelEnd + 1;\n  state.posMax = max;\n  return true;\n}\n\n// Process footnote references ([^...])\n\nfunction footnote_ref(state, silent) {\n  var label,\n      pos,\n      footnoteId,\n      footnoteSubId,\n      max = state.posMax,\n      start = state.pos;\n\n  // should be at least 4 chars - \"[^x]\"\n  if (start + 3 > max) { return false; }\n\n  if (!state.env.footnotes || !state.env.footnotes.refs) { return false; }\n  if (state.src.charCodeAt(start) !== 0x5B/* [ */) { return false; }\n  if (state.src.charCodeAt(start + 1) !== 0x5E/* ^ */) { return false; }\n  if (state.level >= state.options.maxNesting) { return false; }\n\n  for (pos = start + 2; pos < max; pos++) {\n    if (state.src.charCodeAt(pos) === 0x20) { return false; }\n    if (state.src.charCodeAt(pos) === 0x0A) { return false; }\n    if (state.src.charCodeAt(pos) === 0x5D /* ] */) {\n      break;\n    }\n  }\n\n  if (pos === start + 2) { return false; } // no empty footnote labels\n  if (pos >= max) { return false; }\n  pos++;\n\n  label = state.src.slice(start + 2, pos - 1);\n  if (typeof state.env.footnotes.refs[':' + label] === 'undefined') { return false; }\n\n  if (!silent) {\n    if (!state.env.footnotes.list) { state.env.footnotes.list = []; }\n\n    if (state.env.footnotes.refs[':' + label] < 0) {\n      footnoteId = state.env.footnotes.list.length;\n      state.env.footnotes.list[footnoteId] = { label: label, count: 0 };\n      state.env.footnotes.refs[':' + label] = footnoteId;\n    } else {\n      footnoteId = state.env.footnotes.refs[':' + label];\n    }\n\n    footnoteSubId = state.env.footnotes.list[footnoteId].count;\n    state.env.footnotes.list[footnoteId].count++;\n\n    state.push({\n      type: 'footnote_ref',\n      id: footnoteId,\n      subId: footnoteSubId,\n      level: state.level\n    });\n  }\n\n  state.pos = pos;\n  state.posMax = max;\n  return true;\n}\n\n// List of valid url schemas, accorting to commonmark spec\n// http://jgm.github.io/CommonMark/spec.html#autolinks\n\nvar url_schemas = [\n  'coap',\n  'doi',\n  'javascript',\n  'aaa',\n  'aaas',\n  'about',\n  'acap',\n  'cap',\n  'cid',\n  'crid',\n  'data',\n  'dav',\n  'dict',\n  'dns',\n  'file',\n  'ftp',\n  'geo',\n  'go',\n  'gopher',\n  'h323',\n  'http',\n  'https',\n  'iax',\n  'icap',\n  'im',\n  'imap',\n  'info',\n  'ipp',\n  'iris',\n  'iris.beep',\n  'iris.xpc',\n  'iris.xpcs',\n  'iris.lwz',\n  'ldap',\n  'mailto',\n  'mid',\n  'msrp',\n  'msrps',\n  'mtqp',\n  'mupdate',\n  'news',\n  'nfs',\n  'ni',\n  'nih',\n  'nntp',\n  'opaquelocktoken',\n  'pop',\n  'pres',\n  'rtsp',\n  'service',\n  'session',\n  'shttp',\n  'sieve',\n  'sip',\n  'sips',\n  'sms',\n  'snmp',\n  'soap.beep',\n  'soap.beeps',\n  'tag',\n  'tel',\n  'telnet',\n  'tftp',\n  'thismessage',\n  'tn3270',\n  'tip',\n  'tv',\n  'urn',\n  'vemmi',\n  'ws',\n  'wss',\n  'xcon',\n  'xcon-userid',\n  'xmlrpc.beep',\n  'xmlrpc.beeps',\n  'xmpp',\n  'z39.50r',\n  'z39.50s',\n  'adiumxtra',\n  'afp',\n  'afs',\n  'aim',\n  'apt',\n  'attachment',\n  'aw',\n  'beshare',\n  'bitcoin',\n  'bolo',\n  'callto',\n  'chrome',\n  'chrome-extension',\n  'com-eventbrite-attendee',\n  'content',\n  'cvs',\n  'dlna-playsingle',\n  'dlna-playcontainer',\n  'dtn',\n  'dvb',\n  'ed2k',\n  'facetime',\n  'feed',\n  'finger',\n  'fish',\n  'gg',\n  'git',\n  'gizmoproject',\n  'gtalk',\n  'hcp',\n  'icon',\n  'ipn',\n  'irc',\n  'irc6',\n  'ircs',\n  'itms',\n  'jar',\n  'jms',\n  'keyparc',\n  'lastfm',\n  'ldaps',\n  'magnet',\n  'maps',\n  'market',\n  'message',\n  'mms',\n  'ms-help',\n  'msnim',\n  'mumble',\n  'mvn',\n  'notes',\n  'oid',\n  'palm',\n  'paparazzi',\n  'platform',\n  'proxy',\n  'psyc',\n  'query',\n  'res',\n  'resource',\n  'rmi',\n  'rsync',\n  'rtmp',\n  'secondlife',\n  'sftp',\n  'sgn',\n  'skype',\n  'smb',\n  'soldat',\n  'spotify',\n  'ssh',\n  'steam',\n  'svn',\n  'teamspeak',\n  'things',\n  'udp',\n  'unreal',\n  'ut2004',\n  'ventrilo',\n  'view-source',\n  'webcal',\n  'wtai',\n  'wyciwyg',\n  'xfire',\n  'xri',\n  'ymsgr'\n];\n\n// Process autolinks '<protocol:...>'\n\n\n/*eslint max-len:0*/\nvar EMAIL_RE    = /^<([a-zA-Z0-9.!#$%&'*+\\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)>/;\nvar AUTOLINK_RE = /^<([a-zA-Z.\\-]{1,25}):([^<>\\x00-\\x20]*)>/;\n\n\nfunction autolink(state, silent) {\n  var tail, linkMatch, emailMatch, url, fullUrl, pos = state.pos;\n\n  if (state.src.charCodeAt(pos) !== 0x3C/* < */) { return false; }\n\n  tail = state.src.slice(pos);\n\n  if (tail.indexOf('>') < 0) { return false; }\n\n  linkMatch = tail.match(AUTOLINK_RE);\n\n  if (linkMatch) {\n    if (url_schemas.indexOf(linkMatch[1].toLowerCase()) < 0) { return false; }\n\n    url = linkMatch[0].slice(1, -1);\n    fullUrl = normalizeLink(url);\n    if (!state.parser.validateLink(url)) { return false; }\n\n    if (!silent) {\n      state.push({\n        type: 'link_open',\n        href: fullUrl,\n        level: state.level\n      });\n      state.push({\n        type: 'text',\n        content: url,\n        level: state.level + 1\n      });\n      state.push({ type: 'link_close', level: state.level });\n    }\n\n    state.pos += linkMatch[0].length;\n    return true;\n  }\n\n  emailMatch = tail.match(EMAIL_RE);\n\n  if (emailMatch) {\n\n    url = emailMatch[0].slice(1, -1);\n\n    fullUrl = normalizeLink('mailto:' + url);\n    if (!state.parser.validateLink(fullUrl)) { return false; }\n\n    if (!silent) {\n      state.push({\n        type: 'link_open',\n        href: fullUrl,\n        level: state.level\n      });\n      state.push({\n        type: 'text',\n        content: url,\n        level: state.level + 1\n      });\n      state.push({ type: 'link_close', level: state.level });\n    }\n\n    state.pos += emailMatch[0].length;\n    return true;\n  }\n\n  return false;\n}\n\n// Regexps to match html elements\n\nfunction replace$1(regex, options) {\n  regex = regex.source;\n  options = options || '';\n\n  return function self(name, val) {\n    if (!name) {\n      return new RegExp(regex, options);\n    }\n    val = val.source || val;\n    regex = regex.replace(name, val);\n    return self;\n  };\n}\n\n\nvar attr_name     = /[a-zA-Z_:][a-zA-Z0-9:._-]*/;\n\nvar unquoted      = /[^\"'=<>`\\x00-\\x20]+/;\nvar single_quoted = /'[^']*'/;\nvar double_quoted = /\"[^\"]*\"/;\n\n/*eslint no-spaced-func:0*/\nvar attr_value  = replace$1(/(?:unquoted|single_quoted|double_quoted)/)\n                    ('unquoted', unquoted)\n                    ('single_quoted', single_quoted)\n                    ('double_quoted', double_quoted)\n                    ();\n\nvar attribute   = replace$1(/(?:\\s+attr_name(?:\\s*=\\s*attr_value)?)/)\n                    ('attr_name', attr_name)\n                    ('attr_value', attr_value)\n                    ();\n\nvar open_tag    = replace$1(/<[A-Za-z][A-Za-z0-9]*attribute*\\s*\\/?>/)\n                    ('attribute', attribute)\n                    ();\n\nvar close_tag   = /<\\/[A-Za-z][A-Za-z0-9]*\\s*>/;\nvar comment     = /<!---->|<!--(?:-?[^>-])(?:-?[^-])*-->/;\nvar processing  = /<[?].*?[?]>/;\nvar declaration = /<![A-Z]+\\s+[^>]*>/;\nvar cdata       = /<!\\[CDATA\\[[\\s\\S]*?\\]\\]>/;\n\nvar HTML_TAG_RE = replace$1(/^(?:open_tag|close_tag|comment|processing|declaration|cdata)/)\n  ('open_tag', open_tag)\n  ('close_tag', close_tag)\n  ('comment', comment)\n  ('processing', processing)\n  ('declaration', declaration)\n  ('cdata', cdata)\n  ();\n\n// Process html tags\n\n\nfunction isLetter$2(ch) {\n  /*eslint no-bitwise:0*/\n  var lc = ch | 0x20; // to lower case\n  return (lc >= 0x61/* a */) && (lc <= 0x7a/* z */);\n}\n\n\nfunction htmltag(state, silent) {\n  var ch, match, max, pos = state.pos;\n\n  if (!state.options.html) { return false; }\n\n  // Check start\n  max = state.posMax;\n  if (state.src.charCodeAt(pos) !== 0x3C/* < */ ||\n      pos + 2 >= max) {\n    return false;\n  }\n\n  // Quick fail on second char\n  ch = state.src.charCodeAt(pos + 1);\n  if (ch !== 0x21/* ! */ &&\n      ch !== 0x3F/* ? */ &&\n      ch !== 0x2F/* / */ &&\n      !isLetter$2(ch)) {\n    return false;\n  }\n\n  match = state.src.slice(pos).match(HTML_TAG_RE);\n  if (!match) { return false; }\n\n  if (!silent) {\n    state.push({\n      type: 'htmltag',\n      content: state.src.slice(pos, pos + match[0].length),\n      level: state.level\n    });\n  }\n  state.pos += match[0].length;\n  return true;\n}\n\n// Process html entity - &#123;, &#xAF;, &quot;, ...\n\n\nvar DIGITAL_RE = /^&#((?:x[a-f0-9]{1,8}|[0-9]{1,8}));/i;\nvar NAMED_RE   = /^&([a-z][a-z0-9]{1,31});/i;\n\n\nfunction entity(state, silent) {\n  var ch, code, match, pos = state.pos, max = state.posMax;\n\n  if (state.src.charCodeAt(pos) !== 0x26/* & */) { return false; }\n\n  if (pos + 1 < max) {\n    ch = state.src.charCodeAt(pos + 1);\n\n    if (ch === 0x23 /* # */) {\n      match = state.src.slice(pos).match(DIGITAL_RE);\n      if (match) {\n        if (!silent) {\n          code = match[1][0].toLowerCase() === 'x' ? parseInt(match[1].slice(1), 16) : parseInt(match[1], 10);\n          state.pending += isValidEntityCode(code) ? fromCodePoint(code) : fromCodePoint(0xFFFD);\n        }\n        state.pos += match[0].length;\n        return true;\n      }\n    } else {\n      match = state.src.slice(pos).match(NAMED_RE);\n      if (match) {\n        var decoded = decodeEntity(match[1]);\n        if (match[1] !== decoded) {\n          if (!silent) { state.pending += decoded; }\n          state.pos += match[0].length;\n          return true;\n        }\n      }\n    }\n  }\n\n  if (!silent) { state.pending += '&'; }\n  state.pos++;\n  return true;\n}\n\n/**\n * Inline Parser `rules`\n */\n\nvar _rules$2 = [\n  [ 'text',            text ],\n  [ 'newline',         newline ],\n  [ 'escape',          escape ],\n  [ 'backticks',       backticks ],\n  [ 'del',             del ],\n  [ 'ins',             ins ],\n  [ 'mark',            mark ],\n  [ 'emphasis',        emphasis ],\n  [ 'sub',             sub ],\n  [ 'sup',             sup ],\n  [ 'links',           links ],\n  [ 'footnote_inline', footnote_inline ],\n  [ 'footnote_ref',    footnote_ref ],\n  [ 'autolink',        autolink ],\n  [ 'htmltag',         htmltag ],\n  [ 'entity',          entity ]\n];\n\n/**\n * Inline Parser class. Note that link validation is stricter\n * in Remarkable than what is specified by CommonMark. If you\n * want to change this you can use a custom validator.\n *\n * @api private\n */\n\nfunction ParserInline() {\n  this.ruler = new Ruler();\n  for (var i = 0; i < _rules$2.length; i++) {\n    this.ruler.push(_rules$2[i][0], _rules$2[i][1]);\n  }\n\n  // Can be overridden with a custom validator\n  this.validateLink = validateLink;\n}\n\n/**\n * Skip a single token by running all rules in validation mode.\n * Returns `true` if any rule reports success.\n *\n * @param  {Object} `state`\n * @api privage\n */\n\nParserInline.prototype.skipToken = function (state) {\n  var rules = this.ruler.getRules('');\n  var len = rules.length;\n  var pos = state.pos;\n  var i, cached_pos;\n\n  if ((cached_pos = state.cacheGet(pos)) > 0) {\n    state.pos = cached_pos;\n    return;\n  }\n\n  for (i = 0; i < len; i++) {\n    if (rules[i](state, true)) {\n      state.cacheSet(pos, state.pos);\n      return;\n    }\n  }\n\n  state.pos++;\n  state.cacheSet(pos, state.pos);\n};\n\n/**\n * Generate tokens for the given input range.\n *\n * @param  {Object} `state`\n * @api private\n */\n\nParserInline.prototype.tokenize = function (state) {\n  var rules = this.ruler.getRules('');\n  var len = rules.length;\n  var end = state.posMax;\n  var ok, i;\n\n  while (state.pos < end) {\n\n    // Try all possible rules.\n    // On success, the rule should:\n    //\n    // - update `state.pos`\n    // - update `state.tokens`\n    // - return true\n    for (i = 0; i < len; i++) {\n      ok = rules[i](state, false);\n\n      if (ok) {\n        break;\n      }\n    }\n\n    if (ok) {\n      if (state.pos >= end) { break; }\n      continue;\n    }\n\n    state.pending += state.src[state.pos++];\n  }\n\n  if (state.pending) {\n    state.pushPending();\n  }\n};\n\n/**\n * Parse the given input string.\n *\n * @param  {String} `str`\n * @param  {Object} `options`\n * @param  {Object} `env`\n * @param  {Array} `outTokens`\n * @api private\n */\n\nParserInline.prototype.parse = function (str, options, env, outTokens) {\n  var state = new StateInline(str, this, options, env, outTokens);\n  this.tokenize(state);\n};\n\n/**\n * Validate the given `url` by checking for bad protocols.\n *\n * @param  {String} `url`\n * @return {Boolean}\n */\n\nfunction validateLink(url) {\n  var BAD_PROTOCOLS = [ 'vbscript', 'javascript', 'file', 'data' ];\n  var str = url.trim().toLowerCase();\n  // Care about digital entities \"javascript&#x3A;alert(1)\"\n  str = replaceEntities(str);\n  if (str.indexOf(':') !== -1 && BAD_PROTOCOLS.indexOf(str.split(':')[0]) !== -1) {\n    return false;\n  }\n  return true;\n}\n\n// Remarkable default options\n\nvar defaultConfig = {\n  options: {\n    html:         false,        // Enable HTML tags in source\n    xhtmlOut:     false,        // Use '/' to close single tags (<br />)\n    breaks:       false,        // Convert '\\n' in paragraphs into <br>\n    langPrefix:   'language-',  // CSS language prefix for fenced blocks\n    linkTarget:   '',           // set target to open link in\n\n    // Enable some language-neutral replacements + quotes beautification\n    typographer:  false,\n\n    // Double + single quotes replacement pairs, when typographer enabled,\n    // and smartquotes on. Set doubles to '«»' for Russian, '„“' for German.\n    quotes: '“”‘’',\n\n    // Highlighter function. Should return escaped HTML,\n    // or '' if input not changed\n    //\n    // function (/*str, lang*/) { return ''; }\n    //\n    highlight: null,\n\n    maxNesting:   20            // Internal protection, recursion limit\n  },\n\n  components: {\n\n    core: {\n      rules: [\n        'block',\n        'inline',\n        'references',\n        'replacements',\n        'smartquotes',\n        'references',\n        'abbr2',\n        'footnote_tail'\n      ]\n    },\n\n    block: {\n      rules: [\n        'blockquote',\n        'code',\n        'fences',\n        'footnote',\n        'heading',\n        'hr',\n        'htmlblock',\n        'lheading',\n        'list',\n        'paragraph',\n        'table'\n      ]\n    },\n\n    inline: {\n      rules: [\n        'autolink',\n        'backticks',\n        'del',\n        'emphasis',\n        'entity',\n        'escape',\n        'footnote_ref',\n        'htmltag',\n        'links',\n        'newline',\n        'text'\n      ]\n    }\n  }\n};\n\n// Remarkable default options\n\nvar fullConfig = {\n  options: {\n    html:         false,        // Enable HTML tags in source\n    xhtmlOut:     false,        // Use '/' to close single tags (<br />)\n    breaks:       false,        // Convert '\\n' in paragraphs into <br>\n    langPrefix:   'language-',  // CSS language prefix for fenced blocks\n    linkTarget:   '',           // set target to open link in\n\n    // Enable some language-neutral replacements + quotes beautification\n    typographer:  false,\n\n    // Double + single quotes replacement pairs, when typographer enabled,\n    // and smartquotes on. Set doubles to '«»' for Russian, '„“' for German.\n    quotes:       '“”‘’',\n\n    // Highlighter function. Should return escaped HTML,\n    // or '' if input not changed\n    //\n    // function (/*str, lang*/) { return ''; }\n    //\n    highlight:     null,\n\n    maxNesting:    20            // Internal protection, recursion limit\n  },\n\n  components: {\n    // Don't restrict core/block/inline rules\n    core: {},\n    block: {},\n    inline: {}\n  }\n};\n\n// Commonmark default options\n\nvar commonmarkConfig = {\n  options: {\n    html:         true,         // Enable HTML tags in source\n    xhtmlOut:     true,         // Use '/' to close single tags (<br />)\n    breaks:       false,        // Convert '\\n' in paragraphs into <br>\n    langPrefix:   'language-',  // CSS language prefix for fenced blocks\n    linkTarget:   '',           // set target to open link in\n\n    // Enable some language-neutral replacements + quotes beautification\n    typographer:  false,\n\n    // Double + single quotes replacement pairs, when typographer enabled,\n    // and smartquotes on. Set doubles to '«»' for Russian, '„“' for German.\n    quotes: '“”‘’',\n\n    // Highlighter function. Should return escaped HTML,\n    // or '' if input not changed\n    //\n    // function (/*str, lang*/) { return ''; }\n    //\n    highlight: null,\n\n    maxNesting:   20            // Internal protection, recursion limit\n  },\n\n  components: {\n\n    core: {\n      rules: [\n        'block',\n        'inline',\n        'references',\n        'abbr2'\n      ]\n    },\n\n    block: {\n      rules: [\n        'blockquote',\n        'code',\n        'fences',\n        'heading',\n        'hr',\n        'htmlblock',\n        'lheading',\n        'list',\n        'paragraph'\n      ]\n    },\n\n    inline: {\n      rules: [\n        'autolink',\n        'backticks',\n        'emphasis',\n        'entity',\n        'escape',\n        'htmltag',\n        'links',\n        'newline',\n        'text'\n      ]\n    }\n  }\n};\n\n/**\n * Preset configs\n */\n\nvar config = {\n  'default': defaultConfig,\n  'full': fullConfig,\n  'commonmark': commonmarkConfig\n};\n\n/**\n * The `StateCore` class manages state.\n *\n * @param {Object} `instance` Remarkable instance\n * @param {String} `str` Markdown string\n * @param {Object} `env`\n */\n\nfunction StateCore(instance, str, env) {\n  this.src = str;\n  this.env = env;\n  this.options = instance.options;\n  this.tokens = [];\n  this.inlineMode = false;\n\n  this.inline = instance.inline;\n  this.block = instance.block;\n  this.renderer = instance.renderer;\n  this.typographer = instance.typographer;\n}\n\n/**\n * The main `Remarkable` class. Create an instance of\n * `Remarkable` with a `preset` and/or `options`.\n *\n * @param {String} `preset` If no preset is given, `default` is used.\n * @param {Object} `options`\n */\n\nfunction Remarkable(preset, options) {\n  if (typeof preset !== 'string') {\n    options = preset;\n    preset = 'default';\n  }\n\n  if (options && options.linkify != null) {\n    console.warn(\n      'linkify option is removed. Use linkify plugin instead:\\n\\n' +\n      'import Remarkable from \\'remarkable\\';\\n' +\n      'import linkify from \\'remarkable/linkify\\';\\n' +\n      'new Remarkable().use(linkify)\\n'\n    );\n  }\n\n  this.inline   = new ParserInline();\n  this.block    = new ParserBlock();\n  this.core     = new Core();\n  this.renderer = new Renderer();\n  this.ruler    = new Ruler();\n\n  this.options  = {};\n  this.configure(config[preset]);\n  this.set(options || {});\n}\n\n/**\n * Set options as an alternative to passing them\n * to the constructor.\n *\n * ```js\n * md.set({typographer: true});\n * ```\n * @param {Object} `options`\n * @api public\n */\n\nRemarkable.prototype.set = function (options) {\n  assign(this.options, options);\n};\n\n/**\n * Batch loader for components rules states, and options\n *\n * @param  {Object} `presets`\n */\n\nRemarkable.prototype.configure = function (presets) {\n  var self = this;\n\n  if (!presets) { throw new Error('Wrong `remarkable` preset, check name/content'); }\n  if (presets.options) { self.set(presets.options); }\n  if (presets.components) {\n    Object.keys(presets.components).forEach(function (name) {\n      if (presets.components[name].rules) {\n        self[name].ruler.enable(presets.components[name].rules, true);\n      }\n    });\n  }\n};\n\n/**\n * Use a plugin.\n *\n * ```js\n * var md = new Remarkable();\n *\n * md.use(plugin1)\n *   .use(plugin2, opts)\n *   .use(plugin3);\n * ```\n *\n * @param  {Function} `plugin`\n * @param  {Object} `options`\n * @return {Object} `Remarkable` for chaining\n */\n\nRemarkable.prototype.use = function (plugin, options) {\n  plugin(this, options);\n  return this;\n};\n\n\n/**\n * Parse the input `string` and return a tokens array.\n * Modifies `env` with definitions data.\n *\n * @param  {String} `string`\n * @param  {Object} `env`\n * @return {Array} Array of tokens\n */\n\nRemarkable.prototype.parse = function (str, env) {\n  var state = new StateCore(this, str, env);\n  this.core.process(state);\n  return state.tokens;\n};\n\n/**\n * The main `.render()` method that does all the magic :)\n *\n * @param  {String} `string`\n * @param  {Object} `env`\n * @return {String} Rendered HTML.\n */\n\nRemarkable.prototype.render = function (str, env) {\n  env = env || {};\n  return this.renderer.render(this.parse(str, env), this.options, env);\n};\n\n/**\n * Parse the given content `string` as a single string.\n *\n * @param  {String} `string`\n * @param  {Object} `env`\n * @return {Array} Array of tokens\n */\n\nRemarkable.prototype.parseInline = function (str, env) {\n  var state = new StateCore(this, str, env);\n  state.inlineMode = true;\n  this.core.process(state);\n  return state.tokens;\n};\n\n/**\n * Render a single content `string`, without wrapping it\n * to paragraphs\n *\n * @param  {String} `str`\n * @param  {Object} `env`\n * @return {String}\n */\n\nRemarkable.prototype.renderInline = function (str, env) {\n  env = env || {};\n  return this.renderer.render(this.parseInline(str, env), this.options, env);\n};\n\nexport { Remarkable, utils };\n"],"names":["Container","AtRule","constructor","defaults","super","this","type","append","children","proxyOf","nodes","prepend","module","exports","default","registerAtRule","Node","Comment","parse","Root","Rule","Declaration","isClean","my","cleanSource","map","i","source","markTreeDirty","node","child","normalize","last","push","markDirty","cleanRaws","keepBetween","each","callback","index","result","iterator","getIterator","indexes","length","every","condition","lastEach","getProxyProcessor","get","prop","startsWith","args","toProxy","cb","other","root","set","value","indexOf","insertAfter","exist","add","existIndex","reverse","splice","id","insertBefore","sample","Array","isArray","slice","parent","removeChild","Error","String","selector","selectors","name","text","processed","rebuild","raws","before","replace","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","variable","LazyResult","Processor","Document","toResult","lazy","stringify","registerLazyResult","registerProcessor","Input","PreviousMap","fromJSON","json","inputs","n","ownInputs","input","inputHydrated","__proto__","inputId","nanoid","isAbsolute","resolve","SourceMapConsumer","SourceMapGenerator","fileURLToPath","pathToFileURL","fromOffsetCache","Symbol","sourceMapAvailable","Boolean","pathAvailable","hasBOM","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","document","rule","PLUGIN_PROPS","AtRuleExit","CommentExit","DeclarationExit","DocumentExit","Once","OnceExit","postcssPlugin","prepare","RootExit","RuleExit","NOT_VISITORS","CHILDREN","isPromise","obj","then","getEvents","key","toLowerCase","toStack","events","eventIndex","visitorIndex","visitors","cleanMarks","postcss","processor","stringified","inline","prev","parser","syntax","helpers","plugins","async","Promise","reject","processing","runAsync","onRejected","catch","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","spaces","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","childless","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","stringRepresentation","endIndex","raw","defaultType","remove","replaceWith","bookmark","foundSelf","_","fixed","emitInputs","inputsNextIndex","proxyCache","Proxy","warn","Parser","tokenizer","SAFE_COMMENT_NEIGHBOR","empty","findLastWithPosition","tokens","token","createTokenizer","shift","unnamedAtrule","init","open","params","brackets","endOfFile","nextToken","getPosition","spacesAndCommentsFromEnd","afterName","spacesAndCommentsFromStart","checkMissedSemicolon","colon","founded","element","entries","doubleColon","left","right","customProperty","unknownWord","firstSpaces","precheckMissedSemicolon","important","stringFrom","spacesFromEnd","cache","hasWord","concat","emptyRule","unexpectedClose","endFile","unclosedBlock","freeSemicolon","ownSemicolon","bracket","back","unclosedBracket","clean","reduce","lastTokenType","Warning","initializer","warningPrinted","creator","LANG","transformer","process","processOpts","pluginOpts","atRule","existsSync","readFileSync","fromBase64","atob","loadAnnotation","startWith","loadMap","decodeInline","baseCharsetUri","baseUri","charsetUri","uri","uriMatch","decodeURIComponent","substr","baseUriMatch","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","capitalize","toUpperCase","builder","rawValue","block","beforeAfter","detect","buf","depth","step","body","own","rawCache","method","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","options","quote","currentToken","escaped","escapePos","valueOf","ignoreErrors","buffer","returned","unclosed","what","ignoreUnclosed","controlChar","fromCharCode","lastIndex","charAt","printed","range","opt","textarea","decodeEntity","createElement","innerHTML","hasOwn","has","object","sources","arguments","TypeError","UNESCAPE_MD_RE","unescapeMd","isValidEntityCode","c","fromCodePoint","surrogate1","surrogate2","NAMED_ENTITY_RE","DIGITAL_ENTITY_TEST_RE","replaceEntityPattern","decoded","parseInt","replaceEntities","HTML_ESCAPE_TEST_RE","HTML_ESCAPE_REPLACE_RE","HTML_REPLACEMENTS","replaceUnsafeChar","ch","escapeHtml","rules","idx","tight","blockquote_open","blockquote_close","getBreak","fence","env","instance","fences","fenceName","highlighted","langClass","langPrefix","langName","fence_custom","apply","heading_open","hLevel","heading_close","hr","xhtmlOut","bullet_list_open","bullet_list_close","list_item_open","list_item_close","ordered_list_open","order","ordered_list_close","paragraph_open","paragraph_close","addBreak","link_open","title","target","linkTarget","href","link_close","image","src","alt","suffix","table_open","table_close","thead_open","thead_close","tbody_open","tbody_close","tr_open","tr_close","th_open","align","th_close","td_open","td_close","strong_open","strong_close","em_open","em_close","del_open","del_close","ins_open","ins_close","mark_open","mark_close","sub","sup","hardbreak","softbreak","breaks","htmlblock","htmltag","abbr_open","abbr_close","footnote_ref","Number","subId","footnote_block_open","footnote_block_close","footnote_open","footnote_close","footnote_anchor","dl_open","dt_open","dd_open","dl_close","dt_close","dd_close","Renderer","Ruler","__rules__","__cache__","state","inlineMode","level","StateInline","parserInline","outTokens","posMax","pending","pendingLevel","isInLabel","linkLevel","linkContent","labelUnmatchedScopes","parseLinkLabel","found","marker","labelEnd","oldPos","oldFlag","skipToken","parseAbbr","label","abbreviations","abbr","normalizeLink","decodeURI","parseLinkDestination","link","validateLink","parseLinkTitle","normalizeReference","parseReference","references","tok","footnote_block","t","lastParagraph","currentLabel","insideRef","refTokens","footnotes","count","renderInline","_rules","len","render","__find__","__compile__","chains","enabled","altName","chain","fn","at","beforeName","ruleName","enable","strict","disable","getRules","chainName","pushPending","cacheSet","val","cacheGet","PUNCT_CHARS","regEscape","abbr2","reg","m","regText","blockTokens","abbrRegExp","x","sort","a","b","exec","RARE_RE","SCOPED_ABBR_RE","SCOPED_ABBR","replaceScopedAbbr","inlineTokens","blkIdx","typographer","QUOTE_TEST_RE","QUOTE_RE","PUNCT_RE","APOSTROPHE","isLetter","replaceAt","smartquotes","thisLevel","lastSpace","nextSpace","item","canOpen","canClose","isSingle","OUTER","single","quotes","Core","ruler","StateBlock","indent_found","bMarks","eMarks","tShift","blkIndent","lineMax","parentType","ddIndent","startLine","nextLine","isEmpty","getLines","silent","mem","haveEndMarker","skipChars","skipSpaces","blockquote","lastLineEmpty","oldTShift","oldBMarks","oldIndent","oldParentType","terminatorRules","terminate","maxNesting","tokenize","cnt","skipBulletListMarker","skipOrderedListMarker","markTightParagraphs","oldTight","posAfterMarker","indentAfterMarker","markerValue","markerCharCode","isOrdered","contentStart","listTokIdx","prevEmptyEnd","listLines","itemLines","footnote","oldBMark","refs","heading","tmp","skipCharsBack","lheading","skipEmptyLines","begin","keepLastLF","queue","html_blocks","HTML_TAG_OPEN_RE","HTML_TAG_CLOSE_RE","isLetter$1","lc","html","getLine","table","lineText","rows","cell","aligns","tableLines","tbodyLines","skipMarker","markTightParagraphs$1","deflist","ddLine","dtLine","oldDDIndent","paragraph","_rules$1","ParserBlock","ok","hasEmptyLines","TABS_SCAN_RE","NEWLINES_RE","SPACES_RE","isTerminatorChar","newline","pmax","lineStart","lastTabPos","ESCAPED","backticks","matchStart","matchEnd","del","lastChar","nextChar","ins","isAlphaNum","scanDelims","can_open","can_close","delims","emphasis","startCount","oldCount","newCount","res","UNESCAPE_RE","UNESCAPE_RE$1","links","labelStart","ref","isImage","footnote_inline","footnoteId","oldLength","footnoteSubId","url_schemas","EMAIL_RE","AUTOLINK_RE","autolink","tail","linkMatch","emailMatch","fullUrl","replace$1","regex","attr_name","unquoted","single_quoted","double_quoted","attr_value","attribute","open_tag","close_tag","declaration","cdata","HTML_TAG_RE","isLetter$2","DIGITAL_RE","NAMED_RE","entity","_rules$2","ParserInline","BAD_PROTOCOLS","cached_pos","defaultConfig","components","core","fullConfig","commonmarkConfig","config","StateCore","renderer","Remarkable","preset","linkify","configure","presets","parseInline"],"sourceRoot":""}