{"version":3,"file":"static/npm.micromark.130ac0c5.js","mappings":"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","sources":["../node_modules/micromark/dist/character/ascii-alpha.js","../node_modules/micromark/dist/character/ascii-alphanumeric.js","../node_modules/micromark/dist/character/ascii-atext.js","../node_modules/micromark/dist/character/ascii-control.js","../node_modules/micromark/dist/character/ascii-digit.js","../node_modules/micromark/dist/character/ascii-hex-digit.js","../node_modules/micromark/dist/character/ascii-punctuation.js","../node_modules/micromark/dist/character/markdown-line-ending-or-space.js","../node_modules/micromark/dist/character/markdown-line-ending.js","../node_modules/micromark/dist/character/markdown-space.js","../node_modules/micromark/dist/character/unicode-punctuation.js","../node_modules/micromark/dist/character/unicode-whitespace.js","../node_modules/micromark/dist/constant/assign.js","../node_modules/micromark/dist/constant/from-char-code.js","../node_modules/micromark/dist/constant/has-own-property.js","../node_modules/micromark/dist/constant/html-block-names.js","../node_modules/micromark/dist/constant/html-raw-names.js","../node_modules/micromark/dist/constant/splice.js","../node_modules/micromark/dist/constant/unicode-punctuation-regex.js","../node_modules/micromark/dist/constructs.js","../node_modules/micromark/dist/initialize/content.js","../node_modules/micromark/dist/initialize/document.js","../node_modules/micromark/dist/initialize/flow.js","../node_modules/micromark/dist/initialize/text.js","../node_modules/micromark/dist/parse.js","../node_modules/micromark/dist/postprocess.js","../node_modules/micromark/dist/preprocess.js","../node_modules/micromark/dist/tokenize/attention.js","../node_modules/micromark/dist/tokenize/autolink.js","../node_modules/micromark/dist/tokenize/block-quote.js","../node_modules/micromark/dist/tokenize/character-escape.js","../node_modules/micromark/dist/tokenize/character-reference.js","../node_modules/micromark/dist/tokenize/code-fenced.js","../node_modules/micromark/dist/tokenize/code-indented.js","../node_modules/micromark/dist/tokenize/code-text.js","../node_modules/micromark/dist/tokenize/content.js","../node_modules/micromark/dist/tokenize/definition.js","../node_modules/micromark/dist/tokenize/factory-destination.js","../node_modules/micromark/dist/tokenize/factory-label.js","../node_modules/micromark/dist/tokenize/factory-space.js","../node_modules/micromark/dist/tokenize/factory-title.js","../node_modules/micromark/dist/tokenize/factory-whitespace.js","../node_modules/micromark/dist/tokenize/hard-break-escape.js","../node_modules/micromark/dist/tokenize/heading-atx.js","../node_modules/micromark/dist/tokenize/html-flow.js","../node_modules/micromark/dist/tokenize/html-text.js","../node_modules/micromark/dist/tokenize/label-end.js","../node_modules/micromark/dist/tokenize/label-start-image.js","../node_modules/micromark/dist/tokenize/label-start-link.js","../node_modules/micromark/dist/tokenize/line-ending.js","../node_modules/micromark/dist/tokenize/list.js","../node_modules/micromark/dist/tokenize/partial-blank-line.js","../node_modules/micromark/dist/tokenize/setext-underline.js","../node_modules/micromark/dist/tokenize/thematic-break.js","../node_modules/micromark/dist/util/chunked-push.js","../node_modules/micromark/dist/util/chunked-splice.js","../node_modules/micromark/dist/util/classify-character.js","../node_modules/micromark/dist/util/combine-extensions.js","../node_modules/micromark/dist/util/create-tokenizer.js","../node_modules/micromark/dist/util/miniflat.js","../node_modules/micromark/dist/util/move-point.js","../node_modules/micromark/dist/util/normalize-identifier.js","../node_modules/micromark/dist/util/prefix-size.js","../node_modules/micromark/dist/util/regex-check.js","../node_modules/micromark/dist/util/resolve-all.js","../node_modules/micromark/dist/util/safe-from-int.js","../node_modules/micromark/dist/util/serialize-chunks.js","../node_modules/micromark/dist/util/shallow.js","../node_modules/micromark/dist/util/size-chunks.js","../node_modules/micromark/dist/util/slice-chunks.js","../node_modules/micromark/dist/util/subtokenize.js"],"sourcesContent":["'use strict'\n\nvar regexCheck = require('../util/regex-check.js')\n\nvar asciiAlpha = regexCheck(/[A-Za-z]/)\n\nmodule.exports = asciiAlpha\n","'use strict'\n\nvar regexCheck = require('../util/regex-check.js')\n\nvar asciiAlphanumeric = regexCheck(/[\\dA-Za-z]/)\n\nmodule.exports = asciiAlphanumeric\n","'use strict'\n\nvar regexCheck = require('../util/regex-check.js')\n\nvar asciiAtext = regexCheck(/[#-'*+\\--9=?A-Z^-~]/)\n\nmodule.exports = asciiAtext\n","'use strict'\n\n// Note: EOF is seen as ASCII control here, because `null < 32 == true`.\nfunction asciiControl(code) {\n  return (\n    // Special whitespace codes (which have negative values), C0 and Control\n    // character DEL\n    code < 32 || code === 127\n  )\n}\n\nmodule.exports = asciiControl\n","'use strict'\n\nvar regexCheck = require('../util/regex-check.js')\n\nvar asciiDigit = regexCheck(/\\d/)\n\nmodule.exports = asciiDigit\n","'use strict'\n\nvar regexCheck = require('../util/regex-check.js')\n\nvar asciiHexDigit = regexCheck(/[\\dA-Fa-f]/)\n\nmodule.exports = asciiHexDigit\n","'use strict'\n\nvar regexCheck = require('../util/regex-check.js')\n\nvar asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/)\n\nmodule.exports = asciiPunctuation\n","'use strict'\n\nfunction markdownLineEndingOrSpace(code) {\n  return code < 0 || code === 32\n}\n\nmodule.exports = markdownLineEndingOrSpace\n","'use strict'\n\nfunction markdownLineEnding(code) {\n  return code < -2\n}\n\nmodule.exports = markdownLineEnding\n","'use strict'\n\nfunction markdownSpace(code) {\n  return code === -2 || code === -1 || code === 32\n}\n\nmodule.exports = markdownSpace\n","'use strict'\n\nvar unicodePunctuationRegex = require('../constant/unicode-punctuation-regex.js')\nvar regexCheck = require('../util/regex-check.js')\n\n// In fact adds to the bundle size.\n\nvar unicodePunctuation = regexCheck(unicodePunctuationRegex)\n\nmodule.exports = unicodePunctuation\n","'use strict'\n\nvar regexCheck = require('../util/regex-check.js')\n\nvar unicodeWhitespace = regexCheck(/\\s/)\n\nmodule.exports = unicodeWhitespace\n","'use strict'\n\nvar assign = Object.assign\n\nmodule.exports = assign\n","'use strict'\n\nvar fromCharCode = String.fromCharCode\n\nmodule.exports = fromCharCode\n","'use strict'\n\nvar own = {}.hasOwnProperty\n\nmodule.exports = own\n","'use strict'\n\n// This module is copied from <https://spec.commonmark.org/0.29/#html-blocks>.\nvar basics = [\n  'address',\n  'article',\n  'aside',\n  'base',\n  'basefont',\n  'blockquote',\n  'body',\n  'caption',\n  'center',\n  'col',\n  'colgroup',\n  'dd',\n  'details',\n  'dialog',\n  'dir',\n  'div',\n  'dl',\n  'dt',\n  'fieldset',\n  'figcaption',\n  'figure',\n  'footer',\n  'form',\n  'frame',\n  'frameset',\n  'h1',\n  'h2',\n  'h3',\n  'h4',\n  'h5',\n  'h6',\n  'head',\n  'header',\n  'hr',\n  'html',\n  'iframe',\n  'legend',\n  'li',\n  'link',\n  'main',\n  'menu',\n  'menuitem',\n  'nav',\n  'noframes',\n  'ol',\n  'optgroup',\n  'option',\n  'p',\n  'param',\n  'section',\n  'source',\n  'summary',\n  'table',\n  'tbody',\n  'td',\n  'tfoot',\n  'th',\n  'thead',\n  'title',\n  'tr',\n  'track',\n  'ul'\n]\n\nmodule.exports = basics\n","'use strict'\n\n// This module is copied from <https://spec.commonmark.org/0.29/#html-blocks>.\nvar raws = ['pre', 'script', 'style', 'textarea']\n\nmodule.exports = raws\n","'use strict'\n\nvar splice = [].splice\n\nmodule.exports = splice\n","'use strict'\n\n// This module is generated by `script/`.\n//\n// CommonMark handles attention (emphasis, strong) markers based on what comes\n// before or after them.\n// One such difference is if those characters are Unicode punctuation.\n// This script is generated from the Unicode data.\nvar unicodePunctuation = /[!-\\/:-@\\[-`\\{-~\\xA1\\xA7\\xAB\\xB6\\xB7\\xBB\\xBF\\u037E\\u0387\\u055A-\\u055F\\u0589\\u058A\\u05BE\\u05C0\\u05C3\\u05C6\\u05F3\\u05F4\\u0609\\u060A\\u060C\\u060D\\u061B\\u061E\\u061F\\u066A-\\u066D\\u06D4\\u0700-\\u070D\\u07F7-\\u07F9\\u0830-\\u083E\\u085E\\u0964\\u0965\\u0970\\u09FD\\u0A76\\u0AF0\\u0C77\\u0C84\\u0DF4\\u0E4F\\u0E5A\\u0E5B\\u0F04-\\u0F12\\u0F14\\u0F3A-\\u0F3D\\u0F85\\u0FD0-\\u0FD4\\u0FD9\\u0FDA\\u104A-\\u104F\\u10FB\\u1360-\\u1368\\u1400\\u166E\\u169B\\u169C\\u16EB-\\u16ED\\u1735\\u1736\\u17D4-\\u17D6\\u17D8-\\u17DA\\u1800-\\u180A\\u1944\\u1945\\u1A1E\\u1A1F\\u1AA0-\\u1AA6\\u1AA8-\\u1AAD\\u1B5A-\\u1B60\\u1BFC-\\u1BFF\\u1C3B-\\u1C3F\\u1C7E\\u1C7F\\u1CC0-\\u1CC7\\u1CD3\\u2010-\\u2027\\u2030-\\u2043\\u2045-\\u2051\\u2053-\\u205E\\u207D\\u207E\\u208D\\u208E\\u2308-\\u230B\\u2329\\u232A\\u2768-\\u2775\\u27C5\\u27C6\\u27E6-\\u27EF\\u2983-\\u2998\\u29D8-\\u29DB\\u29FC\\u29FD\\u2CF9-\\u2CFC\\u2CFE\\u2CFF\\u2D70\\u2E00-\\u2E2E\\u2E30-\\u2E4F\\u2E52\\u3001-\\u3003\\u3008-\\u3011\\u3014-\\u301F\\u3030\\u303D\\u30A0\\u30FB\\uA4FE\\uA4FF\\uA60D-\\uA60F\\uA673\\uA67E\\uA6F2-\\uA6F7\\uA874-\\uA877\\uA8CE\\uA8CF\\uA8F8-\\uA8FA\\uA8FC\\uA92E\\uA92F\\uA95F\\uA9C1-\\uA9CD\\uA9DE\\uA9DF\\uAA5C-\\uAA5F\\uAADE\\uAADF\\uAAF0\\uAAF1\\uABEB\\uFD3E\\uFD3F\\uFE10-\\uFE19\\uFE30-\\uFE52\\uFE54-\\uFE61\\uFE63\\uFE68\\uFE6A\\uFE6B\\uFF01-\\uFF03\\uFF05-\\uFF0A\\uFF0C-\\uFF0F\\uFF1A\\uFF1B\\uFF1F\\uFF20\\uFF3B-\\uFF3D\\uFF3F\\uFF5B\\uFF5D\\uFF5F-\\uFF65]/\n\nmodule.exports = unicodePunctuation\n","'use strict'\n\nObject.defineProperty(exports, '__esModule', {value: true})\n\nvar text$1 = require('./initialize/text.js')\nvar attention = require('./tokenize/attention.js')\nvar autolink = require('./tokenize/autolink.js')\nvar blockQuote = require('./tokenize/block-quote.js')\nvar characterEscape = require('./tokenize/character-escape.js')\nvar characterReference = require('./tokenize/character-reference.js')\nvar codeFenced = require('./tokenize/code-fenced.js')\nvar codeIndented = require('./tokenize/code-indented.js')\nvar codeText = require('./tokenize/code-text.js')\nvar definition = require('./tokenize/definition.js')\nvar hardBreakEscape = require('./tokenize/hard-break-escape.js')\nvar headingAtx = require('./tokenize/heading-atx.js')\nvar htmlFlow = require('./tokenize/html-flow.js')\nvar htmlText = require('./tokenize/html-text.js')\nvar labelEnd = require('./tokenize/label-end.js')\nvar labelStartImage = require('./tokenize/label-start-image.js')\nvar labelStartLink = require('./tokenize/label-start-link.js')\nvar lineEnding = require('./tokenize/line-ending.js')\nvar list = require('./tokenize/list.js')\nvar setextUnderline = require('./tokenize/setext-underline.js')\nvar thematicBreak = require('./tokenize/thematic-break.js')\n\nvar document = {\n  42: list,\n  // Asterisk\n  43: list,\n  // Plus sign\n  45: list,\n  // Dash\n  48: list,\n  // 0\n  49: list,\n  // 1\n  50: list,\n  // 2\n  51: list,\n  // 3\n  52: list,\n  // 4\n  53: list,\n  // 5\n  54: list,\n  // 6\n  55: list,\n  // 7\n  56: list,\n  // 8\n  57: list,\n  // 9\n  62: blockQuote // Greater than\n}\nvar contentInitial = {\n  91: definition // Left square bracket\n}\nvar flowInitial = {\n  '-2': codeIndented,\n  // Horizontal tab\n  '-1': codeIndented,\n  // Virtual space\n  32: codeIndented // Space\n}\nvar flow = {\n  35: headingAtx,\n  // Number sign\n  42: thematicBreak,\n  // Asterisk\n  45: [setextUnderline, thematicBreak],\n  // Dash\n  60: htmlFlow,\n  // Less than\n  61: setextUnderline,\n  // Equals to\n  95: thematicBreak,\n  // Underscore\n  96: codeFenced,\n  // Grave accent\n  126: codeFenced // Tilde\n}\nvar string = {\n  38: characterReference,\n  // Ampersand\n  92: characterEscape // Backslash\n}\nvar text = {\n  '-5': lineEnding,\n  // Carriage return\n  '-4': lineEnding,\n  // Line feed\n  '-3': lineEnding,\n  // Carriage return + line feed\n  33: labelStartImage,\n  // Exclamation mark\n  38: characterReference,\n  // Ampersand\n  42: attention,\n  // Asterisk\n  60: [autolink, htmlText],\n  // Less than\n  91: labelStartLink,\n  // Left square bracket\n  92: [hardBreakEscape, characterEscape],\n  // Backslash\n  93: labelEnd,\n  // Right square bracket\n  95: attention,\n  // Underscore\n  96: codeText // Grave accent\n}\nvar insideSpan = {\n  null: [attention, text$1.resolver]\n}\nvar disable = {\n  null: []\n}\n\nexports.contentInitial = contentInitial\nexports.disable = disable\nexports.document = document\nexports.flow = flow\nexports.flowInitial = flowInitial\nexports.insideSpan = insideSpan\nexports.string = string\nexports.text = text\n","'use strict'\n\nObject.defineProperty(exports, '__esModule', {value: true})\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\nvar factorySpace = require('../tokenize/factory-space.js')\n\nvar tokenize = initializeContent\n\nfunction initializeContent(effects) {\n  var contentStart = effects.attempt(\n    this.parser.constructs.contentInitial,\n    afterContentStartConstruct,\n    paragraphInitial\n  )\n  var previous\n  return contentStart\n\n  function afterContentStartConstruct(code) {\n    if (code === null) {\n      effects.consume(code)\n      return\n    }\n\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return factorySpace(effects, contentStart, 'linePrefix')\n  }\n\n  function paragraphInitial(code) {\n    effects.enter('paragraph')\n    return lineStart(code)\n  }\n\n  function lineStart(code) {\n    var token = effects.enter('chunkText', {\n      contentType: 'text',\n      previous: previous\n    })\n\n    if (previous) {\n      previous.next = token\n    }\n\n    previous = token\n    return data(code)\n  }\n\n  function data(code) {\n    if (code === null) {\n      effects.exit('chunkText')\n      effects.exit('paragraph')\n      effects.consume(code)\n      return\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.consume(code)\n      effects.exit('chunkText')\n      return lineStart\n    } // Data.\n\n    effects.consume(code)\n    return data\n  }\n}\n\nexports.tokenize = tokenize\n","'use strict'\n\nObject.defineProperty(exports, '__esModule', {value: true})\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\nvar factorySpace = require('../tokenize/factory-space.js')\nvar partialBlankLine = require('../tokenize/partial-blank-line.js')\n\nvar tokenize = initializeDocument\nvar containerConstruct = {\n  tokenize: tokenizeContainer\n}\nvar lazyFlowConstruct = {\n  tokenize: tokenizeLazyFlow\n}\n\nfunction initializeDocument(effects) {\n  var self = this\n  var stack = []\n  var continued = 0\n  var inspectConstruct = {\n    tokenize: tokenizeInspect,\n    partial: true\n  }\n  var inspectResult\n  var childFlow\n  var childToken\n  return start\n\n  function start(code) {\n    if (continued < stack.length) {\n      self.containerState = stack[continued][1]\n      return effects.attempt(\n        stack[continued][0].continuation,\n        documentContinue,\n        documentContinued\n      )(code)\n    }\n\n    return documentContinued(code)\n  }\n\n  function documentContinue(code) {\n    continued++\n    return start(code)\n  }\n\n  function documentContinued(code) {\n    // If we’re in a concrete construct (such as when expecting another line of\n    // HTML, or we resulted in lazy content), we can immediately start flow.\n    if (inspectResult && inspectResult.flowContinue) {\n      return flowStart(code)\n    }\n\n    self.interrupt =\n      childFlow &&\n      childFlow.currentConstruct &&\n      childFlow.currentConstruct.interruptible\n    self.containerState = {}\n    return effects.attempt(\n      containerConstruct,\n      containerContinue,\n      flowStart\n    )(code)\n  }\n\n  function containerContinue(code) {\n    stack.push([self.currentConstruct, self.containerState])\n    self.containerState = undefined\n    return documentContinued(code)\n  }\n\n  function flowStart(code) {\n    if (code === null) {\n      exitContainers(0, true)\n      effects.consume(code)\n      return\n    }\n\n    childFlow = childFlow || self.parser.flow(self.now())\n    effects.enter('chunkFlow', {\n      contentType: 'flow',\n      previous: childToken,\n      _tokenizer: childFlow\n    })\n    return flowContinue(code)\n  }\n\n  function flowContinue(code) {\n    if (code === null) {\n      continueFlow(effects.exit('chunkFlow'))\n      return flowStart(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.consume(code)\n      continueFlow(effects.exit('chunkFlow'))\n      return effects.check(inspectConstruct, documentAfterPeek)\n    }\n\n    effects.consume(code)\n    return flowContinue\n  }\n\n  function documentAfterPeek(code) {\n    exitContainers(\n      inspectResult.continued,\n      inspectResult && inspectResult.flowEnd\n    )\n    continued = 0\n    return start(code)\n  }\n\n  function continueFlow(token) {\n    if (childToken) childToken.next = token\n    childToken = token\n    childFlow.lazy = inspectResult && inspectResult.lazy\n    childFlow.defineSkip(token.start)\n    childFlow.write(self.sliceStream(token))\n  }\n\n  function exitContainers(size, end) {\n    var index = stack.length // Close the flow.\n\n    if (childFlow && end) {\n      childFlow.write([null])\n      childToken = childFlow = undefined\n    } // Exit open containers.\n\n    while (index-- > size) {\n      self.containerState = stack[index][1]\n      stack[index][0].exit.call(self, effects)\n    }\n\n    stack.length = size\n  }\n\n  function tokenizeInspect(effects, ok) {\n    var subcontinued = 0\n    inspectResult = {}\n    return inspectStart\n\n    function inspectStart(code) {\n      if (subcontinued < stack.length) {\n        self.containerState = stack[subcontinued][1]\n        return effects.attempt(\n          stack[subcontinued][0].continuation,\n          inspectContinue,\n          inspectLess\n        )(code)\n      } // If we’re continued but in a concrete flow, we can’t have more\n      // containers.\n\n      if (childFlow.currentConstruct && childFlow.currentConstruct.concrete) {\n        inspectResult.flowContinue = true\n        return inspectDone(code)\n      }\n\n      self.interrupt =\n        childFlow.currentConstruct && childFlow.currentConstruct.interruptible\n      self.containerState = {}\n      return effects.attempt(\n        containerConstruct,\n        inspectFlowEnd,\n        inspectDone\n      )(code)\n    }\n\n    function inspectContinue(code) {\n      subcontinued++\n      return self.containerState._closeFlow\n        ? inspectFlowEnd(code)\n        : inspectStart(code)\n    }\n\n    function inspectLess(code) {\n      if (childFlow.currentConstruct && childFlow.currentConstruct.lazy) {\n        // Maybe another container?\n        self.containerState = {}\n        return effects.attempt(\n          containerConstruct,\n          inspectFlowEnd, // Maybe flow, or a blank line?\n          effects.attempt(\n            lazyFlowConstruct,\n            inspectFlowEnd,\n            effects.check(partialBlankLine, inspectFlowEnd, inspectLazy)\n          )\n        )(code)\n      } // Otherwise we’re interrupting.\n\n      return inspectFlowEnd(code)\n    }\n\n    function inspectLazy(code) {\n      // Act as if all containers are continued.\n      subcontinued = stack.length\n      inspectResult.lazy = true\n      inspectResult.flowContinue = true\n      return inspectDone(code)\n    } // We’re done with flow if we have more containers, or an interruption.\n\n    function inspectFlowEnd(code) {\n      inspectResult.flowEnd = true\n      return inspectDone(code)\n    }\n\n    function inspectDone(code) {\n      inspectResult.continued = subcontinued\n      self.interrupt = self.containerState = undefined\n      return ok(code)\n    }\n  }\n}\n\nfunction tokenizeContainer(effects, ok, nok) {\n  return factorySpace(\n    effects,\n    effects.attempt(this.parser.constructs.document, ok, nok),\n    'linePrefix',\n    this.parser.constructs.disable.null.indexOf('codeIndented') > -1\n      ? undefined\n      : 4\n  )\n}\n\nfunction tokenizeLazyFlow(effects, ok, nok) {\n  return factorySpace(\n    effects,\n    effects.lazy(this.parser.constructs.flow, ok, nok),\n    'linePrefix',\n    this.parser.constructs.disable.null.indexOf('codeIndented') > -1\n      ? undefined\n      : 4\n  )\n}\n\nexports.tokenize = tokenize\n","'use strict'\n\nObject.defineProperty(exports, '__esModule', {value: true})\n\nvar content = require('../tokenize/content.js')\nvar factorySpace = require('../tokenize/factory-space.js')\nvar partialBlankLine = require('../tokenize/partial-blank-line.js')\n\nvar tokenize = initializeFlow\n\nfunction initializeFlow(effects) {\n  var self = this\n  var initial = effects.attempt(\n    // Try to parse a blank line.\n    partialBlankLine,\n    atBlankEnding, // Try to parse initial flow (essentially, only code).\n    effects.attempt(\n      this.parser.constructs.flowInitial,\n      afterConstruct,\n      factorySpace(\n        effects,\n        effects.attempt(\n          this.parser.constructs.flow,\n          afterConstruct,\n          effects.attempt(content, afterConstruct)\n        ),\n        'linePrefix'\n      )\n    )\n  )\n  return initial\n\n  function atBlankEnding(code) {\n    if (code === null) {\n      effects.consume(code)\n      return\n    }\n\n    effects.enter('lineEndingBlank')\n    effects.consume(code)\n    effects.exit('lineEndingBlank')\n    self.currentConstruct = undefined\n    return initial\n  }\n\n  function afterConstruct(code) {\n    if (code === null) {\n      effects.consume(code)\n      return\n    }\n\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    self.currentConstruct = undefined\n    return initial\n  }\n}\n\nexports.tokenize = tokenize\n","'use strict'\n\nObject.defineProperty(exports, '__esModule', {value: true})\n\nvar assign = require('../constant/assign.js')\nvar shallow = require('../util/shallow.js')\n\nvar text = initializeFactory('text')\nvar string = initializeFactory('string')\nvar resolver = {\n  resolveAll: createResolver()\n}\n\nfunction initializeFactory(field) {\n  return {\n    tokenize: initializeText,\n    resolveAll: createResolver(\n      field === 'text' ? resolveAllLineSuffixes : undefined\n    )\n  }\n\n  function initializeText(effects) {\n    var self = this\n    var constructs = this.parser.constructs[field]\n    var text = effects.attempt(constructs, start, notText)\n    return start\n\n    function start(code) {\n      return atBreak(code) ? text(code) : notText(code)\n    }\n\n    function notText(code) {\n      if (code === null) {\n        effects.consume(code)\n        return\n      }\n\n      effects.enter('data')\n      effects.consume(code)\n      return data\n    }\n\n    function data(code) {\n      if (atBreak(code)) {\n        effects.exit('data')\n        return text(code)\n      } // Data.\n\n      effects.consume(code)\n      return data\n    }\n\n    function atBreak(code) {\n      var list = constructs[code]\n      var index = -1\n\n      if (code === null) {\n        return true\n      }\n\n      if (list) {\n        while (++index < list.length) {\n          if (\n            !list[index].previous ||\n            list[index].previous.call(self, self.previous)\n          ) {\n            return true\n          }\n        }\n      }\n    }\n  }\n}\n\nfunction createResolver(extraResolver) {\n  return resolveAllText\n\n  function resolveAllText(events, context) {\n    var index = -1\n    var enter // A rather boring computation (to merge adjacent `data` events) which\n    // improves mm performance by 29%.\n\n    while (++index <= events.length) {\n      if (enter === undefined) {\n        if (events[index] && events[index][1].type === 'data') {\n          enter = index\n          index++\n        }\n      } else if (!events[index] || events[index][1].type !== 'data') {\n        // Don’t do anything if there is one data token.\n        if (index !== enter + 2) {\n          events[enter][1].end = events[index - 1][1].end\n          events.splice(enter + 2, index - enter - 2)\n          index = enter + 2\n        }\n\n        enter = undefined\n      }\n    }\n\n    return extraResolver ? extraResolver(events, context) : events\n  }\n} // A rather ugly set of instructions which again looks at chunks in the input\n// stream.\n// The reason to do this here is that it is *much* faster to parse in reverse.\n// And that we can’t hook into `null` to split the line suffix before an EOF.\n// To do: figure out if we can make this into a clean utility, or even in core.\n// As it will be useful for GFMs literal autolink extension (and maybe even\n// tables?)\n\nfunction resolveAllLineSuffixes(events, context) {\n  var eventIndex = -1\n  var chunks\n  var data\n  var chunk\n  var index\n  var bufferIndex\n  var size\n  var tabs\n  var token\n\n  while (++eventIndex <= events.length) {\n    if (\n      (eventIndex === events.length ||\n        events[eventIndex][1].type === 'lineEnding') &&\n      events[eventIndex - 1][1].type === 'data'\n    ) {\n      data = events[eventIndex - 1][1]\n      chunks = context.sliceStream(data)\n      index = chunks.length\n      bufferIndex = -1\n      size = 0\n      tabs = undefined\n\n      while (index--) {\n        chunk = chunks[index]\n\n        if (typeof chunk === 'string') {\n          bufferIndex = chunk.length\n\n          while (chunk.charCodeAt(bufferIndex - 1) === 32) {\n            size++\n            bufferIndex--\n          }\n\n          if (bufferIndex) break\n          bufferIndex = -1\n        } // Number\n        else if (chunk === -2) {\n          tabs = true\n          size++\n        } else if (chunk === -1);\n        else {\n          // Replacement character, exit.\n          index++\n          break\n        }\n      }\n\n      if (size) {\n        token = {\n          type:\n            eventIndex === events.length || tabs || size < 2\n              ? 'lineSuffix'\n              : 'hardBreakTrailing',\n          start: {\n            line: data.end.line,\n            column: data.end.column - size,\n            offset: data.end.offset - size,\n            _index: data.start._index + index,\n            _bufferIndex: index\n              ? bufferIndex\n              : data.start._bufferIndex + bufferIndex\n          },\n          end: shallow(data.end)\n        }\n        data.end = shallow(token.start)\n\n        if (data.start.offset === data.end.offset) {\n          assign(data, token)\n        } else {\n          events.splice(\n            eventIndex,\n            0,\n            ['enter', token, context],\n            ['exit', token, context]\n          )\n          eventIndex += 2\n        }\n      }\n\n      eventIndex++\n    }\n  }\n\n  return events\n}\n\nexports.resolver = resolver\nexports.string = string\nexports.text = text\n","'use strict'\n\nvar content = require('./initialize/content.js')\nvar document = require('./initialize/document.js')\nvar flow = require('./initialize/flow.js')\nvar text = require('./initialize/text.js')\nvar combineExtensions = require('./util/combine-extensions.js')\nvar createTokenizer = require('./util/create-tokenizer.js')\nvar miniflat = require('./util/miniflat.js')\nvar constructs = require('./constructs.js')\n\nfunction parse(options) {\n  var settings = options || {}\n  var parser = {\n    defined: [],\n    constructs: combineExtensions(\n      [constructs].concat(miniflat(settings.extensions))\n    ),\n    content: create(content),\n    document: create(document),\n    flow: create(flow),\n    string: create(text.string),\n    text: create(text.text)\n  }\n  return parser\n\n  function create(initializer) {\n    return creator\n\n    function creator(from) {\n      return createTokenizer(parser, initializer, from)\n    }\n  }\n}\n\nmodule.exports = parse\n","'use strict'\n\nvar subtokenize = require('./util/subtokenize.js')\n\nfunction postprocess(events) {\n  while (!subtokenize(events)) {\n    // Empty\n  }\n\n  return events\n}\n\nmodule.exports = postprocess\n","'use strict'\n\nvar search = /[\\0\\t\\n\\r]/g\n\nfunction preprocess() {\n  var start = true\n  var column = 1\n  var buffer = ''\n  var atCarriageReturn\n  return preprocessor\n\n  function preprocessor(value, encoding, end) {\n    var chunks = []\n    var match\n    var next\n    var startPosition\n    var endPosition\n    var code\n    value = buffer + value.toString(encoding)\n    startPosition = 0\n    buffer = ''\n\n    if (start) {\n      if (value.charCodeAt(0) === 65279) {\n        startPosition++\n      }\n\n      start = undefined\n    }\n\n    while (startPosition < value.length) {\n      search.lastIndex = startPosition\n      match = search.exec(value)\n      endPosition = match ? match.index : value.length\n      code = value.charCodeAt(endPosition)\n\n      if (!match) {\n        buffer = value.slice(startPosition)\n        break\n      }\n\n      if (code === 10 && startPosition === endPosition && atCarriageReturn) {\n        chunks.push(-3)\n        atCarriageReturn = undefined\n      } else {\n        if (atCarriageReturn) {\n          chunks.push(-5)\n          atCarriageReturn = undefined\n        }\n\n        if (startPosition < endPosition) {\n          chunks.push(value.slice(startPosition, endPosition))\n          column += endPosition - startPosition\n        }\n\n        if (code === 0) {\n          chunks.push(65533)\n          column++\n        } else if (code === 9) {\n          next = Math.ceil(column / 4) * 4\n          chunks.push(-2)\n\n          while (column++ < next) chunks.push(-1)\n        } else if (code === 10) {\n          chunks.push(-4)\n          column = 1\n        } // Must be carriage return.\n        else {\n          atCarriageReturn = true\n          column = 1\n        }\n      }\n\n      startPosition = endPosition + 1\n    }\n\n    if (end) {\n      if (atCarriageReturn) chunks.push(-5)\n      if (buffer) chunks.push(buffer)\n      chunks.push(null)\n    }\n\n    return chunks\n  }\n}\n\nmodule.exports = preprocess\n","'use strict'\n\nvar chunkedPush = require('../util/chunked-push.js')\nvar chunkedSplice = require('../util/chunked-splice.js')\nvar classifyCharacter = require('../util/classify-character.js')\nvar movePoint = require('../util/move-point.js')\nvar resolveAll = require('../util/resolve-all.js')\nvar shallow = require('../util/shallow.js')\n\nvar attention = {\n  name: 'attention',\n  tokenize: tokenizeAttention,\n  resolveAll: resolveAllAttention\n}\n\nfunction resolveAllAttention(events, context) {\n  var index = -1\n  var open\n  var group\n  var text\n  var openingSequence\n  var closingSequence\n  var use\n  var nextEvents\n  var offset // Walk through all events.\n  //\n  // Note: performance of this is fine on an mb of normal markdown, but it’s\n  // a bottleneck for malicious stuff.\n\n  while (++index < events.length) {\n    // Find a token that can close.\n    if (\n      events[index][0] === 'enter' &&\n      events[index][1].type === 'attentionSequence' &&\n      events[index][1]._close\n    ) {\n      open = index // Now walk back to find an opener.\n\n      while (open--) {\n        // Find a token that can open the closer.\n        if (\n          events[open][0] === 'exit' &&\n          events[open][1].type === 'attentionSequence' &&\n          events[open][1]._open && // If the markers are the same:\n          context.sliceSerialize(events[open][1]).charCodeAt(0) ===\n            context.sliceSerialize(events[index][1]).charCodeAt(0)\n        ) {\n          // If the opening can close or the closing can open,\n          // and the close size *is not* a multiple of three,\n          // but the sum of the opening and closing size *is* multiple of three,\n          // then don’t match.\n          if (\n            (events[open][1]._close || events[index][1]._open) &&\n            (events[index][1].end.offset - events[index][1].start.offset) % 3 &&\n            !(\n              (events[open][1].end.offset -\n                events[open][1].start.offset +\n                events[index][1].end.offset -\n                events[index][1].start.offset) %\n              3\n            )\n          ) {\n            continue\n          } // Number of markers to use from the sequence.\n\n          use =\n            events[open][1].end.offset - events[open][1].start.offset > 1 &&\n            events[index][1].end.offset - events[index][1].start.offset > 1\n              ? 2\n              : 1\n          openingSequence = {\n            type: use > 1 ? 'strongSequence' : 'emphasisSequence',\n            start: movePoint(shallow(events[open][1].end), -use),\n            end: shallow(events[open][1].end)\n          }\n          closingSequence = {\n            type: use > 1 ? 'strongSequence' : 'emphasisSequence',\n            start: shallow(events[index][1].start),\n            end: movePoint(shallow(events[index][1].start), use)\n          }\n          text = {\n            type: use > 1 ? 'strongText' : 'emphasisText',\n            start: shallow(events[open][1].end),\n            end: shallow(events[index][1].start)\n          }\n          group = {\n            type: use > 1 ? 'strong' : 'emphasis',\n            start: shallow(openingSequence.start),\n            end: shallow(closingSequence.end)\n          }\n          events[open][1].end = shallow(openingSequence.start)\n          events[index][1].start = shallow(closingSequence.end)\n          nextEvents = [] // If there are more markers in the opening, add them before.\n\n          if (events[open][1].end.offset - events[open][1].start.offset) {\n            nextEvents = chunkedPush(nextEvents, [\n              ['enter', events[open][1], context],\n              ['exit', events[open][1], context]\n            ])\n          } // Opening.\n\n          nextEvents = chunkedPush(nextEvents, [\n            ['enter', group, context],\n            ['enter', openingSequence, context],\n            ['exit', openingSequence, context],\n            ['enter', text, context]\n          ]) // Between.\n\n          nextEvents = chunkedPush(\n            nextEvents,\n            resolveAll(\n              context.parser.constructs.insideSpan.null,\n              events.slice(open + 1, index),\n              context\n            )\n          ) // Closing.\n\n          nextEvents = chunkedPush(nextEvents, [\n            ['exit', text, context],\n            ['enter', closingSequence, context],\n            ['exit', closingSequence, context],\n            ['exit', group, context]\n          ]) // If there are more markers in the closing, add them after.\n\n          if (events[index][1].end.offset - events[index][1].start.offset) {\n            offset = 2\n            nextEvents = chunkedPush(nextEvents, [\n              ['enter', events[index][1], context],\n              ['exit', events[index][1], context]\n            ])\n          } else {\n            offset = 0\n          }\n\n          chunkedSplice(events, open - 1, index - open + 3, nextEvents)\n          index = open + nextEvents.length - offset - 2\n          break\n        }\n      }\n    }\n  } // Remove remaining sequences.\n\n  index = -1\n\n  while (++index < events.length) {\n    if (events[index][1].type === 'attentionSequence') {\n      events[index][1].type = 'data'\n    }\n  }\n\n  return events\n}\n\nfunction tokenizeAttention(effects, ok) {\n  var before = classifyCharacter(this.previous)\n  var marker\n  return start\n\n  function start(code) {\n    effects.enter('attentionSequence')\n    marker = code\n    return sequence(code)\n  }\n\n  function sequence(code) {\n    var token\n    var after\n    var open\n    var close\n\n    if (code === marker) {\n      effects.consume(code)\n      return sequence\n    }\n\n    token = effects.exit('attentionSequence')\n    after = classifyCharacter(code)\n    open = !after || (after === 2 && before)\n    close = !before || (before === 2 && after)\n    token._open = marker === 42 ? open : open && (before || !close)\n    token._close = marker === 42 ? close : close && (after || !open)\n    return ok(code)\n  }\n}\n\nmodule.exports = attention\n","'use strict'\n\nvar asciiAlpha = require('../character/ascii-alpha.js')\nvar asciiAlphanumeric = require('../character/ascii-alphanumeric.js')\nvar asciiAtext = require('../character/ascii-atext.js')\nvar asciiControl = require('../character/ascii-control.js')\n\nvar autolink = {\n  name: 'autolink',\n  tokenize: tokenizeAutolink\n}\n\nfunction tokenizeAutolink(effects, ok, nok) {\n  var size = 1\n  return start\n\n  function start(code) {\n    effects.enter('autolink')\n    effects.enter('autolinkMarker')\n    effects.consume(code)\n    effects.exit('autolinkMarker')\n    effects.enter('autolinkProtocol')\n    return open\n  }\n\n  function open(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return schemeOrEmailAtext\n    }\n\n    return asciiAtext(code) ? emailAtext(code) : nok(code)\n  }\n\n  function schemeOrEmailAtext(code) {\n    return code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)\n      ? schemeInsideOrEmailAtext(code)\n      : emailAtext(code)\n  }\n\n  function schemeInsideOrEmailAtext(code) {\n    if (code === 58) {\n      effects.consume(code)\n      return urlInside\n    }\n\n    if (\n      (code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) &&\n      size++ < 32\n    ) {\n      effects.consume(code)\n      return schemeInsideOrEmailAtext\n    }\n\n    return emailAtext(code)\n  }\n\n  function urlInside(code) {\n    if (code === 62) {\n      effects.exit('autolinkProtocol')\n      return end(code)\n    }\n\n    if (code === 32 || code === 60 || asciiControl(code)) {\n      return nok(code)\n    }\n\n    effects.consume(code)\n    return urlInside\n  }\n\n  function emailAtext(code) {\n    if (code === 64) {\n      effects.consume(code)\n      size = 0\n      return emailAtSignOrDot\n    }\n\n    if (asciiAtext(code)) {\n      effects.consume(code)\n      return emailAtext\n    }\n\n    return nok(code)\n  }\n\n  function emailAtSignOrDot(code) {\n    return asciiAlphanumeric(code) ? emailLabel(code) : nok(code)\n  }\n\n  function emailLabel(code) {\n    if (code === 46) {\n      effects.consume(code)\n      size = 0\n      return emailAtSignOrDot\n    }\n\n    if (code === 62) {\n      // Exit, then change the type.\n      effects.exit('autolinkProtocol').type = 'autolinkEmail'\n      return end(code)\n    }\n\n    return emailValue(code)\n  }\n\n  function emailValue(code) {\n    if ((code === 45 || asciiAlphanumeric(code)) && size++ < 63) {\n      effects.consume(code)\n      return code === 45 ? emailValue : emailLabel\n    }\n\n    return nok(code)\n  }\n\n  function end(code) {\n    effects.enter('autolinkMarker')\n    effects.consume(code)\n    effects.exit('autolinkMarker')\n    effects.exit('autolink')\n    return ok\n  }\n}\n\nmodule.exports = autolink\n","'use strict'\n\nvar markdownSpace = require('../character/markdown-space.js')\nvar factorySpace = require('./factory-space.js')\n\nvar blockQuote = {\n  name: 'blockQuote',\n  tokenize: tokenizeBlockQuoteStart,\n  continuation: {\n    tokenize: tokenizeBlockQuoteContinuation\n  },\n  exit: exit\n}\n\nfunction tokenizeBlockQuoteStart(effects, ok, nok) {\n  var self = this\n  return start\n\n  function start(code) {\n    if (code === 62) {\n      if (!self.containerState.open) {\n        effects.enter('blockQuote', {\n          _container: true\n        })\n        self.containerState.open = true\n      }\n\n      effects.enter('blockQuotePrefix')\n      effects.enter('blockQuoteMarker')\n      effects.consume(code)\n      effects.exit('blockQuoteMarker')\n      return after\n    }\n\n    return nok(code)\n  }\n\n  function after(code) {\n    if (markdownSpace(code)) {\n      effects.enter('blockQuotePrefixWhitespace')\n      effects.consume(code)\n      effects.exit('blockQuotePrefixWhitespace')\n      effects.exit('blockQuotePrefix')\n      return ok\n    }\n\n    effects.exit('blockQuotePrefix')\n    return ok(code)\n  }\n}\n\nfunction tokenizeBlockQuoteContinuation(effects, ok, nok) {\n  return factorySpace(\n    effects,\n    effects.attempt(blockQuote, ok, nok),\n    'linePrefix',\n    this.parser.constructs.disable.null.indexOf('codeIndented') > -1\n      ? undefined\n      : 4\n  )\n}\n\nfunction exit(effects) {\n  effects.exit('blockQuote')\n}\n\nmodule.exports = blockQuote\n","'use strict'\n\nvar asciiPunctuation = require('../character/ascii-punctuation.js')\n\nvar characterEscape = {\n  name: 'characterEscape',\n  tokenize: tokenizeCharacterEscape\n}\n\nfunction tokenizeCharacterEscape(effects, ok, nok) {\n  return start\n\n  function start(code) {\n    effects.enter('characterEscape')\n    effects.enter('escapeMarker')\n    effects.consume(code)\n    effects.exit('escapeMarker')\n    return open\n  }\n\n  function open(code) {\n    if (asciiPunctuation(code)) {\n      effects.enter('characterEscapeValue')\n      effects.consume(code)\n      effects.exit('characterEscapeValue')\n      effects.exit('characterEscape')\n      return ok\n    }\n\n    return nok(code)\n  }\n}\n\nmodule.exports = characterEscape\n","'use strict'\n\nvar decodeEntity = require('parse-entities/decode-entity.js')\nvar asciiAlphanumeric = require('../character/ascii-alphanumeric.js')\nvar asciiDigit = require('../character/ascii-digit.js')\nvar asciiHexDigit = require('../character/ascii-hex-digit.js')\n\nfunction _interopDefaultLegacy(e) {\n  return e && typeof e === 'object' && 'default' in e ? e : {default: e}\n}\n\nvar decodeEntity__default = /*#__PURE__*/ _interopDefaultLegacy(decodeEntity)\n\nvar characterReference = {\n  name: 'characterReference',\n  tokenize: tokenizeCharacterReference\n}\n\nfunction tokenizeCharacterReference(effects, ok, nok) {\n  var self = this\n  var size = 0\n  var max\n  var test\n  return start\n\n  function start(code) {\n    effects.enter('characterReference')\n    effects.enter('characterReferenceMarker')\n    effects.consume(code)\n    effects.exit('characterReferenceMarker')\n    return open\n  }\n\n  function open(code) {\n    if (code === 35) {\n      effects.enter('characterReferenceMarkerNumeric')\n      effects.consume(code)\n      effects.exit('characterReferenceMarkerNumeric')\n      return numeric\n    }\n\n    effects.enter('characterReferenceValue')\n    max = 31\n    test = asciiAlphanumeric\n    return value(code)\n  }\n\n  function numeric(code) {\n    if (code === 88 || code === 120) {\n      effects.enter('characterReferenceMarkerHexadecimal')\n      effects.consume(code)\n      effects.exit('characterReferenceMarkerHexadecimal')\n      effects.enter('characterReferenceValue')\n      max = 6\n      test = asciiHexDigit\n      return value\n    }\n\n    effects.enter('characterReferenceValue')\n    max = 7\n    test = asciiDigit\n    return value(code)\n  }\n\n  function value(code) {\n    var token\n\n    if (code === 59 && size) {\n      token = effects.exit('characterReferenceValue')\n\n      if (\n        test === asciiAlphanumeric &&\n        !decodeEntity__default['default'](self.sliceSerialize(token))\n      ) {\n        return nok(code)\n      }\n\n      effects.enter('characterReferenceMarker')\n      effects.consume(code)\n      effects.exit('characterReferenceMarker')\n      effects.exit('characterReference')\n      return ok\n    }\n\n    if (test(code) && size++ < max) {\n      effects.consume(code)\n      return value\n    }\n\n    return nok(code)\n  }\n}\n\nmodule.exports = characterReference\n","'use strict'\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js')\nvar prefixSize = require('../util/prefix-size.js')\nvar factorySpace = require('./factory-space.js')\n\nvar codeFenced = {\n  name: 'codeFenced',\n  tokenize: tokenizeCodeFenced,\n  concrete: true\n}\n\nfunction tokenizeCodeFenced(effects, ok, nok) {\n  var self = this\n  var closingFenceConstruct = {\n    tokenize: tokenizeClosingFence,\n    partial: true\n  }\n  var initialPrefix = prefixSize(this.events, 'linePrefix')\n  var sizeOpen = 0\n  var marker\n  return start\n\n  function start(code) {\n    effects.enter('codeFenced')\n    effects.enter('codeFencedFence')\n    effects.enter('codeFencedFenceSequence')\n    marker = code\n    return sequenceOpen(code)\n  }\n\n  function sequenceOpen(code) {\n    if (code === marker) {\n      effects.consume(code)\n      sizeOpen++\n      return sequenceOpen\n    }\n\n    effects.exit('codeFencedFenceSequence')\n    return sizeOpen < 3\n      ? nok(code)\n      : factorySpace(effects, infoOpen, 'whitespace')(code)\n  }\n\n  function infoOpen(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return openAfter(code)\n    }\n\n    effects.enter('codeFencedFenceInfo')\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return info(code)\n  }\n\n  function info(code) {\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      effects.exit('chunkString')\n      effects.exit('codeFencedFenceInfo')\n      return factorySpace(effects, infoAfter, 'whitespace')(code)\n    }\n\n    if (code === 96 && code === marker) return nok(code)\n    effects.consume(code)\n    return info\n  }\n\n  function infoAfter(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return openAfter(code)\n    }\n\n    effects.enter('codeFencedFenceMeta')\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return meta(code)\n  }\n\n  function meta(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('chunkString')\n      effects.exit('codeFencedFenceMeta')\n      return openAfter(code)\n    }\n\n    if (code === 96 && code === marker) return nok(code)\n    effects.consume(code)\n    return meta\n  }\n\n  function openAfter(code) {\n    effects.exit('codeFencedFence')\n    return self.interrupt ? ok(code) : content(code)\n  }\n\n  function content(code) {\n    if (code === null) {\n      return after(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return effects.attempt(\n        closingFenceConstruct,\n        after,\n        initialPrefix\n          ? factorySpace(effects, content, 'linePrefix', initialPrefix + 1)\n          : content\n      )\n    }\n\n    effects.enter('codeFlowValue')\n    return contentContinue(code)\n  }\n\n  function contentContinue(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('codeFlowValue')\n      return content(code)\n    }\n\n    effects.consume(code)\n    return contentContinue\n  }\n\n  function after(code) {\n    effects.exit('codeFenced')\n    return ok(code)\n  }\n\n  function tokenizeClosingFence(effects, ok, nok) {\n    var size = 0\n    return factorySpace(\n      effects,\n      closingSequenceStart,\n      'linePrefix',\n      this.parser.constructs.disable.null.indexOf('codeIndented') > -1\n        ? undefined\n        : 4\n    )\n\n    function closingSequenceStart(code) {\n      effects.enter('codeFencedFence')\n      effects.enter('codeFencedFenceSequence')\n      return closingSequence(code)\n    }\n\n    function closingSequence(code) {\n      if (code === marker) {\n        effects.consume(code)\n        size++\n        return closingSequence\n      }\n\n      if (size < sizeOpen) return nok(code)\n      effects.exit('codeFencedFenceSequence')\n      return factorySpace(effects, closingSequenceEnd, 'whitespace')(code)\n    }\n\n    function closingSequenceEnd(code) {\n      if (code === null || markdownLineEnding(code)) {\n        effects.exit('codeFencedFence')\n        return ok(code)\n      }\n\n      return nok(code)\n    }\n  }\n}\n\nmodule.exports = codeFenced\n","'use strict'\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\nvar chunkedSplice = require('../util/chunked-splice.js')\nvar prefixSize = require('../util/prefix-size.js')\nvar factorySpace = require('./factory-space.js')\n\nvar codeIndented = {\n  name: 'codeIndented',\n  tokenize: tokenizeCodeIndented,\n  resolve: resolveCodeIndented\n}\nvar indentedContentConstruct = {\n  tokenize: tokenizeIndentedContent,\n  partial: true\n}\n\nfunction resolveCodeIndented(events, context) {\n  var code = {\n    type: 'codeIndented',\n    start: events[0][1].start,\n    end: events[events.length - 1][1].end\n  }\n  chunkedSplice(events, 0, 0, [['enter', code, context]])\n  chunkedSplice(events, events.length, 0, [['exit', code, context]])\n  return events\n}\n\nfunction tokenizeCodeIndented(effects, ok, nok) {\n  return effects.attempt(indentedContentConstruct, afterPrefix, nok)\n\n  function afterPrefix(code) {\n    if (code === null) {\n      return ok(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      return effects.attempt(indentedContentConstruct, afterPrefix, ok)(code)\n    }\n\n    effects.enter('codeFlowValue')\n    return content(code)\n  }\n\n  function content(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('codeFlowValue')\n      return afterPrefix(code)\n    }\n\n    effects.consume(code)\n    return content\n  }\n}\n\nfunction tokenizeIndentedContent(effects, ok, nok) {\n  var self = this\n  return factorySpace(effects, afterPrefix, 'linePrefix', 4 + 1)\n\n  function afterPrefix(code) {\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return factorySpace(effects, afterPrefix, 'linePrefix', 4 + 1)\n    }\n\n    return prefixSize(self.events, 'linePrefix') < 4 ? nok(code) : ok(code)\n  }\n}\n\nmodule.exports = codeIndented\n","'use strict'\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\n\nvar codeText = {\n  name: 'codeText',\n  tokenize: tokenizeCodeText,\n  resolve: resolveCodeText,\n  previous: previous\n}\n\nfunction resolveCodeText(events) {\n  var tailExitIndex = events.length - 4\n  var headEnterIndex = 3\n  var index\n  var enter // If we start and end with an EOL or a space.\n\n  if (\n    (events[headEnterIndex][1].type === 'lineEnding' ||\n      events[headEnterIndex][1].type === 'space') &&\n    (events[tailExitIndex][1].type === 'lineEnding' ||\n      events[tailExitIndex][1].type === 'space')\n  ) {\n    index = headEnterIndex // And we have data.\n\n    while (++index < tailExitIndex) {\n      if (events[index][1].type === 'codeTextData') {\n        // Then we have padding.\n        events[tailExitIndex][1].type = events[headEnterIndex][1].type =\n          'codeTextPadding'\n        headEnterIndex += 2\n        tailExitIndex -= 2\n        break\n      }\n    }\n  } // Merge adjacent spaces and data.\n\n  index = headEnterIndex - 1\n  tailExitIndex++\n\n  while (++index <= tailExitIndex) {\n    if (enter === undefined) {\n      if (index !== tailExitIndex && events[index][1].type !== 'lineEnding') {\n        enter = index\n      }\n    } else if (\n      index === tailExitIndex ||\n      events[index][1].type === 'lineEnding'\n    ) {\n      events[enter][1].type = 'codeTextData'\n\n      if (index !== enter + 2) {\n        events[enter][1].end = events[index - 1][1].end\n        events.splice(enter + 2, index - enter - 2)\n        tailExitIndex -= index - enter - 2\n        index = enter + 2\n      }\n\n      enter = undefined\n    }\n  }\n\n  return events\n}\n\nfunction previous(code) {\n  // If there is a previous code, there will always be a tail.\n  return (\n    code !== 96 ||\n    this.events[this.events.length - 1][1].type === 'characterEscape'\n  )\n}\n\nfunction tokenizeCodeText(effects, ok, nok) {\n  var sizeOpen = 0\n  var size\n  var token\n  return start\n\n  function start(code) {\n    effects.enter('codeText')\n    effects.enter('codeTextSequence')\n    return openingSequence(code)\n  }\n\n  function openingSequence(code) {\n    if (code === 96) {\n      effects.consume(code)\n      sizeOpen++\n      return openingSequence\n    }\n\n    effects.exit('codeTextSequence')\n    return gap(code)\n  }\n\n  function gap(code) {\n    // EOF.\n    if (code === null) {\n      return nok(code)\n    } // Closing fence?\n    // Could also be data.\n\n    if (code === 96) {\n      token = effects.enter('codeTextSequence')\n      size = 0\n      return closingSequence(code)\n    } // Tabs don’t work, and virtual spaces don’t make sense.\n\n    if (code === 32) {\n      effects.enter('space')\n      effects.consume(code)\n      effects.exit('space')\n      return gap\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return gap\n    } // Data.\n\n    effects.enter('codeTextData')\n    return data(code)\n  } // In code.\n\n  function data(code) {\n    if (\n      code === null ||\n      code === 32 ||\n      code === 96 ||\n      markdownLineEnding(code)\n    ) {\n      effects.exit('codeTextData')\n      return gap(code)\n    }\n\n    effects.consume(code)\n    return data\n  } // Closing fence.\n\n  function closingSequence(code) {\n    // More.\n    if (code === 96) {\n      effects.consume(code)\n      size++\n      return closingSequence\n    } // Done!\n\n    if (size === sizeOpen) {\n      effects.exit('codeTextSequence')\n      effects.exit('codeText')\n      return ok(code)\n    } // More or less accents: mark as data.\n\n    token.type = 'codeTextData'\n    return data(code)\n  }\n}\n\nmodule.exports = codeText\n","'use strict'\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\nvar prefixSize = require('../util/prefix-size.js')\nvar subtokenize = require('../util/subtokenize.js')\nvar factorySpace = require('./factory-space.js')\n\n// No name because it must not be turned off.\nvar content = {\n  tokenize: tokenizeContent,\n  resolve: resolveContent,\n  interruptible: true,\n  lazy: true\n}\nvar continuationConstruct = {\n  tokenize: tokenizeContinuation,\n  partial: true\n} // Content is transparent: it’s parsed right now. That way, definitions are also\n// parsed right now: before text in paragraphs (specifically, media) are parsed.\n\nfunction resolveContent(events) {\n  subtokenize(events)\n  return events\n}\n\nfunction tokenizeContent(effects, ok) {\n  var previous\n  return start\n\n  function start(code) {\n    effects.enter('content')\n    previous = effects.enter('chunkContent', {\n      contentType: 'content'\n    })\n    return data(code)\n  }\n\n  function data(code) {\n    if (code === null) {\n      return contentEnd(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      return effects.check(\n        continuationConstruct,\n        contentContinue,\n        contentEnd\n      )(code)\n    } // Data.\n\n    effects.consume(code)\n    return data\n  }\n\n  function contentEnd(code) {\n    effects.exit('chunkContent')\n    effects.exit('content')\n    return ok(code)\n  }\n\n  function contentContinue(code) {\n    effects.consume(code)\n    effects.exit('chunkContent')\n    previous = previous.next = effects.enter('chunkContent', {\n      contentType: 'content',\n      previous: previous\n    })\n    return data\n  }\n}\n\nfunction tokenizeContinuation(effects, ok, nok) {\n  var self = this\n  return startLookahead\n\n  function startLookahead(code) {\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return factorySpace(effects, prefixed, 'linePrefix')\n  }\n\n  function prefixed(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code)\n    }\n\n    if (\n      self.parser.constructs.disable.null.indexOf('codeIndented') > -1 ||\n      prefixSize(self.events, 'linePrefix') < 4\n    ) {\n      return effects.interrupt(self.parser.constructs.flow, nok, ok)(code)\n    }\n\n    return ok(code)\n  }\n}\n\nmodule.exports = content\n","'use strict'\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js')\nvar normalizeIdentifier = require('../util/normalize-identifier.js')\nvar factoryDestination = require('./factory-destination.js')\nvar factoryLabel = require('./factory-label.js')\nvar factorySpace = require('./factory-space.js')\nvar factoryWhitespace = require('./factory-whitespace.js')\nvar factoryTitle = require('./factory-title.js')\n\nvar definition = {\n  name: 'definition',\n  tokenize: tokenizeDefinition\n}\nvar titleConstruct = {\n  tokenize: tokenizeTitle,\n  partial: true\n}\n\nfunction tokenizeDefinition(effects, ok, nok) {\n  var self = this\n  var identifier\n  return start\n\n  function start(code) {\n    effects.enter('definition')\n    return factoryLabel.call(\n      self,\n      effects,\n      labelAfter,\n      nok,\n      'definitionLabel',\n      'definitionLabelMarker',\n      'definitionLabelString'\n    )(code)\n  }\n\n  function labelAfter(code) {\n    identifier = normalizeIdentifier(\n      self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1)\n    )\n\n    if (code === 58) {\n      effects.enter('definitionMarker')\n      effects.consume(code)\n      effects.exit('definitionMarker') // Note: blank lines can’t exist in content.\n\n      return factoryWhitespace(\n        effects,\n        factoryDestination(\n          effects,\n          effects.attempt(\n            titleConstruct,\n            factorySpace(effects, after, 'whitespace'),\n            factorySpace(effects, after, 'whitespace')\n          ),\n          nok,\n          'definitionDestination',\n          'definitionDestinationLiteral',\n          'definitionDestinationLiteralMarker',\n          'definitionDestinationRaw',\n          'definitionDestinationString'\n        )\n      )\n    }\n\n    return nok(code)\n  }\n\n  function after(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('definition')\n\n      if (self.parser.defined.indexOf(identifier) < 0) {\n        self.parser.defined.push(identifier)\n      }\n\n      return ok(code)\n    }\n\n    return nok(code)\n  }\n}\n\nfunction tokenizeTitle(effects, ok, nok) {\n  return start\n\n  function start(code) {\n    return markdownLineEndingOrSpace(code)\n      ? factoryWhitespace(effects, before)(code)\n      : nok(code)\n  }\n\n  function before(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      return factoryTitle(\n        effects,\n        factorySpace(effects, after, 'whitespace'),\n        nok,\n        'definitionTitle',\n        'definitionTitleMarker',\n        'definitionTitleString'\n      )(code)\n    }\n\n    return nok(code)\n  }\n\n  function after(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code)\n  }\n}\n\nmodule.exports = definition\n","'use strict'\n\nvar asciiControl = require('../character/ascii-control.js')\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js')\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\n\n// eslint-disable-next-line max-params\nfunction destinationFactory(\n  effects,\n  ok,\n  nok,\n  type,\n  literalType,\n  literalMarkerType,\n  rawType,\n  stringType,\n  max\n) {\n  var limit = max || Infinity\n  var balance = 0\n  return start\n\n  function start(code) {\n    if (code === 60) {\n      effects.enter(type)\n      effects.enter(literalType)\n      effects.enter(literalMarkerType)\n      effects.consume(code)\n      effects.exit(literalMarkerType)\n      return destinationEnclosedBefore\n    }\n\n    if (asciiControl(code) || code === 41) {\n      return nok(code)\n    }\n\n    effects.enter(type)\n    effects.enter(rawType)\n    effects.enter(stringType)\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return destinationRaw(code)\n  }\n\n  function destinationEnclosedBefore(code) {\n    if (code === 62) {\n      effects.enter(literalMarkerType)\n      effects.consume(code)\n      effects.exit(literalMarkerType)\n      effects.exit(literalType)\n      effects.exit(type)\n      return ok\n    }\n\n    effects.enter(stringType)\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return destinationEnclosed(code)\n  }\n\n  function destinationEnclosed(code) {\n    if (code === 62) {\n      effects.exit('chunkString')\n      effects.exit(stringType)\n      return destinationEnclosedBefore(code)\n    }\n\n    if (code === null || code === 60 || markdownLineEnding(code)) {\n      return nok(code)\n    }\n\n    effects.consume(code)\n    return code === 92 ? destinationEnclosedEscape : destinationEnclosed\n  }\n\n  function destinationEnclosedEscape(code) {\n    if (code === 60 || code === 62 || code === 92) {\n      effects.consume(code)\n      return destinationEnclosed\n    }\n\n    return destinationEnclosed(code)\n  }\n\n  function destinationRaw(code) {\n    if (code === 40) {\n      if (++balance > limit) return nok(code)\n      effects.consume(code)\n      return destinationRaw\n    }\n\n    if (code === 41) {\n      if (!balance--) {\n        effects.exit('chunkString')\n        effects.exit(stringType)\n        effects.exit(rawType)\n        effects.exit(type)\n        return ok(code)\n      }\n\n      effects.consume(code)\n      return destinationRaw\n    }\n\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      if (balance) return nok(code)\n      effects.exit('chunkString')\n      effects.exit(stringType)\n      effects.exit(rawType)\n      effects.exit(type)\n      return ok(code)\n    }\n\n    if (asciiControl(code)) return nok(code)\n    effects.consume(code)\n    return code === 92 ? destinationRawEscape : destinationRaw\n  }\n\n  function destinationRawEscape(code) {\n    if (code === 40 || code === 41 || code === 92) {\n      effects.consume(code)\n      return destinationRaw\n    }\n\n    return destinationRaw(code)\n  }\n}\n\nmodule.exports = destinationFactory\n","'use strict'\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\nvar markdownSpace = require('../character/markdown-space.js')\n\n// eslint-disable-next-line max-params\nfunction labelFactory(effects, ok, nok, type, markerType, stringType) {\n  var self = this\n  var size = 0\n  var data\n  return start\n\n  function start(code) {\n    effects.enter(type)\n    effects.enter(markerType)\n    effects.consume(code)\n    effects.exit(markerType)\n    effects.enter(stringType)\n    return atBreak\n  }\n\n  function atBreak(code) {\n    if (\n      code === null ||\n      code === 91 ||\n      (code === 93 && !data) ||\n      /* c8 ignore next */\n      (code === 94 &&\n        /* c8 ignore next */\n        !size &&\n        /* c8 ignore next */\n        '_hiddenFootnoteSupport' in self.parser.constructs) ||\n      size > 999\n    ) {\n      return nok(code)\n    }\n\n    if (code === 93) {\n      effects.exit(stringType)\n      effects.enter(markerType)\n      effects.consume(code)\n      effects.exit(markerType)\n      effects.exit(type)\n      return ok\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return atBreak\n    }\n\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return label(code)\n  }\n\n  function label(code) {\n    if (\n      code === null ||\n      code === 91 ||\n      code === 93 ||\n      markdownLineEnding(code) ||\n      size++ > 999\n    ) {\n      effects.exit('chunkString')\n      return atBreak(code)\n    }\n\n    effects.consume(code)\n    data = data || !markdownSpace(code)\n    return code === 92 ? labelEscape : label\n  }\n\n  function labelEscape(code) {\n    if (code === 91 || code === 92 || code === 93) {\n      effects.consume(code)\n      size++\n      return label\n    }\n\n    return label(code)\n  }\n}\n\nmodule.exports = labelFactory\n","'use strict'\n\nvar markdownSpace = require('../character/markdown-space.js')\n\nfunction spaceFactory(effects, ok, type, max) {\n  var limit = max ? max - 1 : Infinity\n  var size = 0\n  return start\n\n  function start(code) {\n    if (markdownSpace(code)) {\n      effects.enter(type)\n      return prefix(code)\n    }\n\n    return ok(code)\n  }\n\n  function prefix(code) {\n    if (markdownSpace(code) && size++ < limit) {\n      effects.consume(code)\n      return prefix\n    }\n\n    effects.exit(type)\n    return ok(code)\n  }\n}\n\nmodule.exports = spaceFactory\n","'use strict'\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\nvar factorySpace = require('./factory-space.js')\n\nfunction titleFactory(effects, ok, nok, type, markerType, stringType) {\n  var marker\n  return start\n\n  function start(code) {\n    effects.enter(type)\n    effects.enter(markerType)\n    effects.consume(code)\n    effects.exit(markerType)\n    marker = code === 40 ? 41 : code\n    return atFirstTitleBreak\n  }\n\n  function atFirstTitleBreak(code) {\n    if (code === marker) {\n      effects.enter(markerType)\n      effects.consume(code)\n      effects.exit(markerType)\n      effects.exit(type)\n      return ok\n    }\n\n    effects.enter(stringType)\n    return atTitleBreak(code)\n  }\n\n  function atTitleBreak(code) {\n    if (code === marker) {\n      effects.exit(stringType)\n      return atFirstTitleBreak(marker)\n    }\n\n    if (code === null) {\n      return nok(code)\n    } // Note: blank lines can’t exist in content.\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return factorySpace(effects, atTitleBreak, 'linePrefix')\n    }\n\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return title(code)\n  }\n\n  function title(code) {\n    if (code === marker || code === null || markdownLineEnding(code)) {\n      effects.exit('chunkString')\n      return atTitleBreak(code)\n    }\n\n    effects.consume(code)\n    return code === 92 ? titleEscape : title\n  }\n\n  function titleEscape(code) {\n    if (code === marker || code === 92) {\n      effects.consume(code)\n      return title\n    }\n\n    return title(code)\n  }\n}\n\nmodule.exports = titleFactory\n","'use strict'\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\nvar markdownSpace = require('../character/markdown-space.js')\nvar factorySpace = require('./factory-space.js')\n\nfunction whitespaceFactory(effects, ok) {\n  var seen\n  return start\n\n  function start(code) {\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      seen = true\n      return start\n    }\n\n    if (markdownSpace(code)) {\n      return factorySpace(\n        effects,\n        start,\n        seen ? 'linePrefix' : 'lineSuffix'\n      )(code)\n    }\n\n    return ok(code)\n  }\n}\n\nmodule.exports = whitespaceFactory\n","'use strict'\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\n\nvar hardBreakEscape = {\n  name: 'hardBreakEscape',\n  tokenize: tokenizeHardBreakEscape\n}\n\nfunction tokenizeHardBreakEscape(effects, ok, nok) {\n  return start\n\n  function start(code) {\n    effects.enter('hardBreakEscape')\n    effects.enter('escapeMarker')\n    effects.consume(code)\n    return open\n  }\n\n  function open(code) {\n    if (markdownLineEnding(code)) {\n      effects.exit('escapeMarker')\n      effects.exit('hardBreakEscape')\n      return ok(code)\n    }\n\n    return nok(code)\n  }\n}\n\nmodule.exports = hardBreakEscape\n","'use strict'\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js')\nvar markdownSpace = require('../character/markdown-space.js')\nvar chunkedSplice = require('../util/chunked-splice.js')\nvar factorySpace = require('./factory-space.js')\n\nvar headingAtx = {\n  name: 'headingAtx',\n  tokenize: tokenizeHeadingAtx,\n  resolve: resolveHeadingAtx\n}\n\nfunction resolveHeadingAtx(events, context) {\n  var contentEnd = events.length - 2\n  var contentStart = 3\n  var content\n  var text // Prefix whitespace, part of the opening.\n\n  if (events[contentStart][1].type === 'whitespace') {\n    contentStart += 2\n  } // Suffix whitespace, part of the closing.\n\n  if (\n    contentEnd - 2 > contentStart &&\n    events[contentEnd][1].type === 'whitespace'\n  ) {\n    contentEnd -= 2\n  }\n\n  if (\n    events[contentEnd][1].type === 'atxHeadingSequence' &&\n    (contentStart === contentEnd - 1 ||\n      (contentEnd - 4 > contentStart &&\n        events[contentEnd - 2][1].type === 'whitespace'))\n  ) {\n    contentEnd -= contentStart + 1 === contentEnd ? 2 : 4\n  }\n\n  if (contentEnd > contentStart) {\n    content = {\n      type: 'atxHeadingText',\n      start: events[contentStart][1].start,\n      end: events[contentEnd][1].end\n    }\n    text = {\n      type: 'chunkText',\n      start: events[contentStart][1].start,\n      end: events[contentEnd][1].end,\n      contentType: 'text'\n    }\n    chunkedSplice(events, contentStart, contentEnd - contentStart + 1, [\n      ['enter', content, context],\n      ['enter', text, context],\n      ['exit', text, context],\n      ['exit', content, context]\n    ])\n  }\n\n  return events\n}\n\nfunction tokenizeHeadingAtx(effects, ok, nok) {\n  var self = this\n  var size = 0\n  return start\n\n  function start(code) {\n    effects.enter('atxHeading')\n    effects.enter('atxHeadingSequence')\n    return fenceOpenInside(code)\n  }\n\n  function fenceOpenInside(code) {\n    if (code === 35 && size++ < 6) {\n      effects.consume(code)\n      return fenceOpenInside\n    }\n\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      effects.exit('atxHeadingSequence')\n      return self.interrupt ? ok(code) : headingBreak(code)\n    }\n\n    return nok(code)\n  }\n\n  function headingBreak(code) {\n    if (code === 35) {\n      effects.enter('atxHeadingSequence')\n      return sequence(code)\n    }\n\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('atxHeading')\n      return ok(code)\n    }\n\n    if (markdownSpace(code)) {\n      return factorySpace(effects, headingBreak, 'whitespace')(code)\n    }\n\n    effects.enter('atxHeadingText')\n    return data(code)\n  }\n\n  function sequence(code) {\n    if (code === 35) {\n      effects.consume(code)\n      return sequence\n    }\n\n    effects.exit('atxHeadingSequence')\n    return headingBreak(code)\n  }\n\n  function data(code) {\n    if (code === null || code === 35 || markdownLineEndingOrSpace(code)) {\n      effects.exit('atxHeadingText')\n      return headingBreak(code)\n    }\n\n    effects.consume(code)\n    return data\n  }\n}\n\nmodule.exports = headingAtx\n","'use strict'\n\nvar asciiAlpha = require('../character/ascii-alpha.js')\nvar asciiAlphanumeric = require('../character/ascii-alphanumeric.js')\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js')\nvar markdownSpace = require('../character/markdown-space.js')\nvar fromCharCode = require('../constant/from-char-code.js')\nvar htmlBlockNames = require('../constant/html-block-names.js')\nvar htmlRawNames = require('../constant/html-raw-names.js')\nvar partialBlankLine = require('./partial-blank-line.js')\n\nvar htmlFlow = {\n  name: 'htmlFlow',\n  tokenize: tokenizeHtmlFlow,\n  resolveTo: resolveToHtmlFlow,\n  concrete: true\n}\nvar nextBlankConstruct = {\n  tokenize: tokenizeNextBlank,\n  partial: true\n}\n\nfunction resolveToHtmlFlow(events) {\n  var index = events.length\n\n  while (index--) {\n    if (events[index][0] === 'enter' && events[index][1].type === 'htmlFlow') {\n      break\n    }\n  }\n\n  if (index > 1 && events[index - 2][1].type === 'linePrefix') {\n    // Add the prefix start to the HTML token.\n    events[index][1].start = events[index - 2][1].start // Add the prefix start to the HTML line token.\n\n    events[index + 1][1].start = events[index - 2][1].start // Remove the line prefix.\n\n    events.splice(index - 2, 2)\n  }\n\n  return events\n}\n\nfunction tokenizeHtmlFlow(effects, ok, nok) {\n  var self = this\n  var kind\n  var startTag\n  var buffer\n  var index\n  var marker\n  return start\n\n  function start(code) {\n    effects.enter('htmlFlow')\n    effects.enter('htmlFlowData')\n    effects.consume(code)\n    return open\n  }\n\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code)\n      return declarationStart\n    }\n\n    if (code === 47) {\n      effects.consume(code)\n      return tagCloseStart\n    }\n\n    if (code === 63) {\n      effects.consume(code)\n      kind = 3 // While we’re in an instruction instead of a declaration, we’re on a `?`\n      // right now, so we do need to search for `>`, similar to declarations.\n\n      return self.interrupt ? ok : continuationDeclarationInside\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      buffer = fromCharCode(code)\n      startTag = true\n      return tagName\n    }\n\n    return nok(code)\n  }\n\n  function declarationStart(code) {\n    if (code === 45) {\n      effects.consume(code)\n      kind = 2\n      return commentOpenInside\n    }\n\n    if (code === 91) {\n      effects.consume(code)\n      kind = 5\n      buffer = 'CDATA['\n      index = 0\n      return cdataOpenInside\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      kind = 4\n      return self.interrupt ? ok : continuationDeclarationInside\n    }\n\n    return nok(code)\n  }\n\n  function commentOpenInside(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return self.interrupt ? ok : continuationDeclarationInside\n    }\n\n    return nok(code)\n  }\n\n  function cdataOpenInside(code) {\n    if (code === buffer.charCodeAt(index++)) {\n      effects.consume(code)\n      return index === buffer.length\n        ? self.interrupt\n          ? ok\n          : continuation\n        : cdataOpenInside\n    }\n\n    return nok(code)\n  }\n\n  function tagCloseStart(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      buffer = fromCharCode(code)\n      return tagName\n    }\n\n    return nok(code)\n  }\n\n  function tagName(code) {\n    if (\n      code === null ||\n      code === 47 ||\n      code === 62 ||\n      markdownLineEndingOrSpace(code)\n    ) {\n      if (\n        code !== 47 &&\n        startTag &&\n        htmlRawNames.indexOf(buffer.toLowerCase()) > -1\n      ) {\n        kind = 1\n        return self.interrupt ? ok(code) : continuation(code)\n      }\n\n      if (htmlBlockNames.indexOf(buffer.toLowerCase()) > -1) {\n        kind = 6\n\n        if (code === 47) {\n          effects.consume(code)\n          return basicSelfClosing\n        }\n\n        return self.interrupt ? ok(code) : continuation(code)\n      }\n\n      kind = 7 // Do not support complete HTML when interrupting.\n\n      return self.interrupt\n        ? nok(code)\n        : startTag\n        ? completeAttributeNameBefore(code)\n        : completeClosingTagAfter(code)\n    }\n\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code)\n      buffer += fromCharCode(code)\n      return tagName\n    }\n\n    return nok(code)\n  }\n\n  function basicSelfClosing(code) {\n    if (code === 62) {\n      effects.consume(code)\n      return self.interrupt ? ok : continuation\n    }\n\n    return nok(code)\n  }\n\n  function completeClosingTagAfter(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeClosingTagAfter\n    }\n\n    return completeEnd(code)\n  }\n\n  function completeAttributeNameBefore(code) {\n    if (code === 47) {\n      effects.consume(code)\n      return completeEnd\n    }\n\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code)\n      return completeAttributeName\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeAttributeNameBefore\n    }\n\n    return completeEnd(code)\n  }\n\n  function completeAttributeName(code) {\n    if (\n      code === 45 ||\n      code === 46 ||\n      code === 58 ||\n      code === 95 ||\n      asciiAlphanumeric(code)\n    ) {\n      effects.consume(code)\n      return completeAttributeName\n    }\n\n    return completeAttributeNameAfter(code)\n  }\n\n  function completeAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code)\n      return completeAttributeValueBefore\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeAttributeNameAfter\n    }\n\n    return completeAttributeNameBefore(code)\n  }\n\n  function completeAttributeValueBefore(code) {\n    if (\n      code === null ||\n      code === 60 ||\n      code === 61 ||\n      code === 62 ||\n      code === 96\n    ) {\n      return nok(code)\n    }\n\n    if (code === 34 || code === 39) {\n      effects.consume(code)\n      marker = code\n      return completeAttributeValueQuoted\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeAttributeValueBefore\n    }\n\n    marker = undefined\n    return completeAttributeValueUnquoted(code)\n  }\n\n  function completeAttributeValueQuoted(code) {\n    if (code === marker) {\n      effects.consume(code)\n      return completeAttributeValueQuotedAfter\n    }\n\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code)\n    }\n\n    effects.consume(code)\n    return completeAttributeValueQuoted\n  }\n\n  function completeAttributeValueUnquoted(code) {\n    if (\n      code === null ||\n      code === 34 ||\n      code === 39 ||\n      code === 60 ||\n      code === 61 ||\n      code === 62 ||\n      code === 96 ||\n      markdownLineEndingOrSpace(code)\n    ) {\n      return completeAttributeNameAfter(code)\n    }\n\n    effects.consume(code)\n    return completeAttributeValueUnquoted\n  }\n\n  function completeAttributeValueQuotedAfter(code) {\n    if (code === 47 || code === 62 || markdownSpace(code)) {\n      return completeAttributeNameBefore(code)\n    }\n\n    return nok(code)\n  }\n\n  function completeEnd(code) {\n    if (code === 62) {\n      effects.consume(code)\n      return completeAfter\n    }\n\n    return nok(code)\n  }\n\n  function completeAfter(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeAfter\n    }\n\n    return code === null || markdownLineEnding(code)\n      ? continuation(code)\n      : nok(code)\n  }\n\n  function continuation(code) {\n    if (code === 45 && kind === 2) {\n      effects.consume(code)\n      return continuationCommentInside\n    }\n\n    if (code === 60 && kind === 1) {\n      effects.consume(code)\n      return continuationRawTagOpen\n    }\n\n    if (code === 62 && kind === 4) {\n      effects.consume(code)\n      return continuationClose\n    }\n\n    if (code === 63 && kind === 3) {\n      effects.consume(code)\n      return continuationDeclarationInside\n    }\n\n    if (code === 93 && kind === 5) {\n      effects.consume(code)\n      return continuationCharacterDataInside\n    }\n\n    if (markdownLineEnding(code) && (kind === 6 || kind === 7)) {\n      return effects.check(\n        nextBlankConstruct,\n        continuationClose,\n        continuationAtLineEnding\n      )(code)\n    }\n\n    if (code === null || markdownLineEnding(code)) {\n      return continuationAtLineEnding(code)\n    }\n\n    effects.consume(code)\n    return continuation\n  }\n\n  function continuationAtLineEnding(code) {\n    effects.exit('htmlFlowData')\n    return htmlContinueStart(code)\n  }\n\n  function htmlContinueStart(code) {\n    if (code === null) {\n      return done(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return htmlContinueStart\n    }\n\n    effects.enter('htmlFlowData')\n    return continuation(code)\n  }\n\n  function continuationCommentInside(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return continuationDeclarationInside\n    }\n\n    return continuation(code)\n  }\n\n  function continuationRawTagOpen(code) {\n    if (code === 47) {\n      effects.consume(code)\n      buffer = ''\n      return continuationRawEndTag\n    }\n\n    return continuation(code)\n  }\n\n  function continuationRawEndTag(code) {\n    if (code === 62 && htmlRawNames.indexOf(buffer.toLowerCase()) > -1) {\n      effects.consume(code)\n      return continuationClose\n    }\n\n    if (asciiAlpha(code) && buffer.length < 8) {\n      effects.consume(code)\n      buffer += fromCharCode(code)\n      return continuationRawEndTag\n    }\n\n    return continuation(code)\n  }\n\n  function continuationCharacterDataInside(code) {\n    if (code === 93) {\n      effects.consume(code)\n      return continuationDeclarationInside\n    }\n\n    return continuation(code)\n  }\n\n  function continuationDeclarationInside(code) {\n    if (code === 62) {\n      effects.consume(code)\n      return continuationClose\n    }\n\n    return continuation(code)\n  }\n\n  function continuationClose(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('htmlFlowData')\n      return done(code)\n    }\n\n    effects.consume(code)\n    return continuationClose\n  }\n\n  function done(code) {\n    effects.exit('htmlFlow')\n    return ok(code)\n  }\n}\n\nfunction tokenizeNextBlank(effects, ok, nok) {\n  return start\n\n  function start(code) {\n    effects.exit('htmlFlowData')\n    effects.enter('lineEndingBlank')\n    effects.consume(code)\n    effects.exit('lineEndingBlank')\n    return effects.attempt(partialBlankLine, ok, nok)\n  }\n}\n\nmodule.exports = htmlFlow\n","'use strict'\n\nvar asciiAlpha = require('../character/ascii-alpha.js')\nvar asciiAlphanumeric = require('../character/ascii-alphanumeric.js')\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js')\nvar markdownSpace = require('../character/markdown-space.js')\nvar factorySpace = require('./factory-space.js')\n\nvar htmlText = {\n  name: 'htmlText',\n  tokenize: tokenizeHtmlText\n}\n\nfunction tokenizeHtmlText(effects, ok, nok) {\n  var self = this\n  var marker\n  var buffer\n  var index\n  var returnState\n  return start\n\n  function start(code) {\n    effects.enter('htmlText')\n    effects.enter('htmlTextData')\n    effects.consume(code)\n    return open\n  }\n\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code)\n      return declarationOpen\n    }\n\n    if (code === 47) {\n      effects.consume(code)\n      return tagCloseStart\n    }\n\n    if (code === 63) {\n      effects.consume(code)\n      return instruction\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return tagOpen\n    }\n\n    return nok(code)\n  }\n\n  function declarationOpen(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return commentOpen\n    }\n\n    if (code === 91) {\n      effects.consume(code)\n      buffer = 'CDATA['\n      index = 0\n      return cdataOpen\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return declaration\n    }\n\n    return nok(code)\n  }\n\n  function commentOpen(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return commentStart\n    }\n\n    return nok(code)\n  }\n\n  function commentStart(code) {\n    if (code === null || code === 62) {\n      return nok(code)\n    }\n\n    if (code === 45) {\n      effects.consume(code)\n      return commentStartDash\n    }\n\n    return comment(code)\n  }\n\n  function commentStartDash(code) {\n    if (code === null || code === 62) {\n      return nok(code)\n    }\n\n    return comment(code)\n  }\n\n  function comment(code) {\n    if (code === null) {\n      return nok(code)\n    }\n\n    if (code === 45) {\n      effects.consume(code)\n      return commentClose\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = comment\n      return atLineEnding(code)\n    }\n\n    effects.consume(code)\n    return comment\n  }\n\n  function commentClose(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return end\n    }\n\n    return comment(code)\n  }\n\n  function cdataOpen(code) {\n    if (code === buffer.charCodeAt(index++)) {\n      effects.consume(code)\n      return index === buffer.length ? cdata : cdataOpen\n    }\n\n    return nok(code)\n  }\n\n  function cdata(code) {\n    if (code === null) {\n      return nok(code)\n    }\n\n    if (code === 93) {\n      effects.consume(code)\n      return cdataClose\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = cdata\n      return atLineEnding(code)\n    }\n\n    effects.consume(code)\n    return cdata\n  }\n\n  function cdataClose(code) {\n    if (code === 93) {\n      effects.consume(code)\n      return cdataEnd\n    }\n\n    return cdata(code)\n  }\n\n  function cdataEnd(code) {\n    if (code === 62) {\n      return end(code)\n    }\n\n    if (code === 93) {\n      effects.consume(code)\n      return cdataEnd\n    }\n\n    return cdata(code)\n  }\n\n  function declaration(code) {\n    if (code === null || code === 62) {\n      return end(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = declaration\n      return atLineEnding(code)\n    }\n\n    effects.consume(code)\n    return declaration\n  }\n\n  function instruction(code) {\n    if (code === null) {\n      return nok(code)\n    }\n\n    if (code === 63) {\n      effects.consume(code)\n      return instructionClose\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = instruction\n      return atLineEnding(code)\n    }\n\n    effects.consume(code)\n    return instruction\n  }\n\n  function instructionClose(code) {\n    return code === 62 ? end(code) : instruction(code)\n  }\n\n  function tagCloseStart(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return tagClose\n    }\n\n    return nok(code)\n  }\n\n  function tagClose(code) {\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code)\n      return tagClose\n    }\n\n    return tagCloseBetween(code)\n  }\n\n  function tagCloseBetween(code) {\n    if (markdownLineEnding(code)) {\n      returnState = tagCloseBetween\n      return atLineEnding(code)\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return tagCloseBetween\n    }\n\n    return end(code)\n  }\n\n  function tagOpen(code) {\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code)\n      return tagOpen\n    }\n\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code)\n    }\n\n    return nok(code)\n  }\n\n  function tagOpenBetween(code) {\n    if (code === 47) {\n      effects.consume(code)\n      return end\n    }\n\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code)\n      return tagOpenAttributeName\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenBetween\n      return atLineEnding(code)\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return tagOpenBetween\n    }\n\n    return end(code)\n  }\n\n  function tagOpenAttributeName(code) {\n    if (\n      code === 45 ||\n      code === 46 ||\n      code === 58 ||\n      code === 95 ||\n      asciiAlphanumeric(code)\n    ) {\n      effects.consume(code)\n      return tagOpenAttributeName\n    }\n\n    return tagOpenAttributeNameAfter(code)\n  }\n\n  function tagOpenAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code)\n      return tagOpenAttributeValueBefore\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeNameAfter\n      return atLineEnding(code)\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return tagOpenAttributeNameAfter\n    }\n\n    return tagOpenBetween(code)\n  }\n\n  function tagOpenAttributeValueBefore(code) {\n    if (\n      code === null ||\n      code === 60 ||\n      code === 61 ||\n      code === 62 ||\n      code === 96\n    ) {\n      return nok(code)\n    }\n\n    if (code === 34 || code === 39) {\n      effects.consume(code)\n      marker = code\n      return tagOpenAttributeValueQuoted\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueBefore\n      return atLineEnding(code)\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return tagOpenAttributeValueBefore\n    }\n\n    effects.consume(code)\n    marker = undefined\n    return tagOpenAttributeValueUnquoted\n  }\n\n  function tagOpenAttributeValueQuoted(code) {\n    if (code === marker) {\n      effects.consume(code)\n      return tagOpenAttributeValueQuotedAfter\n    }\n\n    if (code === null) {\n      return nok(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueQuoted\n      return atLineEnding(code)\n    }\n\n    effects.consume(code)\n    return tagOpenAttributeValueQuoted\n  }\n\n  function tagOpenAttributeValueQuotedAfter(code) {\n    if (code === 62 || code === 47 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code)\n    }\n\n    return nok(code)\n  }\n\n  function tagOpenAttributeValueUnquoted(code) {\n    if (\n      code === null ||\n      code === 34 ||\n      code === 39 ||\n      code === 60 ||\n      code === 61 ||\n      code === 96\n    ) {\n      return nok(code)\n    }\n\n    if (code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code)\n    }\n\n    effects.consume(code)\n    return tagOpenAttributeValueUnquoted\n  } // We can’t have blank lines in content, so no need to worry about empty\n  // tokens.\n\n  function atLineEnding(code) {\n    effects.exit('htmlTextData')\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return factorySpace(\n      effects,\n      afterPrefix,\n      'linePrefix',\n      self.parser.constructs.disable.null.indexOf('codeIndented') > -1\n        ? undefined\n        : 4\n    )\n  }\n\n  function afterPrefix(code) {\n    effects.enter('htmlTextData')\n    return returnState(code)\n  }\n\n  function end(code) {\n    if (code === 62) {\n      effects.consume(code)\n      effects.exit('htmlTextData')\n      effects.exit('htmlText')\n      return ok\n    }\n\n    return nok(code)\n  }\n}\n\nmodule.exports = htmlText\n","'use strict'\n\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js')\nvar chunkedPush = require('../util/chunked-push.js')\nvar chunkedSplice = require('../util/chunked-splice.js')\nvar normalizeIdentifier = require('../util/normalize-identifier.js')\nvar resolveAll = require('../util/resolve-all.js')\nvar shallow = require('../util/shallow.js')\nvar factoryDestination = require('./factory-destination.js')\nvar factoryLabel = require('./factory-label.js')\nvar factoryTitle = require('./factory-title.js')\nvar factoryWhitespace = require('./factory-whitespace.js')\n\nvar labelEnd = {\n  name: 'labelEnd',\n  tokenize: tokenizeLabelEnd,\n  resolveTo: resolveToLabelEnd,\n  resolveAll: resolveAllLabelEnd\n}\nvar resourceConstruct = {\n  tokenize: tokenizeResource\n}\nvar fullReferenceConstruct = {\n  tokenize: tokenizeFullReference\n}\nvar collapsedReferenceConstruct = {\n  tokenize: tokenizeCollapsedReference\n}\n\nfunction resolveAllLabelEnd(events) {\n  var index = -1\n  var token\n\n  while (++index < events.length) {\n    token = events[index][1]\n\n    if (\n      !token._used &&\n      (token.type === 'labelImage' ||\n        token.type === 'labelLink' ||\n        token.type === 'labelEnd')\n    ) {\n      // Remove the marker.\n      events.splice(index + 1, token.type === 'labelImage' ? 4 : 2)\n      token.type = 'data'\n      index++\n    }\n  }\n\n  return events\n}\n\nfunction resolveToLabelEnd(events, context) {\n  var index = events.length\n  var offset = 0\n  var group\n  var label\n  var text\n  var token\n  var open\n  var close\n  var media // Find an opening.\n\n  while (index--) {\n    token = events[index][1]\n\n    if (open) {\n      // If we see another link, or inactive link label, we’ve been here before.\n      if (\n        token.type === 'link' ||\n        (token.type === 'labelLink' && token._inactive)\n      ) {\n        break\n      } // Mark other link openings as inactive, as we can’t have links in\n      // links.\n\n      if (events[index][0] === 'enter' && token.type === 'labelLink') {\n        token._inactive = true\n      }\n    } else if (close) {\n      if (\n        events[index][0] === 'enter' &&\n        (token.type === 'labelImage' || token.type === 'labelLink') &&\n        !token._balanced\n      ) {\n        open = index\n\n        if (token.type !== 'labelLink') {\n          offset = 2\n          break\n        }\n      }\n    } else if (token.type === 'labelEnd') {\n      close = index\n    }\n  }\n\n  group = {\n    type: events[open][1].type === 'labelLink' ? 'link' : 'image',\n    start: shallow(events[open][1].start),\n    end: shallow(events[events.length - 1][1].end)\n  }\n  label = {\n    type: 'label',\n    start: shallow(events[open][1].start),\n    end: shallow(events[close][1].end)\n  }\n  text = {\n    type: 'labelText',\n    start: shallow(events[open + offset + 2][1].end),\n    end: shallow(events[close - 2][1].start)\n  }\n  media = [\n    ['enter', group, context],\n    ['enter', label, context]\n  ] // Opening marker.\n\n  media = chunkedPush(media, events.slice(open + 1, open + offset + 3)) // Text open.\n\n  media = chunkedPush(media, [['enter', text, context]]) // Between.\n\n  media = chunkedPush(\n    media,\n    resolveAll(\n      context.parser.constructs.insideSpan.null,\n      events.slice(open + offset + 4, close - 3),\n      context\n    )\n  ) // Text close, marker close, label close.\n\n  media = chunkedPush(media, [\n    ['exit', text, context],\n    events[close - 2],\n    events[close - 1],\n    ['exit', label, context]\n  ]) // Reference, resource, or so.\n\n  media = chunkedPush(media, events.slice(close + 1)) // Media close.\n\n  media = chunkedPush(media, [['exit', group, context]])\n  chunkedSplice(events, open, events.length, media)\n  return events\n}\n\nfunction tokenizeLabelEnd(effects, ok, nok) {\n  var self = this\n  var index = self.events.length\n  var labelStart\n  var defined // Find an opening.\n\n  while (index--) {\n    if (\n      (self.events[index][1].type === 'labelImage' ||\n        self.events[index][1].type === 'labelLink') &&\n      !self.events[index][1]._balanced\n    ) {\n      labelStart = self.events[index][1]\n      break\n    }\n  }\n\n  return start\n\n  function start(code) {\n    if (!labelStart) {\n      return nok(code)\n    } // It’s a balanced bracket, but contains a link.\n\n    if (labelStart._inactive) return balanced(code)\n    defined =\n      self.parser.defined.indexOf(\n        normalizeIdentifier(\n          self.sliceSerialize({\n            start: labelStart.end,\n            end: self.now()\n          })\n        )\n      ) > -1\n    effects.enter('labelEnd')\n    effects.enter('labelMarker')\n    effects.consume(code)\n    effects.exit('labelMarker')\n    effects.exit('labelEnd')\n    return afterLabelEnd\n  }\n\n  function afterLabelEnd(code) {\n    // Resource: `[asd](fgh)`.\n    if (code === 40) {\n      return effects.attempt(\n        resourceConstruct,\n        ok,\n        defined ? ok : balanced\n      )(code)\n    } // Collapsed (`[asd][]`) or full (`[asd][fgh]`) reference?\n\n    if (code === 91) {\n      return effects.attempt(\n        fullReferenceConstruct,\n        ok,\n        defined\n          ? effects.attempt(collapsedReferenceConstruct, ok, balanced)\n          : balanced\n      )(code)\n    } // Shortcut reference: `[asd]`?\n\n    return defined ? ok(code) : balanced(code)\n  }\n\n  function balanced(code) {\n    labelStart._balanced = true\n    return nok(code)\n  }\n}\n\nfunction tokenizeResource(effects, ok, nok) {\n  return start\n\n  function start(code) {\n    effects.enter('resource')\n    effects.enter('resourceMarker')\n    effects.consume(code)\n    effects.exit('resourceMarker')\n    return factoryWhitespace(effects, open)\n  }\n\n  function open(code) {\n    if (code === 41) {\n      return end(code)\n    }\n\n    return factoryDestination(\n      effects,\n      destinationAfter,\n      nok,\n      'resourceDestination',\n      'resourceDestinationLiteral',\n      'resourceDestinationLiteralMarker',\n      'resourceDestinationRaw',\n      'resourceDestinationString',\n      3\n    )(code)\n  }\n\n  function destinationAfter(code) {\n    return markdownLineEndingOrSpace(code)\n      ? factoryWhitespace(effects, between)(code)\n      : end(code)\n  }\n\n  function between(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      return factoryTitle(\n        effects,\n        factoryWhitespace(effects, end),\n        nok,\n        'resourceTitle',\n        'resourceTitleMarker',\n        'resourceTitleString'\n      )(code)\n    }\n\n    return end(code)\n  }\n\n  function end(code) {\n    if (code === 41) {\n      effects.enter('resourceMarker')\n      effects.consume(code)\n      effects.exit('resourceMarker')\n      effects.exit('resource')\n      return ok\n    }\n\n    return nok(code)\n  }\n}\n\nfunction tokenizeFullReference(effects, ok, nok) {\n  var self = this\n  return start\n\n  function start(code) {\n    return factoryLabel.call(\n      self,\n      effects,\n      afterLabel,\n      nok,\n      'reference',\n      'referenceMarker',\n      'referenceString'\n    )(code)\n  }\n\n  function afterLabel(code) {\n    return self.parser.defined.indexOf(\n      normalizeIdentifier(\n        self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1)\n      )\n    ) < 0\n      ? nok(code)\n      : ok(code)\n  }\n}\n\nfunction tokenizeCollapsedReference(effects, ok, nok) {\n  return start\n\n  function start(code) {\n    effects.enter('reference')\n    effects.enter('referenceMarker')\n    effects.consume(code)\n    effects.exit('referenceMarker')\n    return open\n  }\n\n  function open(code) {\n    if (code === 93) {\n      effects.enter('referenceMarker')\n      effects.consume(code)\n      effects.exit('referenceMarker')\n      effects.exit('reference')\n      return ok\n    }\n\n    return nok(code)\n  }\n}\n\nmodule.exports = labelEnd\n","'use strict'\n\nvar labelEnd = require('./label-end.js')\n\nvar labelStartImage = {\n  name: 'labelStartImage',\n  tokenize: tokenizeLabelStartImage,\n  resolveAll: labelEnd.resolveAll\n}\n\nfunction tokenizeLabelStartImage(effects, ok, nok) {\n  var self = this\n  return start\n\n  function start(code) {\n    effects.enter('labelImage')\n    effects.enter('labelImageMarker')\n    effects.consume(code)\n    effects.exit('labelImageMarker')\n    return open\n  }\n\n  function open(code) {\n    if (code === 91) {\n      effects.enter('labelMarker')\n      effects.consume(code)\n      effects.exit('labelMarker')\n      effects.exit('labelImage')\n      return after\n    }\n\n    return nok(code)\n  }\n\n  function after(code) {\n    /* c8 ignore next */\n    return code === 94 &&\n      /* c8 ignore next */\n      '_hiddenFootnoteSupport' in self.parser.constructs\n      ? /* c8 ignore next */\n        nok(code)\n      : ok(code)\n  }\n}\n\nmodule.exports = labelStartImage\n","'use strict'\n\nvar labelEnd = require('./label-end.js')\n\nvar labelStartLink = {\n  name: 'labelStartLink',\n  tokenize: tokenizeLabelStartLink,\n  resolveAll: labelEnd.resolveAll\n}\n\nfunction tokenizeLabelStartLink(effects, ok, nok) {\n  var self = this\n  return start\n\n  function start(code) {\n    effects.enter('labelLink')\n    effects.enter('labelMarker')\n    effects.consume(code)\n    effects.exit('labelMarker')\n    effects.exit('labelLink')\n    return after\n  }\n\n  function after(code) {\n    /* c8 ignore next */\n    return code === 94 &&\n      /* c8 ignore next */\n      '_hiddenFootnoteSupport' in self.parser.constructs\n      ? /* c8 ignore next */\n        nok(code)\n      : ok(code)\n  }\n}\n\nmodule.exports = labelStartLink\n","'use strict'\n\nvar factorySpace = require('./factory-space.js')\n\nvar lineEnding = {\n  name: 'lineEnding',\n  tokenize: tokenizeLineEnding\n}\n\nfunction tokenizeLineEnding(effects, ok) {\n  return start\n\n  function start(code) {\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return factorySpace(effects, ok, 'linePrefix')\n  }\n}\n\nmodule.exports = lineEnding\n","'use strict'\n\nvar asciiDigit = require('../character/ascii-digit.js')\nvar markdownSpace = require('../character/markdown-space.js')\nvar prefixSize = require('../util/prefix-size.js')\nvar sizeChunks = require('../util/size-chunks.js')\nvar factorySpace = require('./factory-space.js')\nvar partialBlankLine = require('./partial-blank-line.js')\nvar thematicBreak = require('./thematic-break.js')\n\nvar list = {\n  name: 'list',\n  tokenize: tokenizeListStart,\n  continuation: {\n    tokenize: tokenizeListContinuation\n  },\n  exit: tokenizeListEnd\n}\nvar listItemPrefixWhitespaceConstruct = {\n  tokenize: tokenizeListItemPrefixWhitespace,\n  partial: true\n}\nvar indentConstruct = {\n  tokenize: tokenizeIndent,\n  partial: true\n}\n\nfunction tokenizeListStart(effects, ok, nok) {\n  var self = this\n  var initialSize = prefixSize(self.events, 'linePrefix')\n  var size = 0\n  return start\n\n  function start(code) {\n    var kind =\n      self.containerState.type ||\n      (code === 42 || code === 43 || code === 45\n        ? 'listUnordered'\n        : 'listOrdered')\n\n    if (\n      kind === 'listUnordered'\n        ? !self.containerState.marker || code === self.containerState.marker\n        : asciiDigit(code)\n    ) {\n      if (!self.containerState.type) {\n        self.containerState.type = kind\n        effects.enter(kind, {\n          _container: true\n        })\n      }\n\n      if (kind === 'listUnordered') {\n        effects.enter('listItemPrefix')\n        return code === 42 || code === 45\n          ? effects.check(thematicBreak, nok, atMarker)(code)\n          : atMarker(code)\n      }\n\n      if (!self.interrupt || code === 49) {\n        effects.enter('listItemPrefix')\n        effects.enter('listItemValue')\n        return inside(code)\n      }\n    }\n\n    return nok(code)\n  }\n\n  function inside(code) {\n    if (asciiDigit(code) && ++size < 10) {\n      effects.consume(code)\n      return inside\n    }\n\n    if (\n      (!self.interrupt || size < 2) &&\n      (self.containerState.marker\n        ? code === self.containerState.marker\n        : code === 41 || code === 46)\n    ) {\n      effects.exit('listItemValue')\n      return atMarker(code)\n    }\n\n    return nok(code)\n  }\n\n  function atMarker(code) {\n    effects.enter('listItemMarker')\n    effects.consume(code)\n    effects.exit('listItemMarker')\n    self.containerState.marker = self.containerState.marker || code\n    return effects.check(\n      partialBlankLine, // Can’t be empty when interrupting.\n      self.interrupt ? nok : onBlank,\n      effects.attempt(\n        listItemPrefixWhitespaceConstruct,\n        endOfPrefix,\n        otherPrefix\n      )\n    )\n  }\n\n  function onBlank(code) {\n    self.containerState.initialBlankLine = true\n    initialSize++\n    return endOfPrefix(code)\n  }\n\n  function otherPrefix(code) {\n    if (markdownSpace(code)) {\n      effects.enter('listItemPrefixWhitespace')\n      effects.consume(code)\n      effects.exit('listItemPrefixWhitespace')\n      return endOfPrefix\n    }\n\n    return nok(code)\n  }\n\n  function endOfPrefix(code) {\n    self.containerState.size =\n      initialSize + sizeChunks(self.sliceStream(effects.exit('listItemPrefix')))\n    return ok(code)\n  }\n}\n\nfunction tokenizeListContinuation(effects, ok, nok) {\n  var self = this\n  self.containerState._closeFlow = undefined\n  return effects.check(partialBlankLine, onBlank, notBlank)\n\n  function onBlank(code) {\n    self.containerState.furtherBlankLines =\n      self.containerState.furtherBlankLines ||\n      self.containerState.initialBlankLine // We have a blank line.\n    // Still, try to consume at most the items size.\n\n    return factorySpace(\n      effects,\n      ok,\n      'listItemIndent',\n      self.containerState.size + 1\n    )(code)\n  }\n\n  function notBlank(code) {\n    if (self.containerState.furtherBlankLines || !markdownSpace(code)) {\n      self.containerState.furtherBlankLines = self.containerState.initialBlankLine = undefined\n      return notInCurrentItem(code)\n    }\n\n    self.containerState.furtherBlankLines = self.containerState.initialBlankLine = undefined\n    return effects.attempt(indentConstruct, ok, notInCurrentItem)(code)\n  }\n\n  function notInCurrentItem(code) {\n    // While we do continue, we signal that the flow should be closed.\n    self.containerState._closeFlow = true // As we’re closing flow, we’re no longer interrupting.\n\n    self.interrupt = undefined\n    return factorySpace(\n      effects,\n      effects.attempt(list, ok, nok),\n      'linePrefix',\n      self.parser.constructs.disable.null.indexOf('codeIndented') > -1\n        ? undefined\n        : 4\n    )(code)\n  }\n}\n\nfunction tokenizeIndent(effects, ok, nok) {\n  var self = this\n  return factorySpace(\n    effects,\n    afterPrefix,\n    'listItemIndent',\n    self.containerState.size + 1\n  )\n\n  function afterPrefix(code) {\n    return prefixSize(self.events, 'listItemIndent') ===\n      self.containerState.size\n      ? ok(code)\n      : nok(code)\n  }\n}\n\nfunction tokenizeListEnd(effects) {\n  effects.exit(this.containerState.type)\n}\n\nfunction tokenizeListItemPrefixWhitespace(effects, ok, nok) {\n  var self = this\n  return factorySpace(\n    effects,\n    afterPrefix,\n    'listItemPrefixWhitespace',\n    self.parser.constructs.disable.null.indexOf('codeIndented') > -1\n      ? undefined\n      : 4 + 1\n  )\n\n  function afterPrefix(code) {\n    return markdownSpace(code) ||\n      !prefixSize(self.events, 'listItemPrefixWhitespace')\n      ? nok(code)\n      : ok(code)\n  }\n}\n\nmodule.exports = list\n","'use strict'\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\nvar factorySpace = require('./factory-space.js')\n\nvar partialBlankLine = {\n  tokenize: tokenizePartialBlankLine,\n  partial: true\n}\n\nfunction tokenizePartialBlankLine(effects, ok, nok) {\n  return factorySpace(effects, afterWhitespace, 'linePrefix')\n\n  function afterWhitespace(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code)\n  }\n}\n\nmodule.exports = partialBlankLine\n","'use strict'\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\nvar shallow = require('../util/shallow.js')\nvar factorySpace = require('./factory-space.js')\n\nvar setextUnderline = {\n  name: 'setextUnderline',\n  tokenize: tokenizeSetextUnderline,\n  resolveTo: resolveToSetextUnderline\n}\n\nfunction resolveToSetextUnderline(events, context) {\n  var index = events.length\n  var content\n  var text\n  var definition\n  var heading // Find the opening of the content.\n  // It’ll always exist: we don’t tokenize if it isn’t there.\n\n  while (index--) {\n    if (events[index][0] === 'enter') {\n      if (events[index][1].type === 'content') {\n        content = index\n        break\n      }\n\n      if (events[index][1].type === 'paragraph') {\n        text = index\n      }\n    } // Exit\n    else {\n      if (events[index][1].type === 'content') {\n        // Remove the content end (if needed we’ll add it later)\n        events.splice(index, 1)\n      }\n\n      if (!definition && events[index][1].type === 'definition') {\n        definition = index\n      }\n    }\n  }\n\n  heading = {\n    type: 'setextHeading',\n    start: shallow(events[text][1].start),\n    end: shallow(events[events.length - 1][1].end)\n  } // Change the paragraph to setext heading text.\n\n  events[text][1].type = 'setextHeadingText' // If we have definitions in the content, we’ll keep on having content,\n  // but we need move it.\n\n  if (definition) {\n    events.splice(text, 0, ['enter', heading, context])\n    events.splice(definition + 1, 0, ['exit', events[content][1], context])\n    events[content][1].end = shallow(events[definition][1].end)\n  } else {\n    events[content][1] = heading\n  } // Add the heading exit at the end.\n\n  events.push(['exit', heading, context])\n  return events\n}\n\nfunction tokenizeSetextUnderline(effects, ok, nok) {\n  var self = this\n  var index = self.events.length\n  var marker\n  var paragraph // Find an opening.\n\n  while (index--) {\n    // Skip enter/exit of line ending, line prefix, and content.\n    // We can now either have a definition or a paragraph.\n    if (\n      self.events[index][1].type !== 'lineEnding' &&\n      self.events[index][1].type !== 'linePrefix' &&\n      self.events[index][1].type !== 'content'\n    ) {\n      paragraph = self.events[index][1].type === 'paragraph'\n      break\n    }\n  }\n\n  return start\n\n  function start(code) {\n    if (!self.lazy && (self.interrupt || paragraph)) {\n      effects.enter('setextHeadingLine')\n      effects.enter('setextHeadingLineSequence')\n      marker = code\n      return closingSequence(code)\n    }\n\n    return nok(code)\n  }\n\n  function closingSequence(code) {\n    if (code === marker) {\n      effects.consume(code)\n      return closingSequence\n    }\n\n    effects.exit('setextHeadingLineSequence')\n    return factorySpace(effects, closingSequenceEnd, 'lineSuffix')(code)\n  }\n\n  function closingSequenceEnd(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('setextHeadingLine')\n      return ok(code)\n    }\n\n    return nok(code)\n  }\n}\n\nmodule.exports = setextUnderline\n","'use strict'\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\nvar markdownSpace = require('../character/markdown-space.js')\nvar factorySpace = require('./factory-space.js')\n\nvar thematicBreak = {\n  name: 'thematicBreak',\n  tokenize: tokenizeThematicBreak\n}\n\nfunction tokenizeThematicBreak(effects, ok, nok) {\n  var size = 0\n  var marker\n  return start\n\n  function start(code) {\n    effects.enter('thematicBreak')\n    marker = code\n    return atBreak(code)\n  }\n\n  function atBreak(code) {\n    if (code === marker) {\n      effects.enter('thematicBreakSequence')\n      return sequence(code)\n    }\n\n    if (markdownSpace(code)) {\n      return factorySpace(effects, atBreak, 'whitespace')(code)\n    }\n\n    if (size < 3 || (code !== null && !markdownLineEnding(code))) {\n      return nok(code)\n    }\n\n    effects.exit('thematicBreak')\n    return ok(code)\n  }\n\n  function sequence(code) {\n    if (code === marker) {\n      effects.consume(code)\n      size++\n      return sequence\n    }\n\n    effects.exit('thematicBreakSequence')\n    return atBreak(code)\n  }\n}\n\nmodule.exports = thematicBreak\n","'use strict'\n\nvar chunkedSplice = require('./chunked-splice.js')\n\nfunction chunkedPush(list, items) {\n  if (list.length) {\n    chunkedSplice(list, list.length, 0, items)\n    return list\n  }\n\n  return items\n}\n\nmodule.exports = chunkedPush\n","'use strict'\n\nvar splice = require('../constant/splice.js')\n\n// causes a stack overflow in V8 when trying to insert 100k items for instance.\n\nfunction chunkedSplice(list, start, remove, items) {\n  var end = list.length\n  var chunkStart = 0\n  var parameters // Make start between zero and `end` (included).\n\n  if (start < 0) {\n    start = -start > end ? 0 : end + start\n  } else {\n    start = start > end ? end : start\n  }\n\n  remove = remove > 0 ? remove : 0 // No need to chunk the items if there’s only a couple (10k) items.\n\n  if (items.length < 10000) {\n    parameters = Array.from(items)\n    parameters.unshift(start, remove)\n    splice.apply(list, parameters)\n  } else {\n    // Delete `remove` items starting from `start`\n    if (remove) splice.apply(list, [start, remove]) // Insert the items in chunks to not cause stack overflows.\n\n    while (chunkStart < items.length) {\n      parameters = items.slice(chunkStart, chunkStart + 10000)\n      parameters.unshift(start, 0)\n      splice.apply(list, parameters)\n      chunkStart += 10000\n      start += 10000\n    }\n  }\n}\n\nmodule.exports = chunkedSplice\n","'use strict'\n\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js')\nvar unicodePunctuation = require('../character/unicode-punctuation.js')\nvar unicodeWhitespace = require('../character/unicode-whitespace.js')\n\n// Classify whether a character is unicode whitespace, unicode punctuation, or\n// anything else.\n// Used for attention (emphasis, strong), whose sequences can open or close\n// based on the class of surrounding characters.\nfunction classifyCharacter(code) {\n  if (\n    code === null ||\n    markdownLineEndingOrSpace(code) ||\n    unicodeWhitespace(code)\n  ) {\n    return 1\n  }\n\n  if (unicodePunctuation(code)) {\n    return 2\n  }\n}\n\nmodule.exports = classifyCharacter\n","'use strict'\n\nvar hasOwnProperty = require('../constant/has-own-property.js')\nvar chunkedSplice = require('./chunked-splice.js')\nvar miniflat = require('./miniflat.js')\n\nfunction combineExtensions(extensions) {\n  var all = {}\n  var index = -1\n\n  while (++index < extensions.length) {\n    extension(all, extensions[index])\n  }\n\n  return all\n}\n\nfunction extension(all, extension) {\n  var hook\n  var left\n  var right\n  var code\n\n  for (hook in extension) {\n    left = hasOwnProperty.call(all, hook) ? all[hook] : (all[hook] = {})\n    right = extension[hook]\n\n    for (code in right) {\n      left[code] = constructs(\n        miniflat(right[code]),\n        hasOwnProperty.call(left, code) ? left[code] : []\n      )\n    }\n  }\n}\n\nfunction constructs(list, existing) {\n  var index = -1\n  var before = []\n\n  while (++index < list.length) {\n    ;(list[index].add === 'after' ? existing : before).push(list[index])\n  }\n\n  chunkedSplice(existing, 0, 0, before)\n  return existing\n}\n\nmodule.exports = combineExtensions\n","'use strict'\n\nvar assign = require('../constant/assign.js')\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\nvar chunkedPush = require('./chunked-push.js')\nvar chunkedSplice = require('./chunked-splice.js')\nvar miniflat = require('./miniflat.js')\nvar resolveAll = require('./resolve-all.js')\nvar serializeChunks = require('./serialize-chunks.js')\nvar shallow = require('./shallow.js')\nvar sliceChunks = require('./slice-chunks.js')\n\n// Create a tokenizer.\n// Tokenizers deal with one type of data (e.g., containers, flow, text).\n// The parser is the object dealing with it all.\n// `initialize` works like other constructs, except that only its `tokenize`\n// function is used, in which case it doesn’t receive an `ok` or `nok`.\n// `from` can be given to set the point before the first character, although\n// when further lines are indented, they must be set with `defineSkip`.\nfunction createTokenizer(parser, initialize, from) {\n  var point = from\n    ? shallow(from)\n    : {\n        line: 1,\n        column: 1,\n        offset: 0\n      }\n  var columnStart = {}\n  var resolveAllConstructs = []\n  var chunks = []\n  var stack = []\n\n  var effects = {\n    consume: consume,\n    enter: enter,\n    exit: exit,\n    attempt: constructFactory(onsuccessfulconstruct),\n    check: constructFactory(onsuccessfulcheck),\n    interrupt: constructFactory(onsuccessfulcheck, {\n      interrupt: true\n    }),\n    lazy: constructFactory(onsuccessfulcheck, {\n      lazy: true\n    })\n  } // State and tools for resolving and serializing.\n\n  var context = {\n    previous: null,\n    events: [],\n    parser: parser,\n    sliceStream: sliceStream,\n    sliceSerialize: sliceSerialize,\n    now: now,\n    defineSkip: skip,\n    write: write\n  } // The state function.\n\n  var state = initialize.tokenize.call(context, effects) // Track which character we expect to be consumed, to catch bugs.\n\n  if (initialize.resolveAll) {\n    resolveAllConstructs.push(initialize)\n  } // Store where we are in the input stream.\n\n  point._index = 0\n  point._bufferIndex = -1\n  return context\n\n  function write(slice) {\n    chunks = chunkedPush(chunks, slice)\n    main() // Exit if we’re not done, resolve might change stuff.\n\n    if (chunks[chunks.length - 1] !== null) {\n      return []\n    }\n\n    addResult(initialize, 0) // Otherwise, resolve, and exit.\n\n    context.events = resolveAll(resolveAllConstructs, context.events, context)\n    return context.events\n  } //\n  // Tools.\n  //\n\n  function sliceSerialize(token) {\n    return serializeChunks(sliceStream(token))\n  }\n\n  function sliceStream(token) {\n    return sliceChunks(chunks, token)\n  }\n\n  function now() {\n    return shallow(point)\n  }\n\n  function skip(value) {\n    columnStart[value.line] = value.column\n    accountForPotentialSkip()\n  } //\n  // State management.\n  //\n  // Main loop (note that `_index` and `_bufferIndex` in `point` are modified by\n  // `consume`).\n  // Here is where we walk through the chunks, which either include strings of\n  // several characters, or numerical character codes.\n  // The reason to do this in a loop instead of a call is so the stack can\n  // drain.\n\n  function main() {\n    var chunkIndex\n    var chunk\n\n    while (point._index < chunks.length) {\n      chunk = chunks[point._index] // If we’re in a buffer chunk, loop through it.\n\n      if (typeof chunk === 'string') {\n        chunkIndex = point._index\n\n        if (point._bufferIndex < 0) {\n          point._bufferIndex = 0\n        }\n\n        while (\n          point._index === chunkIndex &&\n          point._bufferIndex < chunk.length\n        ) {\n          go(chunk.charCodeAt(point._bufferIndex))\n        }\n      } else {\n        go(chunk)\n      }\n    }\n  } // Deal with one code.\n\n  function go(code) {\n    state = state(code)\n  } // Move a character forward.\n\n  function consume(code) {\n    if (markdownLineEnding(code)) {\n      point.line++\n      point.column = 1\n      point.offset += code === -3 ? 2 : 1\n      accountForPotentialSkip()\n    } else if (code !== -1) {\n      point.column++\n      point.offset++\n    } // Not in a string chunk.\n\n    if (point._bufferIndex < 0) {\n      point._index++\n    } else {\n      point._bufferIndex++ // At end of string chunk.\n\n      if (point._bufferIndex === chunks[point._index].length) {\n        point._bufferIndex = -1\n        point._index++\n      }\n    } // Expose the previous character.\n\n    context.previous = code // Mark as consumed.\n  } // Start a token.\n\n  function enter(type, fields) {\n    var token = fields || {}\n    token.type = type\n    token.start = now()\n    context.events.push(['enter', token, context])\n    stack.push(token)\n    return token\n  } // Stop a token.\n\n  function exit(type) {\n    var token = stack.pop()\n    token.end = now()\n    context.events.push(['exit', token, context])\n    return token\n  } // Use results.\n\n  function onsuccessfulconstruct(construct, info) {\n    addResult(construct, info.from)\n  } // Discard results.\n\n  function onsuccessfulcheck(construct, info) {\n    info.restore()\n  } // Factory to attempt/check/interrupt.\n\n  function constructFactory(onreturn, fields) {\n    return hook // Handle either an object mapping codes to constructs, a list of\n    // constructs, or a single construct.\n\n    function hook(constructs, returnState, bogusState) {\n      var listOfConstructs\n      var constructIndex\n      var currentConstruct\n      var info\n      return constructs.tokenize || 'length' in constructs\n        ? handleListOfConstructs(miniflat(constructs))\n        : handleMapOfConstructs\n\n      function handleMapOfConstructs(code) {\n        if (code in constructs || null in constructs) {\n          return handleListOfConstructs(\n            constructs.null\n              ? /* c8 ignore next */\n                miniflat(constructs[code]).concat(miniflat(constructs.null))\n              : constructs[code]\n          )(code)\n        }\n\n        return bogusState(code)\n      }\n\n      function handleListOfConstructs(list) {\n        listOfConstructs = list\n        constructIndex = 0\n        return handleConstruct(list[constructIndex])\n      }\n\n      function handleConstruct(construct) {\n        return start\n\n        function start(code) {\n          // To do: not nede to store if there is no bogus state, probably?\n          // Currently doesn’t work because `inspect` in document does a check\n          // w/o a bogus, which doesn’t make sense. But it does seem to help perf\n          // by not storing.\n          info = store()\n          currentConstruct = construct\n\n          if (!construct.partial) {\n            context.currentConstruct = construct\n          }\n\n          if (\n            construct.name &&\n            context.parser.constructs.disable.null.indexOf(construct.name) > -1\n          ) {\n            return nok()\n          }\n\n          return construct.tokenize.call(\n            fields ? assign({}, context, fields) : context,\n            effects,\n            ok,\n            nok\n          )(code)\n        }\n      }\n\n      function ok(code) {\n        onreturn(currentConstruct, info)\n        return returnState\n      }\n\n      function nok(code) {\n        info.restore()\n\n        if (++constructIndex < listOfConstructs.length) {\n          return handleConstruct(listOfConstructs[constructIndex])\n        }\n\n        return bogusState\n      }\n    }\n  }\n\n  function addResult(construct, from) {\n    if (construct.resolveAll && resolveAllConstructs.indexOf(construct) < 0) {\n      resolveAllConstructs.push(construct)\n    }\n\n    if (construct.resolve) {\n      chunkedSplice(\n        context.events,\n        from,\n        context.events.length - from,\n        construct.resolve(context.events.slice(from), context)\n      )\n    }\n\n    if (construct.resolveTo) {\n      context.events = construct.resolveTo(context.events, context)\n    }\n  }\n\n  function store() {\n    var startPoint = now()\n    var startPrevious = context.previous\n    var startCurrentConstruct = context.currentConstruct\n    var startEventsIndex = context.events.length\n    var startStack = Array.from(stack)\n    return {\n      restore: restore,\n      from: startEventsIndex\n    }\n\n    function restore() {\n      point = startPoint\n      context.previous = startPrevious\n      context.currentConstruct = startCurrentConstruct\n      context.events.length = startEventsIndex\n      stack = startStack\n      accountForPotentialSkip()\n    }\n  }\n\n  function accountForPotentialSkip() {\n    if (point.line in columnStart && point.column < 2) {\n      point.column = columnStart[point.line]\n      point.offset += columnStart[point.line] - 1\n    }\n  }\n}\n\nmodule.exports = createTokenizer\n","'use strict'\n\nfunction miniflat(value) {\n  return value === null || value === undefined\n    ? []\n    : 'length' in value\n    ? value\n    : [value]\n}\n\nmodule.exports = miniflat\n","'use strict'\n\n// chunks (replacement characters, tabs, or line endings).\n\nfunction movePoint(point, offset) {\n  point.column += offset\n  point.offset += offset\n  point._bufferIndex += offset\n  return point\n}\n\nmodule.exports = movePoint\n","'use strict'\n\nfunction normalizeIdentifier(value) {\n  return (\n    value // Collapse Markdown whitespace.\n      .replace(/[\\t\\n\\r ]+/g, ' ') // Trim.\n      .replace(/^ | $/g, '') // Some characters are considered “uppercase”, but if their lowercase\n      // counterpart is uppercased will result in a different uppercase\n      // character.\n      // Hence, to get that form, we perform both lower- and uppercase.\n      // Upper case makes sure keys will not interact with default prototypal\n      // methods: no object method is uppercase.\n      .toLowerCase()\n      .toUpperCase()\n  )\n}\n\nmodule.exports = normalizeIdentifier\n","'use strict'\n\nvar sizeChunks = require('./size-chunks.js')\n\nfunction prefixSize(events, type) {\n  var tail = events[events.length - 1]\n  if (!tail || tail[1].type !== type) return 0\n  return sizeChunks(tail[2].sliceStream(tail[1]))\n}\n\nmodule.exports = prefixSize\n","'use strict'\n\nvar fromCharCode = require('../constant/from-char-code.js')\n\nfunction regexCheck(regex) {\n  return check\n\n  function check(code) {\n    return regex.test(fromCharCode(code))\n  }\n}\n\nmodule.exports = regexCheck\n","'use strict'\n\nfunction resolveAll(constructs, events, context) {\n  var called = []\n  var index = -1\n  var resolve\n\n  while (++index < constructs.length) {\n    resolve = constructs[index].resolveAll\n\n    if (resolve && called.indexOf(resolve) < 0) {\n      events = resolve(events, context)\n      called.push(resolve)\n    }\n  }\n\n  return events\n}\n\nmodule.exports = resolveAll\n","'use strict'\n\nvar fromCharCode = require('../constant/from-char-code.js')\n\nfunction safeFromInt(value, base) {\n  var code = parseInt(value, base)\n\n  if (\n    // C0 except for HT, LF, FF, CR, space\n    code < 9 ||\n    code === 11 ||\n    (code > 13 && code < 32) || // Control character (DEL) of the basic block and C1 controls.\n    (code > 126 && code < 160) || // Lone high surrogates and low surrogates.\n    (code > 55295 && code < 57344) || // Noncharacters.\n    (code > 64975 && code < 65008) ||\n    (code & 65535) === 65535 ||\n    (code & 65535) === 65534 || // Out of range\n    code > 1114111\n  ) {\n    return '\\uFFFD'\n  }\n\n  return fromCharCode(code)\n}\n\nmodule.exports = safeFromInt\n","'use strict'\n\nvar fromCharCode = require('../constant/from-char-code.js')\n\nfunction serializeChunks(chunks) {\n  var index = -1\n  var result = []\n  var chunk\n  var value\n  var atTab\n\n  while (++index < chunks.length) {\n    chunk = chunks[index]\n\n    if (typeof chunk === 'string') {\n      value = chunk\n    } else if (chunk === -5) {\n      value = '\\r'\n    } else if (chunk === -4) {\n      value = '\\n'\n    } else if (chunk === -3) {\n      value = '\\r' + '\\n'\n    } else if (chunk === -2) {\n      value = '\\t'\n    } else if (chunk === -1) {\n      if (atTab) continue\n      value = ' '\n    } else {\n      // Currently only replacement character.\n      value = fromCharCode(chunk)\n    }\n\n    atTab = chunk === -2\n    result.push(value)\n  }\n\n  return result.join('')\n}\n\nmodule.exports = serializeChunks\n","'use strict'\n\nvar assign = require('../constant/assign.js')\n\nfunction shallow(object) {\n  return assign({}, object)\n}\n\nmodule.exports = shallow\n","'use strict'\n\n// Counts tabs based on their expanded size, and CR+LF as one character.\n\nfunction sizeChunks(chunks) {\n  var index = -1\n  var size = 0\n\n  while (++index < chunks.length) {\n    size += typeof chunks[index] === 'string' ? chunks[index].length : 1\n  }\n\n  return size\n}\n\nmodule.exports = sizeChunks\n","'use strict'\n\nfunction sliceChunks(chunks, token) {\n  var startIndex = token.start._index\n  var startBufferIndex = token.start._bufferIndex\n  var endIndex = token.end._index\n  var endBufferIndex = token.end._bufferIndex\n  var view\n\n  if (startIndex === endIndex) {\n    view = [chunks[startIndex].slice(startBufferIndex, endBufferIndex)]\n  } else {\n    view = chunks.slice(startIndex, endIndex)\n\n    if (startBufferIndex > -1) {\n      view[0] = view[0].slice(startBufferIndex)\n    }\n\n    if (endBufferIndex > 0) {\n      view.push(chunks[endIndex].slice(0, endBufferIndex))\n    }\n  }\n\n  return view\n}\n\nmodule.exports = sliceChunks\n","'use strict'\n\nvar assign = require('../constant/assign.js')\nvar chunkedSplice = require('./chunked-splice.js')\nvar shallow = require('./shallow.js')\n\nfunction subtokenize(events) {\n  var jumps = {}\n  var index = -1\n  var event\n  var lineIndex\n  var otherIndex\n  var otherEvent\n  var parameters\n  var subevents\n  var more\n\n  while (++index < events.length) {\n    while (index in jumps) {\n      index = jumps[index]\n    }\n\n    event = events[index] // Add a hook for the GFM tasklist extension, which needs to know if text\n    // is in the first content of a list item.\n\n    if (\n      index &&\n      event[1].type === 'chunkFlow' &&\n      events[index - 1][1].type === 'listItemPrefix'\n    ) {\n      subevents = event[1]._tokenizer.events\n      otherIndex = 0\n\n      if (\n        otherIndex < subevents.length &&\n        subevents[otherIndex][1].type === 'lineEndingBlank'\n      ) {\n        otherIndex += 2\n      }\n\n      if (\n        otherIndex < subevents.length &&\n        subevents[otherIndex][1].type === 'content'\n      ) {\n        while (++otherIndex < subevents.length) {\n          if (subevents[otherIndex][1].type === 'content') {\n            break\n          }\n\n          if (subevents[otherIndex][1].type === 'chunkText') {\n            subevents[otherIndex][1].isInFirstContentOfListItem = true\n            otherIndex++\n          }\n        }\n      }\n    } // Enter.\n\n    if (event[0] === 'enter') {\n      if (event[1].contentType) {\n        assign(jumps, subcontent(events, index))\n        index = jumps[index]\n        more = true\n      }\n    } // Exit.\n    else if (event[1]._container || event[1]._movePreviousLineEndings) {\n      otherIndex = index\n      lineIndex = undefined\n\n      while (otherIndex--) {\n        otherEvent = events[otherIndex]\n\n        if (\n          otherEvent[1].type === 'lineEnding' ||\n          otherEvent[1].type === 'lineEndingBlank'\n        ) {\n          if (otherEvent[0] === 'enter') {\n            if (lineIndex) {\n              events[lineIndex][1].type = 'lineEndingBlank'\n            }\n\n            otherEvent[1].type = 'lineEnding'\n            lineIndex = otherIndex\n          }\n        } else {\n          break\n        }\n      }\n\n      if (lineIndex) {\n        // Fix position.\n        event[1].end = shallow(events[lineIndex][1].start) // Switch container exit w/ line endings.\n\n        parameters = events.slice(lineIndex, index)\n        parameters.unshift(event)\n        chunkedSplice(events, lineIndex, index - lineIndex + 1, parameters)\n      }\n    }\n  }\n\n  return !more\n}\n\nfunction subcontent(events, eventIndex) {\n  var token = events[eventIndex][1]\n  var context = events[eventIndex][2]\n  var startPosition = eventIndex - 1\n  var startPositions = []\n  var tokenizer =\n    token._tokenizer || context.parser[token.contentType](token.start)\n  var childEvents = tokenizer.events\n  var jumps = []\n  var gaps = {}\n  var stream\n  var previous\n  var index\n  var entered\n  var end\n  var adjust // Loop forward through the linked tokens to pass them in order to the\n  // subtokenizer.\n\n  while (token) {\n    // Find the position of the event for this token.\n    while (events[++startPosition][1] !== token) {\n      // Empty.\n    }\n\n    startPositions.push(startPosition)\n\n    if (!token._tokenizer) {\n      stream = context.sliceStream(token)\n\n      if (!token.next) {\n        stream.push(null)\n      }\n\n      if (previous) {\n        tokenizer.defineSkip(token.start)\n      }\n\n      if (token.isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = true\n      }\n\n      tokenizer.write(stream)\n\n      if (token.isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = undefined\n      }\n    } // Unravel the next token.\n\n    previous = token\n    token = token.next\n  } // Now, loop back through all events (and linked tokens), to figure out which\n  // parts belong where.\n\n  token = previous\n  index = childEvents.length\n\n  while (index--) {\n    // Make sure we’ve at least seen something (final eol is part of the last\n    // token).\n    if (childEvents[index][0] === 'enter') {\n      entered = true\n    } else if (\n      // Find a void token that includes a break.\n      entered &&\n      childEvents[index][1].type === childEvents[index - 1][1].type &&\n      childEvents[index][1].start.line !== childEvents[index][1].end.line\n    ) {\n      add(childEvents.slice(index + 1, end))\n      // Help GC.\n      token._tokenizer = token.next = undefined\n      token = token.previous\n      end = index + 1\n    }\n  }\n\n  // Help GC.\n  tokenizer.events = token._tokenizer = token.next = undefined // Do head:\n\n  add(childEvents.slice(0, end))\n  index = -1\n  adjust = 0\n\n  while (++index < jumps.length) {\n    gaps[adjust + jumps[index][0]] = adjust + jumps[index][1]\n    adjust += jumps[index][1] - jumps[index][0] - 1\n  }\n\n  return gaps\n\n  function add(slice) {\n    var start = startPositions.pop()\n    jumps.unshift([start, start + slice.length - 1])\n    chunkedSplice(events, start, 2, slice)\n  }\n}\n\nmodule.exports = subtokenize\n"],"names":["asciiAlpha","require","regexCheck","module","exports","asciiAlphanumeric","asciiAtext","code","asciiDigit","asciiHexDigit","asciiPunctuation","unicodePunctuationRegex","unicodePunctuation","unicodeWhitespace","assign","Object","fromCharCode","String","own","hasOwnProperty","splice","defineProperty","value","text$1","attention","autolink","blockQuote","characterEscape","characterReference","codeFenced","codeIndented","codeText","definition","hardBreakEscape","headingAtx","htmlFlow","htmlText","labelEnd","labelStartImage","labelStartLink","lineEnding","list","setextUnderline","thematicBreak","document","contentInitial","flowInitial","flow","string","text","insideSpan","null","resolver","disable","markdownLineEnding","factorySpace","tokenize","effects","previous","contentStart","attempt","this","parser","constructs","consume","enter","exit","lineStart","token","contentType","next","data","partialBlankLine","inspectResult","childFlow","childToken","self","stack","continued","inspectConstruct","ok","subcontinued","inspectStart","length","containerState","continuation","inspectContinue","inspectLess","currentConstruct","concrete","flowContinue","inspectDone","interrupt","interruptible","containerConstruct","inspectFlowEnd","_closeFlow","lazy","lazyFlowConstruct","check","inspectLazy","flowEnd","undefined","partial","start","documentContinue","documentContinued","flowStart","containerContinue","push","exitContainers","now","_tokenizer","continueFlow","documentAfterPeek","defineSkip","write","sliceStream","size","end","index","call","nok","indexOf","content","initial","afterConstruct","shallow","initializeFactory","resolveAll","createResolver","field","notText","atBreak","resolveAllLineSuffixes","extraResolver","events","context","type","chunks","chunk","bufferIndex","tabs","eventIndex","charCodeAt","line","column","offset","_index","_bufferIndex","combineExtensions","createTokenizer","miniflat","options","defined","concat","extensions","create","initializer","from","subtokenize","search","atCarriageReturn","buffer","encoding","match","startPosition","endPosition","toString","lastIndex","exec","slice","Math","ceil","chunkedPush","chunkedSplice","classifyCharacter","movePoint","name","marker","before","sequence","after","open","close","_open","_close","group","openingSequence","closingSequence","use","nextEvents","sliceSerialize","asciiControl","schemeOrEmailAtext","emailAtext","schemeInsideOrEmailAtext","urlInside","emailAtSignOrDot","emailLabel","emailValue","markdownSpace","_container","decodeEntity","_interopDefaultLegacy","e","default","decodeEntity__default","max","test","numeric","markdownLineEndingOrSpace","prefixSize","closingFenceConstruct","closingSequenceStart","sizeOpen","closingSequenceEnd","initialPrefix","sequenceOpen","infoOpen","openAfter","info","infoAfter","meta","contentContinue","indentedContentConstruct","afterPrefix","resolve","gap","tailExitIndex","headEnterIndex","contentEnd","continuationConstruct","prefixed","normalizeIdentifier","factoryDestination","factoryLabel","factoryWhitespace","factoryTitle","identifier","labelAfter","titleConstruct","literalType","literalMarkerType","rawType","stringType","limit","Infinity","balance","destinationEnclosedBefore","destinationRaw","destinationEnclosed","destinationEnclosedEscape","destinationRawEscape","markerType","label","labelEscape","prefix","atFirstTitleBreak","atTitleBreak","title","titleEscape","seen","fenceOpenInside","headingBreak","htmlBlockNames","htmlRawNames","kind","startTag","declarationStart","tagCloseStart","continuationDeclarationInside","tagName","commentOpenInside","cdataOpenInside","toLowerCase","basicSelfClosing","completeAttributeNameBefore","completeClosingTagAfter","completeEnd","completeAttributeName","completeAttributeNameAfter","completeAttributeValueBefore","completeAttributeValueQuoted","completeAttributeValueUnquoted","completeAttributeValueQuotedAfter","completeAfter","continuationCommentInside","continuationRawTagOpen","continuationClose","continuationCharacterDataInside","continuationAtLineEnding","nextBlankConstruct","htmlContinueStart","done","continuationRawEndTag","resolveTo","returnState","declarationOpen","instruction","tagOpen","commentOpen","cdataOpen","declaration","commentStart","commentStartDash","comment","commentClose","atLineEnding","cdata","cdataClose","cdataEnd","instructionClose","tagClose","tagCloseBetween","tagOpenBetween","tagOpenAttributeName","tagOpenAttributeNameAfter","tagOpenAttributeValueBefore","tagOpenAttributeValueQuoted","tagOpenAttributeValueUnquoted","tagOpenAttributeValueQuotedAfter","labelStart","_balanced","_inactive","balanced","afterLabelEnd","resourceConstruct","fullReferenceConstruct","collapsedReferenceConstruct","media","_used","destinationAfter","between","afterLabel","sizeChunks","initialSize","atMarker","inside","onBlank","listItemPrefixWhitespaceConstruct","endOfPrefix","otherPrefix","initialBlankLine","furtherBlankLines","notInCurrentItem","indentConstruct","paragraph","heading","items","remove","parameters","chunkStart","Array","unshift","apply","extension","all","hook","left","right","existing","add","serializeChunks","sliceChunks","initialize","point","columnStart","resolveAllConstructs","accountForPotentialSkip","fields","pop","constructFactory","construct","addResult","onsuccessfulcheck","main","state","chunkIndex","go","restore","onreturn","bogusState","listOfConstructs","constructIndex","handleListOfConstructs","handleConstruct","startPoint","startPrevious","startCurrentConstruct","startEventsIndex","startStack","store","replace","toUpperCase","tail","regex","called","base","parseInt","atTab","result","join","object","view","startIndex","startBufferIndex","endIndex","endBufferIndex","subcontent","stream","entered","adjust","startPositions","tokenizer","childEvents","jumps","gaps","isInFirstContentOfListItem","_gfmTasklistFirstContentOfListItem","event","lineIndex","otherIndex","otherEvent","subevents","more","_movePreviousLineEndings"],"sourceRoot":""}