{"version":3,"file":"static/js/2068.950d4ed7.chunk.js","mappings":"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","sources":["../node_modules/bail/index.js","../node_modules/extend/index.js","../node_modules/is-buffer/index.js","../node_modules/mdast-add-list-metadata/index.js","../node_modules/mdast-util-from-markdown/dist/index.js","../node_modules/mdast-util-from-markdown/index.js","../node_modules/mdast-util-to-string/index.js","../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","../node_modules/parse-entities/decode-entity.browser.js","../node_modules/react-markdown/lib/ast-to-react.js","../node_modules/react-markdown/lib/get-definitions.js","../node_modules/react-markdown/lib/plugins/disallow-node.js","../node_modules/react-markdown/lib/plugins/naive-html.js","../node_modules/react-markdown/lib/react-markdown.js","../node_modules/react-markdown/lib/renderers.js","../node_modules/react-markdown/lib/symbols.js","../node_modules/react-markdown/lib/uri-transformer.js","../node_modules/react-markdown/lib/wrap-table-rows.js","../node_modules/react-markdown/node_modules/react-is/cjs/react-is.production.min.js","../node_modules/react-markdown/node_modules/react-is/index.js","../node_modules/remark-parse/index.js","../node_modules/trough/index.js","../node_modules/trough/wrap.js","../node_modules/unified/index.js","../node_modules/unified/node_modules/is-plain-obj/index.js","../node_modules/unist-util-is/convert.js","../node_modules/unist-util-stringify-position/index.js","../node_modules/unist-util-visit-parents/index.js","../node_modules/unist-util-visit/index.js","../node_modules/unist-util-visit/node_modules/unist-util-visit-parents/color.browser.js","../node_modules/unist-util-visit/node_modules/unist-util-visit-parents/index.js","../node_modules/vfile-message/index.js","../node_modules/vfile/index.js","../node_modules/vfile/lib/core.js","../node_modules/vfile/lib/index.js","../node_modules/vfile/lib/minpath.browser.js","../node_modules/vfile/lib/minproc.browser.js","../node_modules/xtend/immutable.js"],"sourcesContent":["'use strict'\n\nmodule.exports = bail\n\nfunction bail(err) {\n  if (err) {\n    throw err\n  }\n}\n","'use strict';\n\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar toStr = Object.prototype.toString;\nvar defineProperty = Object.defineProperty;\nvar gOPD = Object.getOwnPropertyDescriptor;\n\nvar isArray = function isArray(arr) {\n\tif (typeof Array.isArray === 'function') {\n\t\treturn Array.isArray(arr);\n\t}\n\n\treturn toStr.call(arr) === '[object Array]';\n};\n\nvar isPlainObject = function isPlainObject(obj) {\n\tif (!obj || toStr.call(obj) !== '[object Object]') {\n\t\treturn false;\n\t}\n\n\tvar hasOwnConstructor = hasOwn.call(obj, 'constructor');\n\tvar hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf');\n\t// Not own constructor property must be Object\n\tif (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {\n\t\treturn false;\n\t}\n\n\t// Own properties are enumerated firstly, so to speed up,\n\t// if last one is own, then all properties are own.\n\tvar key;\n\tfor (key in obj) { /**/ }\n\n\treturn typeof key === 'undefined' || hasOwn.call(obj, key);\n};\n\n// If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target\nvar setProperty = function setProperty(target, options) {\n\tif (defineProperty && options.name === '__proto__') {\n\t\tdefineProperty(target, options.name, {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: true,\n\t\t\tvalue: options.newValue,\n\t\t\twritable: true\n\t\t});\n\t} else {\n\t\ttarget[options.name] = options.newValue;\n\t}\n};\n\n// Return undefined instead of __proto__ if '__proto__' is not an own property\nvar getProperty = function getProperty(obj, name) {\n\tif (name === '__proto__') {\n\t\tif (!hasOwn.call(obj, name)) {\n\t\t\treturn void 0;\n\t\t} else if (gOPD) {\n\t\t\t// In early versions of node, obj['__proto__'] is buggy when obj has\n\t\t\t// __proto__ as an own property. Object.getOwnPropertyDescriptor() works.\n\t\t\treturn gOPD(obj, name).value;\n\t\t}\n\t}\n\n\treturn obj[name];\n};\n\nmodule.exports = function extend() {\n\tvar options, name, src, copy, copyIsArray, clone;\n\tvar target = arguments[0];\n\tvar i = 1;\n\tvar length = arguments.length;\n\tvar deep = false;\n\n\t// Handle a deep copy situation\n\tif (typeof target === 'boolean') {\n\t\tdeep = target;\n\t\ttarget = arguments[1] || {};\n\t\t// skip the boolean and the target\n\t\ti = 2;\n\t}\n\tif (target == null || (typeof target !== 'object' && typeof target !== 'function')) {\n\t\ttarget = {};\n\t}\n\n\tfor (; i < length; ++i) {\n\t\toptions = arguments[i];\n\t\t// Only deal with non-null/undefined values\n\t\tif (options != null) {\n\t\t\t// Extend the base object\n\t\t\tfor (name in options) {\n\t\t\t\tsrc = getProperty(target, name);\n\t\t\t\tcopy = getProperty(options, name);\n\n\t\t\t\t// Prevent never-ending loop\n\t\t\t\tif (target !== copy) {\n\t\t\t\t\t// Recurse if we're merging plain objects or arrays\n\t\t\t\t\tif (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {\n\t\t\t\t\t\tif (copyIsArray) {\n\t\t\t\t\t\t\tcopyIsArray = false;\n\t\t\t\t\t\t\tclone = src && isArray(src) ? src : [];\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tclone = src && isPlainObject(src) ? src : {};\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Never move original objects, clone them\n\t\t\t\t\t\tsetProperty(target, { name: name, newValue: extend(deep, clone, copy) });\n\n\t\t\t\t\t// Don't bring in undefined values\n\t\t\t\t\t} else if (typeof copy !== 'undefined') {\n\t\t\t\t\t\tsetProperty(target, { name: name, newValue: copy });\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Return the modified object\n\treturn target;\n};\n","/*!\n * Determine if an object is a Buffer\n *\n * @author   Feross Aboukhadijeh <https://feross.org>\n * @license  MIT\n */\n\nmodule.exports = function isBuffer (obj) {\n  return obj != null && obj.constructor != null &&\n    typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)\n}\n","var visitWithParents = require('unist-util-visit-parents');\n\nfunction addListMetadata() {\n  return function (ast) {\n    visitWithParents(ast, 'list', function (listNode, parents) {\n      var depth = 0, i, n;\n      for (i = 0, n = parents.length; i < n; i++) {\n        if (parents[i].type === 'list') depth += 1;\n      }\n      for (i = 0, n = listNode.children.length; i < n; i++) {\n        var child = listNode.children[i];\n        child.index = i;\n        child.ordered = listNode.ordered;\n      }\n      listNode.depth = depth;\n    });\n    return ast;\n  };\n}\n\nmodule.exports = addListMetadata;\n","'use strict'\n\nmodule.exports = fromMarkdown\n\n// These three are compiled away in the `dist/`\n\nvar toString = require('mdast-util-to-string')\nvar assign = require('micromark/dist/constant/assign')\nvar own = require('micromark/dist/constant/has-own-property')\nvar normalizeIdentifier = require('micromark/dist/util/normalize-identifier')\nvar safeFromInt = require('micromark/dist/util/safe-from-int')\nvar parser = require('micromark/dist/parse')\nvar preprocessor = require('micromark/dist/preprocess')\nvar postprocess = require('micromark/dist/postprocess')\nvar decode = require('parse-entities/decode-entity')\nvar stringifyPosition = require('unist-util-stringify-position')\n\nfunction fromMarkdown(value, encoding, options) {\n  if (typeof encoding !== 'string') {\n    options = encoding\n    encoding = undefined\n  }\n\n  return compiler(options)(\n    postprocess(\n      parser(options).document().write(preprocessor()(value, encoding, true))\n    )\n  )\n}\n\n// Note this compiler only understand complete buffering, not streaming.\nfunction compiler(options) {\n  var settings = options || {}\n  var config = configure(\n    {\n      transforms: [],\n      canContainEols: [\n        'emphasis',\n        'fragment',\n        'heading',\n        'paragraph',\n        'strong'\n      ],\n\n      enter: {\n        autolink: opener(link),\n        autolinkProtocol: onenterdata,\n        autolinkEmail: onenterdata,\n        atxHeading: opener(heading),\n        blockQuote: opener(blockQuote),\n        characterEscape: onenterdata,\n        characterReference: onenterdata,\n        codeFenced: opener(codeFlow),\n        codeFencedFenceInfo: buffer,\n        codeFencedFenceMeta: buffer,\n        codeIndented: opener(codeFlow, buffer),\n        codeText: opener(codeText, buffer),\n        codeTextData: onenterdata,\n        data: onenterdata,\n        codeFlowValue: onenterdata,\n        definition: opener(definition),\n        definitionDestinationString: buffer,\n        definitionLabelString: buffer,\n        definitionTitleString: buffer,\n        emphasis: opener(emphasis),\n        hardBreakEscape: opener(hardBreak),\n        hardBreakTrailing: opener(hardBreak),\n        htmlFlow: opener(html, buffer),\n        htmlFlowData: onenterdata,\n        htmlText: opener(html, buffer),\n        htmlTextData: onenterdata,\n        image: opener(image),\n        label: buffer,\n        link: opener(link),\n        listItem: opener(listItem),\n        listItemValue: onenterlistitemvalue,\n        listOrdered: opener(list, onenterlistordered),\n        listUnordered: opener(list),\n        paragraph: opener(paragraph),\n        reference: onenterreference,\n        referenceString: buffer,\n        resourceDestinationString: buffer,\n        resourceTitleString: buffer,\n        setextHeading: opener(heading),\n        strong: opener(strong),\n        thematicBreak: opener(thematicBreak)\n      },\n\n      exit: {\n        atxHeading: closer(),\n        atxHeadingSequence: onexitatxheadingsequence,\n        autolink: closer(),\n        autolinkEmail: onexitautolinkemail,\n        autolinkProtocol: onexitautolinkprotocol,\n        blockQuote: closer(),\n        characterEscapeValue: onexitdata,\n        characterReferenceMarkerHexadecimal: onexitcharacterreferencemarker,\n        characterReferenceMarkerNumeric: onexitcharacterreferencemarker,\n        characterReferenceValue: onexitcharacterreferencevalue,\n        codeFenced: closer(onexitcodefenced),\n        codeFencedFence: onexitcodefencedfence,\n        codeFencedFenceInfo: onexitcodefencedfenceinfo,\n        codeFencedFenceMeta: onexitcodefencedfencemeta,\n        codeFlowValue: onexitdata,\n        codeIndented: closer(onexitcodeindented),\n        codeText: closer(onexitcodetext),\n        codeTextData: onexitdata,\n        data: onexitdata,\n        definition: closer(),\n        definitionDestinationString: onexitdefinitiondestinationstring,\n        definitionLabelString: onexitdefinitionlabelstring,\n        definitionTitleString: onexitdefinitiontitlestring,\n        emphasis: closer(),\n        hardBreakEscape: closer(onexithardbreak),\n        hardBreakTrailing: closer(onexithardbreak),\n        htmlFlow: closer(onexithtmlflow),\n        htmlFlowData: onexitdata,\n        htmlText: closer(onexithtmltext),\n        htmlTextData: onexitdata,\n        image: closer(onexitimage),\n        label: onexitlabel,\n        labelText: onexitlabeltext,\n        lineEnding: onexitlineending,\n        link: closer(onexitlink),\n        listItem: closer(),\n        listOrdered: closer(),\n        listUnordered: closer(),\n        paragraph: closer(),\n        referenceString: onexitreferencestring,\n        resourceDestinationString: onexitresourcedestinationstring,\n        resourceTitleString: onexitresourcetitlestring,\n        resource: onexitresource,\n        setextHeading: closer(onexitsetextheading),\n        setextHeadingLineSequence: onexitsetextheadinglinesequence,\n        setextHeadingText: onexitsetextheadingtext,\n        strong: closer(),\n        thematicBreak: closer()\n      }\n    },\n\n    settings.mdastExtensions || []\n  )\n\n  var data = {}\n\n  return compile\n\n  function compile(events) {\n    var tree = {type: 'root', children: []}\n    var stack = [tree]\n    var tokenStack = []\n    var listStack = []\n    var index = -1\n    var handler\n    var listStart\n\n    var context = {\n      stack: stack,\n      tokenStack: tokenStack,\n      config: config,\n      enter: enter,\n      exit: exit,\n      buffer: buffer,\n      resume: resume,\n      setData: setData,\n      getData: getData\n    }\n\n    while (++index < events.length) {\n      // We preprocess lists to add `listItem` tokens, and to infer whether\n      // items the list itself are spread out.\n      if (\n        events[index][1].type === 'listOrdered' ||\n        events[index][1].type === 'listUnordered'\n      ) {\n        if (events[index][0] === 'enter') {\n          listStack.push(index)\n        } else {\n          listStart = listStack.pop(index)\n          index = prepareList(events, listStart, index)\n        }\n      }\n    }\n\n    index = -1\n\n    while (++index < events.length) {\n      handler = config[events[index][0]]\n\n      if (own.call(handler, events[index][1].type)) {\n        handler[events[index][1].type].call(\n          assign({sliceSerialize: events[index][2].sliceSerialize}, context),\n          events[index][1]\n        )\n      }\n    }\n\n    if (tokenStack.length) {\n      throw new Error(\n        'Cannot close document, a token (`' +\n          tokenStack[tokenStack.length - 1].type +\n          '`, ' +\n          stringifyPosition({\n            start: tokenStack[tokenStack.length - 1].start,\n            end: tokenStack[tokenStack.length - 1].end\n          }) +\n          ') is still open'\n      )\n    }\n\n    // Figure out `root` position.\n    tree.position = {\n      start: point(\n        events.length ? events[0][1].start : {line: 1, column: 1, offset: 0}\n      ),\n\n      end: point(\n        events.length\n          ? events[events.length - 2][1].end\n          : {line: 1, column: 1, offset: 0}\n      )\n    }\n\n    index = -1\n    while (++index < config.transforms.length) {\n      tree = config.transforms[index](tree) || tree\n    }\n\n    return tree\n  }\n\n  function prepareList(events, start, length) {\n    var index = start - 1\n    var containerBalance = -1\n    var listSpread = false\n    var listItem\n    var tailIndex\n    var lineIndex\n    var tailEvent\n    var event\n    var firstBlankLineIndex\n    var atMarker\n\n    while (++index <= length) {\n      event = events[index]\n\n      if (\n        event[1].type === 'listUnordered' ||\n        event[1].type === 'listOrdered' ||\n        event[1].type === 'blockQuote'\n      ) {\n        if (event[0] === 'enter') {\n          containerBalance++\n        } else {\n          containerBalance--\n        }\n\n        atMarker = undefined\n      } else if (event[1].type === 'lineEndingBlank') {\n        if (event[0] === 'enter') {\n          if (\n            listItem &&\n            !atMarker &&\n            !containerBalance &&\n            !firstBlankLineIndex\n          ) {\n            firstBlankLineIndex = index\n          }\n\n          atMarker = undefined\n        }\n      } else if (\n        event[1].type === 'linePrefix' ||\n        event[1].type === 'listItemValue' ||\n        event[1].type === 'listItemMarker' ||\n        event[1].type === 'listItemPrefix' ||\n        event[1].type === 'listItemPrefixWhitespace'\n      ) {\n        // Empty.\n      } else {\n        atMarker = undefined\n      }\n\n      if (\n        (!containerBalance &&\n          event[0] === 'enter' &&\n          event[1].type === 'listItemPrefix') ||\n        (containerBalance === -1 &&\n          event[0] === 'exit' &&\n          (event[1].type === 'listUnordered' ||\n            event[1].type === 'listOrdered'))\n      ) {\n        if (listItem) {\n          tailIndex = index\n          lineIndex = undefined\n\n          while (tailIndex--) {\n            tailEvent = events[tailIndex]\n\n            if (\n              tailEvent[1].type === 'lineEnding' ||\n              tailEvent[1].type === 'lineEndingBlank'\n            ) {\n              if (tailEvent[0] === 'exit') continue\n\n              if (lineIndex) {\n                events[lineIndex][1].type = 'lineEndingBlank'\n                listSpread = true\n              }\n\n              tailEvent[1].type = 'lineEnding'\n              lineIndex = tailIndex\n            } else if (\n              tailEvent[1].type === 'linePrefix' ||\n              tailEvent[1].type === 'blockQuotePrefix' ||\n              tailEvent[1].type === 'blockQuotePrefixWhitespace' ||\n              tailEvent[1].type === 'blockQuoteMarker' ||\n              tailEvent[1].type === 'listItemIndent'\n            ) {\n              // Empty\n            } else {\n              break\n            }\n          }\n\n          if (\n            firstBlankLineIndex &&\n            (!lineIndex || firstBlankLineIndex < lineIndex)\n          ) {\n            listItem._spread = true\n          }\n\n          // Fix position.\n          listItem.end = point(\n            lineIndex ? events[lineIndex][1].start : event[1].end\n          )\n\n          events.splice(lineIndex || index, 0, ['exit', listItem, event[2]])\n          index++\n          length++\n        }\n\n        // Create a new list item.\n        if (event[1].type === 'listItemPrefix') {\n          listItem = {\n            type: 'listItem',\n            _spread: false,\n            start: point(event[1].start)\n          }\n\n          events.splice(index, 0, ['enter', listItem, event[2]])\n          index++\n          length++\n          firstBlankLineIndex = undefined\n          atMarker = true\n        }\n      }\n    }\n\n    events[start][1]._spread = listSpread\n    return length\n  }\n\n  function setData(key, value) {\n    data[key] = value\n  }\n\n  function getData(key) {\n    return data[key]\n  }\n\n  function point(d) {\n    return {line: d.line, column: d.column, offset: d.offset}\n  }\n\n  function opener(create, and) {\n    return open\n\n    function open(token) {\n      enter.call(this, create(token), token)\n      if (and) and.call(this, token)\n    }\n  }\n\n  function buffer() {\n    this.stack.push({type: 'fragment', children: []})\n  }\n\n  function enter(node, token) {\n    this.stack[this.stack.length - 1].children.push(node)\n    this.stack.push(node)\n    this.tokenStack.push(token)\n    node.position = {start: point(token.start)}\n    return node\n  }\n\n  function closer(and) {\n    return close\n\n    function close(token) {\n      if (and) and.call(this, token)\n      exit.call(this, token)\n    }\n  }\n\n  function exit(token) {\n    var node = this.stack.pop()\n    var open = this.tokenStack.pop()\n\n    if (!open) {\n      throw new Error(\n        'Cannot close `' +\n          token.type +\n          '` (' +\n          stringifyPosition({start: token.start, end: token.end}) +\n          '): it’s not open'\n      )\n    } else if (open.type !== token.type) {\n      throw new Error(\n        'Cannot close `' +\n          token.type +\n          '` (' +\n          stringifyPosition({start: token.start, end: token.end}) +\n          '): a different token (`' +\n          open.type +\n          '`, ' +\n          stringifyPosition({start: open.start, end: open.end}) +\n          ') is open'\n      )\n    }\n\n    node.position.end = point(token.end)\n    return node\n  }\n\n  function resume() {\n    return toString(this.stack.pop())\n  }\n\n  //\n  // Handlers.\n  //\n\n  function onenterlistordered() {\n    setData('expectingFirstListItemValue', true)\n  }\n\n  function onenterlistitemvalue(token) {\n    if (getData('expectingFirstListItemValue')) {\n      this.stack[this.stack.length - 2].start = parseInt(\n        this.sliceSerialize(token),\n        10\n      )\n\n      setData('expectingFirstListItemValue')\n    }\n  }\n\n  function onexitcodefencedfenceinfo() {\n    var data = this.resume()\n    this.stack[this.stack.length - 1].lang = data\n  }\n\n  function onexitcodefencedfencemeta() {\n    var data = this.resume()\n    this.stack[this.stack.length - 1].meta = data\n  }\n\n  function onexitcodefencedfence() {\n    // Exit if this is the closing fence.\n    if (getData('flowCodeInside')) return\n    this.buffer()\n    setData('flowCodeInside', true)\n  }\n\n  function onexitcodefenced() {\n    var data = this.resume()\n    this.stack[this.stack.length - 1].value = data.replace(\n      /^(\\r?\\n|\\r)|(\\r?\\n|\\r)$/g,\n      ''\n    )\n\n    setData('flowCodeInside')\n  }\n\n  function onexitcodeindented() {\n    var data = this.resume()\n    this.stack[this.stack.length - 1].value = data\n  }\n\n  function onexitdefinitionlabelstring(token) {\n    // Discard label, use the source content instead.\n    var label = this.resume()\n    this.stack[this.stack.length - 1].label = label\n    this.stack[this.stack.length - 1].identifier = normalizeIdentifier(\n      this.sliceSerialize(token)\n    ).toLowerCase()\n  }\n\n  function onexitdefinitiontitlestring() {\n    var data = this.resume()\n    this.stack[this.stack.length - 1].title = data\n  }\n\n  function onexitdefinitiondestinationstring() {\n    var data = this.resume()\n    this.stack[this.stack.length - 1].url = data\n  }\n\n  function onexitatxheadingsequence(token) {\n    if (!this.stack[this.stack.length - 1].depth) {\n      this.stack[this.stack.length - 1].depth = this.sliceSerialize(\n        token\n      ).length\n    }\n  }\n\n  function onexitsetextheadingtext() {\n    setData('setextHeadingSlurpLineEnding', true)\n  }\n\n  function onexitsetextheadinglinesequence(token) {\n    this.stack[this.stack.length - 1].depth =\n      this.sliceSerialize(token).charCodeAt(0) === 61 ? 1 : 2\n  }\n\n  function onexitsetextheading() {\n    setData('setextHeadingSlurpLineEnding')\n  }\n\n  function onenterdata(token) {\n    var siblings = this.stack[this.stack.length - 1].children\n    var tail = siblings[siblings.length - 1]\n\n    if (!tail || tail.type !== 'text') {\n      // Add a new text node.\n      tail = text()\n      tail.position = {start: point(token.start)}\n      this.stack[this.stack.length - 1].children.push(tail)\n    }\n\n    this.stack.push(tail)\n  }\n\n  function onexitdata(token) {\n    var tail = this.stack.pop()\n    tail.value += this.sliceSerialize(token)\n    tail.position.end = point(token.end)\n  }\n\n  function onexitlineending(token) {\n    var context = this.stack[this.stack.length - 1]\n\n    // If we’re at a hard break, include the line ending in there.\n    if (getData('atHardBreak')) {\n      context.children[context.children.length - 1].position.end = point(\n        token.end\n      )\n\n      setData('atHardBreak')\n      return\n    }\n\n    if (\n      !getData('setextHeadingSlurpLineEnding') &&\n      config.canContainEols.indexOf(context.type) > -1\n    ) {\n      onenterdata.call(this, token)\n      onexitdata.call(this, token)\n    }\n  }\n\n  function onexithardbreak() {\n    setData('atHardBreak', true)\n  }\n\n  function onexithtmlflow() {\n    var data = this.resume()\n    this.stack[this.stack.length - 1].value = data\n  }\n\n  function onexithtmltext() {\n    var data = this.resume()\n    this.stack[this.stack.length - 1].value = data\n  }\n\n  function onexitcodetext() {\n    var data = this.resume()\n    this.stack[this.stack.length - 1].value = data\n  }\n\n  function onexitlink() {\n    var context = this.stack[this.stack.length - 1]\n\n    // To do: clean.\n    if (getData('inReference')) {\n      context.type += 'Reference'\n      context.referenceType = getData('referenceType') || 'shortcut'\n      delete context.url\n      delete context.title\n    } else {\n      delete context.identifier\n      delete context.label\n      delete context.referenceType\n    }\n\n    setData('referenceType')\n  }\n\n  function onexitimage() {\n    var context = this.stack[this.stack.length - 1]\n\n    // To do: clean.\n    if (getData('inReference')) {\n      context.type += 'Reference'\n      context.referenceType = getData('referenceType') || 'shortcut'\n      delete context.url\n      delete context.title\n    } else {\n      delete context.identifier\n      delete context.label\n      delete context.referenceType\n    }\n\n    setData('referenceType')\n  }\n\n  function onexitlabeltext(token) {\n    this.stack[this.stack.length - 2].identifier = normalizeIdentifier(\n      this.sliceSerialize(token)\n    ).toLowerCase()\n  }\n\n  function onexitlabel() {\n    var fragment = this.stack[this.stack.length - 1]\n    var value = this.resume()\n\n    this.stack[this.stack.length - 1].label = value\n\n    // Assume a reference.\n    setData('inReference', true)\n\n    if (this.stack[this.stack.length - 1].type === 'link') {\n      this.stack[this.stack.length - 1].children = fragment.children\n    } else {\n      this.stack[this.stack.length - 1].alt = value\n    }\n  }\n\n  function onexitresourcedestinationstring() {\n    var data = this.resume()\n    this.stack[this.stack.length - 1].url = data\n  }\n\n  function onexitresourcetitlestring() {\n    var data = this.resume()\n    this.stack[this.stack.length - 1].title = data\n  }\n\n  function onexitresource() {\n    setData('inReference')\n  }\n\n  function onenterreference() {\n    setData('referenceType', 'collapsed')\n  }\n\n  function onexitreferencestring(token) {\n    var label = this.resume()\n    this.stack[this.stack.length - 1].label = label\n    this.stack[this.stack.length - 1].identifier = normalizeIdentifier(\n      this.sliceSerialize(token)\n    ).toLowerCase()\n    setData('referenceType', 'full')\n  }\n\n  function onexitcharacterreferencemarker(token) {\n    setData('characterReferenceType', token.type)\n  }\n\n  function onexitcharacterreferencevalue(token) {\n    var data = this.sliceSerialize(token)\n    var type = getData('characterReferenceType')\n    var value\n    var tail\n\n    if (type) {\n      value = safeFromInt(\n        data,\n        type === 'characterReferenceMarkerNumeric' ? 10 : 16\n      )\n\n      setData('characterReferenceType')\n    } else {\n      value = decode(data)\n    }\n\n    tail = this.stack.pop()\n    tail.value += value\n    tail.position.end = point(token.end)\n  }\n\n  function onexitautolinkprotocol(token) {\n    onexitdata.call(this, token)\n    this.stack[this.stack.length - 1].url = this.sliceSerialize(token)\n  }\n\n  function onexitautolinkemail(token) {\n    onexitdata.call(this, token)\n    this.stack[this.stack.length - 1].url =\n      'mailto:' + this.sliceSerialize(token)\n  }\n\n  //\n  // Creaters.\n  //\n\n  function blockQuote() {\n    return {type: 'blockquote', children: []}\n  }\n\n  function codeFlow() {\n    return {type: 'code', lang: null, meta: null, value: ''}\n  }\n\n  function codeText() {\n    return {type: 'inlineCode', value: ''}\n  }\n\n  function definition() {\n    return {\n      type: 'definition',\n      identifier: '',\n      label: null,\n      title: null,\n      url: ''\n    }\n  }\n\n  function emphasis() {\n    return {type: 'emphasis', children: []}\n  }\n\n  function heading() {\n    return {type: 'heading', depth: undefined, children: []}\n  }\n\n  function hardBreak() {\n    return {type: 'break'}\n  }\n\n  function html() {\n    return {type: 'html', value: ''}\n  }\n\n  function image() {\n    return {type: 'image', title: null, url: '', alt: null}\n  }\n\n  function link() {\n    return {type: 'link', title: null, url: '', children: []}\n  }\n\n  function list(token) {\n    return {\n      type: 'list',\n      ordered: token.type === 'listOrdered',\n      start: null,\n      spread: token._spread,\n      children: []\n    }\n  }\n\n  function listItem(token) {\n    return {\n      type: 'listItem',\n      spread: token._spread,\n      checked: null,\n      children: []\n    }\n  }\n\n  function paragraph() {\n    return {type: 'paragraph', children: []}\n  }\n\n  function strong() {\n    return {type: 'strong', children: []}\n  }\n\n  function text() {\n    return {type: 'text', value: ''}\n  }\n\n  function thematicBreak() {\n    return {type: 'thematicBreak'}\n  }\n}\n\nfunction configure(config, extensions) {\n  var index = -1\n\n  while (++index < extensions.length) {\n    extension(config, extensions[index])\n  }\n\n  return config\n}\n\nfunction extension(config, extension) {\n  var key\n  var left\n\n  for (key in extension) {\n    left = own.call(config, key) ? config[key] : (config[key] = {})\n\n    if (key === 'canContainEols' || key === 'transforms') {\n      config[key] = [].concat(left, extension[key])\n    } else {\n      Object.assign(left, extension[key])\n    }\n  }\n}\n","'use strict'\n\nmodule.exports = require('./dist')\n","'use strict'\n\nmodule.exports = toString\n\n// Get the text content of a node.\n// Prefer the node’s plain-text fields, otherwise serialize its children,\n// and if the given value is an array, serialize the nodes in it.\nfunction toString(node) {\n  return (\n    (node &&\n      (node.value ||\n        node.alt ||\n        node.title ||\n        ('children' in node && all(node.children)) ||\n        ('length' in node && all(node)))) ||\n    ''\n  )\n}\n\nfunction all(values) {\n  var result = []\n  var index = -1\n\n  while (++index < values.length) {\n    result[index] = toString(values[index])\n  }\n\n  return result.join('')\n}\n","'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","'use strict'\n\n/* eslint-env browser */\n\nvar el\n\nvar semicolon = 59 //  ';'\n\nmodule.exports = decodeEntity\n\nfunction decodeEntity(characters) {\n  var entity = '&' + characters + ';'\n  var char\n\n  el = el || document.createElement('i')\n  el.innerHTML = entity\n  char = el.textContent\n\n  // Some entities do not require the closing semicolon (`&not` - for instance),\n  // which leads to situations where parsing the assumed entity of &notit; will\n  // result in the string `¬it;`.  When we encounter a trailing semicolon after\n  // parsing and the entity to decode was not a semicolon (`&semi;`), we can\n  // assume that the matching was incomplete\n  if (char.charCodeAt(char.length - 1) === semicolon && characters !== 'semi') {\n    return false\n  }\n\n  // If the decoded string is equal to the input, the entity was not valid\n  return char === entity ? false : char\n}\n","'use strict';\n\nvar React = require('react');\n\nvar xtend = require('xtend');\n\nvar ReactIs = require('react-is');\n\nfunction astToReact(node, options) {\n  var parent = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  var index = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;\n  var renderer = options.renderers[node.type]; // Nodes created by plugins do not have positional info, in which case we set\n  // an object that matches the positon interface.\n\n  if (!node.position) {\n    node.position = {\n      start: {\n        line: null,\n        column: null,\n        offset: null\n      },\n      end: {\n        line: null,\n        column: null,\n        offset: null\n      }\n    };\n  }\n\n  var pos = node.position.start;\n  var key = [node.type, pos.line, pos.column, index].join('-');\n\n  if (!ReactIs.isValidElementType(renderer)) {\n    throw new Error(\"Renderer for type `\".concat(node.type, \"` not defined or is not renderable\"));\n  }\n\n  var nodeProps = getNodeProps(node, key, options, renderer, parent, index);\n  return React.createElement(renderer, nodeProps, nodeProps.children || resolveChildren() || undefined);\n\n  function resolveChildren() {\n    return node.children && node.children.map(function (childNode, i) {\n      return astToReact(childNode, options, {\n        node: node,\n        props: nodeProps\n      }, i);\n    });\n  }\n} // eslint-disable-next-line max-params, complexity\n\n\nfunction getNodeProps(node, key, opts, renderer, parent, index) {\n  var props = {\n    key: key\n  };\n  var isSimpleRenderer = typeof renderer === 'string' || renderer === React.Fragment; // `sourcePos` is true if the user wants source information (line/column info from markdown source)\n\n  if (opts.sourcePos && node.position) {\n    props['data-sourcepos'] = flattenPosition(node.position);\n  }\n\n  if (opts.rawSourcePos && !isSimpleRenderer) {\n    props.sourcePosition = node.position;\n  } // If `includeNodeIndex` is true, pass node index info to all non-tag renderers\n\n\n  if (opts.includeNodeIndex && parent.node && parent.node.children && !isSimpleRenderer) {\n    props.index = parent.node.children.indexOf(node);\n    props.parentChildCount = parent.node.children.length;\n  }\n\n  var ref = node.identifier !== null && node.identifier !== undefined ?\n  /* istanbul ignore next - plugins could inject an undefined reference. */\n  opts.definitions[node.identifier.toUpperCase()] || {} : null;\n\n  switch (node.type) {\n    case 'root':\n      assignDefined(props, {\n        className: opts.className\n      });\n      break;\n\n    case 'text':\n      props.nodeKey = key;\n      props.children = node.value;\n      break;\n\n    case 'heading':\n      props.level = node.depth;\n      break;\n\n    case 'list':\n      props.start = node.start;\n      props.ordered = node.ordered;\n      props.spread = node.spread;\n      props.depth = node.depth;\n      break;\n\n    case 'listItem':\n      props.checked = node.checked;\n      props.spread = node.spread;\n      props.ordered = node.ordered;\n      props.index = node.index;\n      props.children = getListItemChildren(node, parent).map(function (childNode, i) {\n        return astToReact(childNode, opts, {\n          node: node,\n          props: props\n        }, i);\n      });\n      break;\n\n    case 'definition':\n      assignDefined(props, {\n        identifier: node.identifier,\n        title: node.title,\n        url: node.url\n      });\n      break;\n\n    case 'code':\n      assignDefined(props, {\n        language: node.lang && node.lang.split(/\\s/, 1)[0]\n      });\n      break;\n\n    case 'inlineCode':\n      props.children = node.value;\n      props.inline = true;\n      break;\n\n    case 'link':\n      assignDefined(props, {\n        title: node.title || undefined,\n        target: typeof opts.linkTarget === 'function' ? opts.linkTarget(node.url, node.children, node.title) : opts.linkTarget,\n        href: opts.transformLinkUri ? opts.transformLinkUri(node.url, node.children, node.title) : node.url\n      });\n      break;\n\n    case 'image':\n      assignDefined(props, {\n        src: opts.transformImageUri ? opts.transformImageUri(node.url, node.children, node.title, node.alt) : node.url,\n        alt: node.alt || '',\n        title: node.title || undefined\n      });\n      break;\n\n    case 'linkReference':\n      assignDefined(props, xtend(ref, {\n        href: opts.transformLinkUri ? opts.transformLinkUri(ref.href) : ref.href\n      }));\n      break;\n\n    case 'imageReference':\n      assignDefined(props, {\n        src: opts.transformImageUri && ref.href ? opts.transformImageUri(ref.href, node.children, ref.title, node.alt) : ref.href,\n        alt: node.alt || '',\n        title: ref.title || undefined\n      });\n      break;\n\n    case 'table':\n    case 'tableHead':\n    case 'tableBody':\n      props.columnAlignment = node.align;\n      break;\n\n    case 'tableRow':\n      props.isHeader = parent.node.type === 'tableHead';\n      props.columnAlignment = parent.props.columnAlignment;\n      break;\n\n    case 'tableCell':\n      assignDefined(props, {\n        isHeader: parent.props.isHeader,\n        align: parent.props.columnAlignment[index]\n      });\n      break;\n\n    case 'virtualHtml':\n      props.tag = node.tag;\n      break;\n\n    case 'html':\n      // @todo find a better way than this\n      props.isBlock = node.position.start.line !== node.position.end.line;\n      props.allowDangerousHtml = opts.allowDangerousHtml;\n      props.escapeHtml = opts.escapeHtml;\n      props.skipHtml = opts.skipHtml;\n      break;\n\n    case 'parsedHtml':\n      {\n        var parsedChildren;\n\n        if (node.children) {\n          parsedChildren = node.children.map(function (child, i) {\n            return astToReact(child, opts, {\n              node: node,\n              props: props\n            }, i);\n          });\n        }\n\n        props.allowDangerousHtml = opts.allowDangerousHtml;\n        props.escapeHtml = opts.escapeHtml;\n        props.skipHtml = opts.skipHtml;\n        props.element = node.element ? mergeNodeChildren(node, parsedChildren) : null;\n        break;\n      }\n\n    default:\n      assignDefined(props, xtend(node, {\n        type: undefined,\n        position: undefined,\n        children: undefined\n      }));\n  }\n\n  if (!isSimpleRenderer && node.value) {\n    props.value = node.value;\n  }\n\n  if (!isSimpleRenderer) {\n    props.node = node;\n  }\n\n  return props;\n}\n\nfunction assignDefined(target, attrs) {\n  for (var key in attrs) {\n    if (typeof attrs[key] !== 'undefined') {\n      target[key] = attrs[key];\n    }\n  }\n}\n\nfunction mergeNodeChildren(node, parsedChildren) {\n  var el = node.element;\n\n  if (Array.isArray(el)) {\n    /* istanbul ignore next - `div` fallback for old React. */\n    var Fragment = React.Fragment || 'div';\n    return React.createElement(Fragment, null, el);\n  }\n\n  if (el.props.children || parsedChildren) {\n    var children = React.Children.toArray(el.props.children).concat(parsedChildren);\n    return React.cloneElement(el, null, children);\n  }\n\n  return React.cloneElement(el, null);\n}\n\nfunction flattenPosition(pos) {\n  return [pos.start.line, ':', pos.start.column, '-', pos.end.line, ':', pos.end.column].map(String).join('');\n}\n\nfunction getListItemChildren(node, parent) {\n  /* istanbul ignore next - list items are always in a list, but best to be sure. */\n  var loose = parent && parent.node ? listLoose(parent.node) : listItemLoose(node);\n  return loose ? node.children : unwrapParagraphs(node);\n}\n\nfunction unwrapParagraphs(node) {\n  return node.children.reduce(function (array, child) {\n    return array.concat(child.type === 'paragraph' ? child.children : [child]);\n  }, []);\n}\n\nfunction listLoose(node) {\n  var children = node.children;\n  var loose = node.spread;\n  var index = -1;\n\n  while (!loose && ++index < children.length) {\n    loose = listItemLoose(children[index]);\n  }\n\n  return loose;\n}\n\nfunction listItemLoose(node) {\n  var spread = node.spread;\n  /* istanbul ignore next - spread is present from remark-parse, but maybe plugins don’t set it. */\n\n  return spread === undefined || spread === null ? node.children.length > 1 : spread;\n}\n\nmodule.exports = astToReact;","'use strict';\n\nvar visit = require('unist-util-visit');\n\nmodule.exports = function getDefinitions(tree) {\n  var definitions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  visit(tree, 'definition', function (node) {\n    var identifier = node.identifier.toUpperCase();\n    if (identifier in definitions) return;\n    definitions[identifier] = {\n      href: node.url,\n      title: node.title\n    };\n  });\n  return definitions;\n};","\"use strict\";\n\nvar visit = require('unist-util-visit');\n\nvar splice = [].splice;\n\nexports.ofType = function (types, mode) {\n  return ifNotMatch(allow, mode);\n\n  function allow(node, index, parent) {\n    return !types.includes(node.type);\n  }\n};\n\nexports.ifNotMatch = ifNotMatch;\n\nfunction ifNotMatch(allow, mode) {\n  return transform;\n\n  function transform(tree) {\n    visit(tree, filter);\n    return tree;\n  } // eslint-disable-next-line consistent-return\n\n\n  function filter(node, index, parent) {\n    if (parent && !allow(node, index, parent)) {\n      var parameters = [index, 1];\n\n      if (mode === 'unwrap' && node.children) {\n        parameters = parameters.concat(node.children);\n      }\n\n      splice.apply(parent.children, parameters);\n      return index;\n    }\n  }\n}","\"use strict\";\n\n/**\n * Naive, simple plugin to match inline nodes without attributes\n * This allows say <strong>foo</strong>, but not <strong class=\"very\">foo</strong>\n * For proper HTML support, you'll want a different plugin\n **/\nvar visit = require('unist-util-visit');\n\nvar type = 'virtualHtml';\nvar selfClosingRe = /^<(area|base|br|col|embed|hr|img|input|keygen|link|meta|param|source|track|wbr)\\s*\\/?>$/i;\nvar simpleTagRe = /^<(\\/?)([a-z]+)\\s*>$/;\n\nmodule.exports = function (tree) {\n  var open;\n  var currentParent;\n  visit(tree, 'html', function (node, index, parent) {\n    if (currentParent !== parent) {\n      open = [];\n      currentParent = parent;\n    }\n\n    var selfClosing = getSelfClosing(node);\n\n    if (selfClosing) {\n      parent.children.splice(index, 1, {\n        type: type,\n        tag: selfClosing,\n        position: node.position\n      });\n      return true;\n    }\n\n    var current = getSimpleTag(node, parent);\n\n    if (!current) {\n      return true;\n    }\n\n    var matching = findAndPull(open, current.tag);\n\n    if (matching) {\n      parent.children.splice(index, 0, virtual(current, matching, parent));\n    } else if (!current.opening) {\n      open.push(current);\n    }\n\n    return true;\n  }, true // Iterate in reverse\n  );\n  return tree;\n};\n\nfunction findAndPull(open, matchingTag) {\n  var i = open.length;\n\n  while (i--) {\n    if (open[i].tag === matchingTag) {\n      return open.splice(i, 1)[0];\n    }\n  }\n\n  return false;\n}\n\nfunction getSimpleTag(node, parent) {\n  var match = node.value.match(simpleTagRe);\n  return match ? {\n    tag: match[2],\n    opening: !match[1],\n    node: node\n  } : false;\n}\n\nfunction getSelfClosing(node) {\n  var match = node.value.match(selfClosingRe);\n  return match ? match[1] : false;\n}\n\nfunction virtual(fromNode, toNode, parent) {\n  var fromIndex = parent.children.indexOf(fromNode.node);\n  var toIndex = parent.children.indexOf(toNode.node);\n  var extracted = parent.children.splice(fromIndex, toIndex - fromIndex + 1);\n  var children = extracted.slice(1, -1);\n  return {\n    type: type,\n    children: children,\n    tag: fromNode.tag,\n    position: {\n      start: fromNode.node.position.start,\n      end: toNode.node.position.end,\n      indent: []\n    }\n  };\n}","'use strict';\n\nvar xtend = require('xtend');\n\nvar unified = require('unified');\n\nvar parse = require('remark-parse');\n\nvar PropTypes = require('prop-types');\n\nvar addListMetadata = require('mdast-add-list-metadata');\n\nvar naiveHtml = require('./plugins/naive-html');\n\nvar disallowNode = require('./plugins/disallow-node');\n\nvar astToReact = require('./ast-to-react');\n\nvar wrapTableRows = require('./wrap-table-rows');\n\nvar getDefinitions = require('./get-definitions');\n\nvar uriTransformer = require('./uri-transformer');\n\nvar defaultRenderers = require('./renderers');\n\nvar symbols = require('./symbols');\n\nvar allTypes = Object.keys(defaultRenderers);\n\nvar ReactMarkdown = function ReactMarkdown(props) {\n  // To do in next major: remove `source`.\n  var src = props.source || props.children || '';\n\n  if (props.allowedTypes && props.disallowedTypes) {\n    throw new Error('Only one of `allowedTypes` and `disallowedTypes` should be defined');\n  }\n\n  var renderers = xtend(defaultRenderers, props.renderers);\n  var processor = unified().use(parse).use(props.plugins || []); // eslint-disable-next-line no-sync\n\n  var tree = processor.runSync(processor.parse(src));\n  var renderProps = xtend(props, {\n    renderers: renderers,\n    definitions: getDefinitions(tree)\n  });\n  determineAstToReactTransforms(props).forEach(function (transform) {\n    tree = transform(tree, renderProps);\n  });\n  return tree;\n};\n\nfunction determineAstToReactTransforms(props) {\n  var transforms = [wrapTableRows, addListMetadata()];\n  var disallowedTypes = props.disallowedTypes;\n\n  if (props.allowedTypes) {\n    disallowedTypes = allTypes.filter(function (type) {\n      return type !== 'root' && props.allowedTypes.indexOf(type) === -1;\n    });\n  }\n\n  var removalMethod = props.unwrapDisallowed ? 'unwrap' : 'remove';\n\n  if (disallowedTypes && disallowedTypes.length > 0) {\n    transforms.push(disallowNode.ofType(disallowedTypes, removalMethod));\n  }\n\n  if (props.allowNode) {\n    transforms.push(disallowNode.ifNotMatch(props.allowNode, removalMethod));\n  } // To do in next major: remove `escapeHtml`.\n\n\n  var renderHtml = (props.allowDangerousHtml || props.escapeHtml === false) && !props.skipHtml;\n  var hasHtmlParser = (props.astPlugins || []).some(function (transform) {\n    return transform.identity === symbols.HtmlParser;\n  });\n\n  if (renderHtml && !hasHtmlParser) {\n    transforms.push(naiveHtml);\n  }\n\n  if (props.astPlugins) {\n    transforms = transforms.concat(props.astPlugins);\n  } // Add the final transform to turn everything into React.\n\n\n  transforms.push(astToReact);\n  return transforms;\n}\n\nReactMarkdown.defaultProps = {\n  transformLinkUri: uriTransformer\n};\nReactMarkdown.propTypes = {\n  className: PropTypes.string,\n  source: PropTypes.string,\n  children: PropTypes.string,\n  sourcePos: PropTypes.bool,\n  rawSourcePos: PropTypes.bool,\n  escapeHtml: PropTypes.bool,\n  allowDangerousHtml: PropTypes.bool,\n  skipHtml: PropTypes.bool,\n  allowNode: PropTypes.func,\n  allowedTypes: PropTypes.arrayOf(PropTypes.oneOf(allTypes)),\n  disallowedTypes: PropTypes.arrayOf(PropTypes.oneOf(allTypes)),\n  transformLinkUri: PropTypes.oneOfType([PropTypes.func, PropTypes.bool]),\n  linkTarget: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  transformImageUri: PropTypes.func,\n  astPlugins: PropTypes.arrayOf(PropTypes.func),\n  unwrapDisallowed: PropTypes.bool,\n  renderers: PropTypes.object,\n  plugins: PropTypes.array\n};\nReactMarkdown.types = allTypes;\nReactMarkdown.renderers = defaultRenderers;\nReactMarkdown.uriTransformer = uriTransformer;\nmodule.exports = ReactMarkdown;","/* eslint-disable react/prop-types, react/no-multi-comp */\n'use strict';\n\nvar xtend = require('xtend');\n\nvar React = require('react');\n/* istanbul ignore next - Don’t crash on old React. */\n\n\nvar supportsStringRender = parseInt((React.version || '16').slice(0, 2), 10) >= 16;\nvar createElement = React.createElement;\nmodule.exports = {\n  break: 'br',\n  paragraph: 'p',\n  emphasis: 'em',\n  strong: 'strong',\n  thematicBreak: 'hr',\n  blockquote: 'blockquote',\n  delete: 'del',\n  link: 'a',\n  image: 'img',\n  linkReference: 'a',\n  imageReference: 'img',\n  table: SimpleRenderer.bind(null, 'table'),\n  tableHead: SimpleRenderer.bind(null, 'thead'),\n  tableBody: SimpleRenderer.bind(null, 'tbody'),\n  tableRow: SimpleRenderer.bind(null, 'tr'),\n  tableCell: TableCell,\n  root: Root,\n  text: TextRenderer,\n  list: List,\n  listItem: ListItem,\n  definition: NullRenderer,\n  heading: Heading,\n  inlineCode: InlineCode,\n  code: CodeBlock,\n  html: Html,\n  virtualHtml: VirtualHtml,\n  parsedHtml: ParsedHtml\n};\n\nfunction TextRenderer(props) {\n  /* istanbul ignore next - a text node w/o a value could be injected by plugins */\n  var children = props.children || '';\n  /* istanbul ignore next - `span` is a fallback for old React. */\n\n  return supportsStringRender ? children : createElement('span', null, children);\n}\n\nfunction Root(props) {\n  var className = props.className;\n  var root = !className && React.Fragment || 'div';\n  return createElement(root, className ? {\n    className: className\n  } : null, props.children);\n}\n\nfunction SimpleRenderer(tag, props) {\n  return createElement(tag, getCoreProps(props), props.children);\n}\n\nfunction TableCell(props) {\n  var style = props.align ? {\n    textAlign: props.align\n  } : undefined;\n  var coreProps = getCoreProps(props);\n  return createElement(props.isHeader ? 'th' : 'td', style ? xtend({\n    style: style\n  }, coreProps) : coreProps, props.children);\n}\n\nfunction Heading(props) {\n  return createElement(\"h\".concat(props.level), getCoreProps(props), props.children);\n}\n\nfunction List(props) {\n  var attrs = getCoreProps(props);\n\n  if (props.start !== null && props.start !== 1 && props.start !== undefined) {\n    attrs.start = props.start.toString();\n  }\n\n  return createElement(props.ordered ? 'ol' : 'ul', attrs, props.children);\n}\n\nfunction ListItem(props) {\n  var checkbox = null;\n\n  if (props.checked !== null && props.checked !== undefined) {\n    var checked = props.checked;\n    checkbox = createElement('input', {\n      type: 'checkbox',\n      checked: checked,\n      readOnly: true\n    });\n  }\n\n  return createElement('li', getCoreProps(props), checkbox, props.children);\n}\n\nfunction CodeBlock(props) {\n  var className = props.language && \"language-\".concat(props.language);\n  var code = createElement('code', className ? {\n    className: className\n  } : null, props.value);\n  return createElement('pre', getCoreProps(props), code);\n}\n\nfunction InlineCode(props) {\n  return createElement('code', getCoreProps(props), props.children);\n}\n\nfunction Html(props) {\n  if (props.skipHtml) {\n    return null;\n  }\n\n  var dangerous = props.allowDangerousHtml || props.escapeHtml === false;\n  var tag = props.isBlock ? 'div' : 'span';\n\n  if (!dangerous) {\n    /* istanbul ignore next - `tag` is a fallback for old React. */\n    return createElement(React.Fragment || tag, null, props.value);\n  }\n\n  var nodeProps = {\n    dangerouslySetInnerHTML: {\n      __html: props.value\n    }\n  };\n  return createElement(tag, nodeProps);\n}\n\nfunction ParsedHtml(props) {\n  /* To do: `React.cloneElement` is slow, is it really needed? */\n  return props['data-sourcepos'] ? React.cloneElement(props.element, {\n    'data-sourcepos': props['data-sourcepos']\n  }) : props.element;\n}\n\nfunction VirtualHtml(props) {\n  return createElement(props.tag, getCoreProps(props), props.children);\n}\n\nfunction NullRenderer() {\n  return null;\n}\n\nfunction getCoreProps(props) {\n  var source = props['data-sourcepos'];\n  /* istanbul ignore next - nodes from plugins w/o position */\n\n  return source ? {\n    'data-sourcepos': source\n  } : {};\n}","\"use strict\";\n\nvar HtmlParser = '__RMD_HTML_PARSER__';\n/* istanbul ignore next - Fallback for `Symbol`. */\n\nexports.HtmlParser = typeof Symbol === 'undefined' ? HtmlParser : Symbol(HtmlParser);","\"use strict\";\n\nvar protocols = ['http', 'https', 'mailto', 'tel'];\n\nmodule.exports = function uriTransformer(uri) {\n  var url = (uri || '').trim();\n  var first = url.charAt(0);\n\n  if (first === '#' || first === '/') {\n    return url;\n  }\n\n  var colon = url.indexOf(':');\n\n  if (colon === -1) {\n    return url;\n  }\n\n  var length = protocols.length;\n  var index = -1;\n\n  while (++index < length) {\n    var protocol = protocols[index];\n\n    if (colon === protocol.length && url.slice(0, protocol.length).toLowerCase() === protocol) {\n      return url;\n    }\n  }\n\n  index = url.indexOf('?');\n\n  if (index !== -1 && colon > index) {\n    return url;\n  }\n\n  index = url.indexOf('#');\n\n  if (index !== -1 && colon > index) {\n    return url;\n  } // eslint-disable-next-line no-script-url\n\n\n  return 'javascript:void(0)';\n};","'use strict';\n\nvar visit = require('unist-util-visit');\n\nmodule.exports = function (node) {\n  visit(node, 'table', wrap);\n  return node;\n};\n\nfunction wrap(table) {\n  var children = table.children;\n  table.children = [{\n    type: 'tableHead',\n    align: table.align,\n    children: [children[0]],\n    position: children[0].position\n  }];\n\n  if (children.length > 1) {\n    table.children.push({\n      type: 'tableBody',\n      align: table.align,\n      children: children.slice(1),\n      position: {\n        start: children[1].position.start,\n        end: children[children.length - 1].position.end\n      }\n    });\n  }\n}","/** @license React v16.13.1\n * react-is.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';var b=\"function\"===typeof Symbol&&Symbol.for,c=b?Symbol.for(\"react.element\"):60103,d=b?Symbol.for(\"react.portal\"):60106,e=b?Symbol.for(\"react.fragment\"):60107,f=b?Symbol.for(\"react.strict_mode\"):60108,g=b?Symbol.for(\"react.profiler\"):60114,h=b?Symbol.for(\"react.provider\"):60109,k=b?Symbol.for(\"react.context\"):60110,l=b?Symbol.for(\"react.async_mode\"):60111,m=b?Symbol.for(\"react.concurrent_mode\"):60111,n=b?Symbol.for(\"react.forward_ref\"):60112,p=b?Symbol.for(\"react.suspense\"):60113,q=b?\nSymbol.for(\"react.suspense_list\"):60120,r=b?Symbol.for(\"react.memo\"):60115,t=b?Symbol.for(\"react.lazy\"):60116,v=b?Symbol.for(\"react.block\"):60121,w=b?Symbol.for(\"react.fundamental\"):60117,x=b?Symbol.for(\"react.responder\"):60118,y=b?Symbol.for(\"react.scope\"):60119;\nfunction z(a){if(\"object\"===typeof a&&null!==a){var u=a.$$typeof;switch(u){case c:switch(a=a.type,a){case l:case m:case e:case g:case f:case p:return a;default:switch(a=a&&a.$$typeof,a){case k:case n:case t:case r:case h:return a;default:return u}}case d:return u}}}function A(a){return z(a)===m}exports.AsyncMode=l;exports.ConcurrentMode=m;exports.ContextConsumer=k;exports.ContextProvider=h;exports.Element=c;exports.ForwardRef=n;exports.Fragment=e;exports.Lazy=t;exports.Memo=r;exports.Portal=d;\nexports.Profiler=g;exports.StrictMode=f;exports.Suspense=p;exports.isAsyncMode=function(a){return A(a)||z(a)===l};exports.isConcurrentMode=A;exports.isContextConsumer=function(a){return z(a)===k};exports.isContextProvider=function(a){return z(a)===h};exports.isElement=function(a){return\"object\"===typeof a&&null!==a&&a.$$typeof===c};exports.isForwardRef=function(a){return z(a)===n};exports.isFragment=function(a){return z(a)===e};exports.isLazy=function(a){return z(a)===t};\nexports.isMemo=function(a){return z(a)===r};exports.isPortal=function(a){return z(a)===d};exports.isProfiler=function(a){return z(a)===g};exports.isStrictMode=function(a){return z(a)===f};exports.isSuspense=function(a){return z(a)===p};\nexports.isValidElementType=function(a){return\"string\"===typeof a||\"function\"===typeof a||a===e||a===m||a===g||a===f||a===p||a===q||\"object\"===typeof a&&null!==a&&(a.$$typeof===t||a.$$typeof===r||a.$$typeof===h||a.$$typeof===k||a.$$typeof===n||a.$$typeof===w||a.$$typeof===x||a.$$typeof===y||a.$$typeof===v)};exports.typeOf=z;\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react-is.production.min.js');\n} else {\n  module.exports = require('./cjs/react-is.development.js');\n}\n","'use strict'\n\nmodule.exports = parse\n\nvar fromMarkdown = require('mdast-util-from-markdown')\n\nfunction parse(options) {\n  var self = this\n\n  this.Parser = parse\n\n  function parse(doc) {\n    return fromMarkdown(\n      doc,\n      Object.assign({}, self.data('settings'), options, {\n        // Note: these options are not in the readme.\n        // The goal is for them to be set by plugins on `data` instead of being\n        // passed by users.\n        extensions: self.data('micromarkExtensions') || [],\n        mdastExtensions: self.data('fromMarkdownExtensions') || []\n      })\n    )\n  }\n}\n","'use strict'\n\nvar wrap = require('./wrap.js')\n\nmodule.exports = trough\n\ntrough.wrap = wrap\n\nvar slice = [].slice\n\n// Create new middleware.\nfunction trough() {\n  var fns = []\n  var middleware = {}\n\n  middleware.run = run\n  middleware.use = use\n\n  return middleware\n\n  // Run `fns`.  Last argument must be a completion handler.\n  function run() {\n    var index = -1\n    var input = slice.call(arguments, 0, -1)\n    var done = arguments[arguments.length - 1]\n\n    if (typeof done !== 'function') {\n      throw new Error('Expected function as last argument, not ' + done)\n    }\n\n    next.apply(null, [null].concat(input))\n\n    // Run the next `fn`, if any.\n    function next(err) {\n      var fn = fns[++index]\n      var params = slice.call(arguments, 0)\n      var values = params.slice(1)\n      var length = input.length\n      var pos = -1\n\n      if (err) {\n        done(err)\n        return\n      }\n\n      // Copy non-nully input into values.\n      while (++pos < length) {\n        if (values[pos] === null || values[pos] === undefined) {\n          values[pos] = input[pos]\n        }\n      }\n\n      input = values\n\n      // Next or done.\n      if (fn) {\n        wrap(fn, next).apply(null, input)\n      } else {\n        done.apply(null, [null].concat(input))\n      }\n    }\n  }\n\n  // Add `fn` to the list.\n  function use(fn) {\n    if (typeof fn !== 'function') {\n      throw new Error('Expected `fn` to be a function, not ' + fn)\n    }\n\n    fns.push(fn)\n\n    return middleware\n  }\n}\n","'use strict'\n\nvar slice = [].slice\n\nmodule.exports = wrap\n\n// Wrap `fn`.\n// Can be sync or async; return a promise, receive a completion handler, return\n// new values and errors.\nfunction wrap(fn, callback) {\n  var invoked\n\n  return wrapped\n\n  function wrapped() {\n    var params = slice.call(arguments, 0)\n    var callback = fn.length > params.length\n    var result\n\n    if (callback) {\n      params.push(done)\n    }\n\n    try {\n      result = fn.apply(null, params)\n    } catch (error) {\n      // Well, this is quite the pickle.\n      // `fn` received a callback and invoked it (thus continuing the pipeline),\n      // but later also threw an error.\n      // We’re not about to restart the pipeline again, so the only thing left\n      // to do is to throw the thing instead.\n      if (callback && invoked) {\n        throw error\n      }\n\n      return done(error)\n    }\n\n    if (!callback) {\n      if (result && typeof result.then === 'function') {\n        result.then(then, done)\n      } else if (result instanceof Error) {\n        done(result)\n      } else {\n        then(result)\n      }\n    }\n  }\n\n  // Invoke `next`, only once.\n  function done() {\n    if (!invoked) {\n      invoked = true\n\n      callback.apply(null, arguments)\n    }\n  }\n\n  // Invoke `done` with one value.\n  // Tracks if an error is passed, too.\n  function then(value) {\n    done(null, value)\n  }\n}\n","'use strict'\n\nvar bail = require('bail')\nvar buffer = require('is-buffer')\nvar extend = require('extend')\nvar plain = require('is-plain-obj')\nvar trough = require('trough')\nvar vfile = require('vfile')\n\n// Expose a frozen processor.\nmodule.exports = unified().freeze()\n\nvar slice = [].slice\nvar own = {}.hasOwnProperty\n\n// Process pipeline.\nvar pipeline = trough()\n  .use(pipelineParse)\n  .use(pipelineRun)\n  .use(pipelineStringify)\n\nfunction pipelineParse(p, ctx) {\n  ctx.tree = p.parse(ctx.file)\n}\n\nfunction pipelineRun(p, ctx, next) {\n  p.run(ctx.tree, ctx.file, done)\n\n  function done(error, tree, file) {\n    if (error) {\n      next(error)\n    } else {\n      ctx.tree = tree\n      ctx.file = file\n      next()\n    }\n  }\n}\n\nfunction pipelineStringify(p, ctx) {\n  var result = p.stringify(ctx.tree, ctx.file)\n\n  if (result === undefined || result === null) {\n    // Empty.\n  } else if (typeof result === 'string' || buffer(result)) {\n    if ('value' in ctx.file) {\n      ctx.file.value = result\n    }\n\n    ctx.file.contents = result\n  } else {\n    ctx.file.result = result\n  }\n}\n\n// Function to create the first processor.\nfunction unified() {\n  var attachers = []\n  var transformers = trough()\n  var namespace = {}\n  var freezeIndex = -1\n  var frozen\n\n  // Data management.\n  processor.data = data\n\n  // Lock.\n  processor.freeze = freeze\n\n  // Plugins.\n  processor.attachers = attachers\n  processor.use = use\n\n  // API.\n  processor.parse = parse\n  processor.stringify = stringify\n  processor.run = run\n  processor.runSync = runSync\n  processor.process = process\n  processor.processSync = processSync\n\n  // Expose.\n  return processor\n\n  // Create a new processor based on the processor in the current scope.\n  function processor() {\n    var destination = unified()\n    var index = -1\n\n    while (++index < attachers.length) {\n      destination.use.apply(null, attachers[index])\n    }\n\n    destination.data(extend(true, {}, namespace))\n\n    return destination\n  }\n\n  // Freeze: used to signal a processor that has finished configuration.\n  //\n  // For example, take unified itself: it’s frozen.\n  // Plugins should not be added to it.\n  // Rather, it should be extended, by invoking it, before modifying it.\n  //\n  // In essence, always invoke this when exporting a processor.\n  function freeze() {\n    var values\n    var transformer\n\n    if (frozen) {\n      return processor\n    }\n\n    while (++freezeIndex < attachers.length) {\n      values = attachers[freezeIndex]\n\n      if (values[1] === false) {\n        continue\n      }\n\n      if (values[1] === true) {\n        values[1] = undefined\n      }\n\n      transformer = values[0].apply(processor, values.slice(1))\n\n      if (typeof transformer === 'function') {\n        transformers.use(transformer)\n      }\n    }\n\n    frozen = true\n    freezeIndex = Infinity\n\n    return processor\n  }\n\n  // Data management.\n  // Getter / setter for processor-specific informtion.\n  function data(key, value) {\n    if (typeof key === 'string') {\n      // Set `key`.\n      if (arguments.length === 2) {\n        assertUnfrozen('data', frozen)\n        namespace[key] = value\n        return processor\n      }\n\n      // Get `key`.\n      return (own.call(namespace, key) && namespace[key]) || null\n    }\n\n    // Set space.\n    if (key) {\n      assertUnfrozen('data', frozen)\n      namespace = key\n      return processor\n    }\n\n    // Get space.\n    return namespace\n  }\n\n  // Plugin management.\n  //\n  // Pass it:\n  // *   an attacher and options,\n  // *   a preset,\n  // *   a list of presets, attachers, and arguments (list of attachers and\n  //     options).\n  function use(value) {\n    var settings\n\n    assertUnfrozen('use', frozen)\n\n    if (value === null || value === undefined) {\n      // Empty.\n    } else if (typeof value === 'function') {\n      addPlugin.apply(null, arguments)\n    } else if (typeof value === 'object') {\n      if ('length' in value) {\n        addList(value)\n      } else {\n        addPreset(value)\n      }\n    } else {\n      throw new Error('Expected usable value, not `' + value + '`')\n    }\n\n    if (settings) {\n      namespace.settings = extend(namespace.settings || {}, settings)\n    }\n\n    return processor\n\n    function addPreset(result) {\n      addList(result.plugins)\n\n      if (result.settings) {\n        settings = extend(settings || {}, result.settings)\n      }\n    }\n\n    function add(value) {\n      if (typeof value === 'function') {\n        addPlugin(value)\n      } else if (typeof value === 'object') {\n        if ('length' in value) {\n          addPlugin.apply(null, value)\n        } else {\n          addPreset(value)\n        }\n      } else {\n        throw new Error('Expected usable value, not `' + value + '`')\n      }\n    }\n\n    function addList(plugins) {\n      var index = -1\n\n      if (plugins === null || plugins === undefined) {\n        // Empty.\n      } else if (typeof plugins === 'object' && 'length' in plugins) {\n        while (++index < plugins.length) {\n          add(plugins[index])\n        }\n      } else {\n        throw new Error('Expected a list of plugins, not `' + plugins + '`')\n      }\n    }\n\n    function addPlugin(plugin, value) {\n      var entry = find(plugin)\n\n      if (entry) {\n        if (plain(entry[1]) && plain(value)) {\n          value = extend(true, entry[1], value)\n        }\n\n        entry[1] = value\n      } else {\n        attachers.push(slice.call(arguments))\n      }\n    }\n  }\n\n  function find(plugin) {\n    var index = -1\n\n    while (++index < attachers.length) {\n      if (attachers[index][0] === plugin) {\n        return attachers[index]\n      }\n    }\n  }\n\n  // Parse a file (in string or vfile representation) into a unist node using\n  // the `Parser` on the processor.\n  function parse(doc) {\n    var file = vfile(doc)\n    var Parser\n\n    freeze()\n    Parser = processor.Parser\n    assertParser('parse', Parser)\n\n    if (newable(Parser, 'parse')) {\n      return new Parser(String(file), file).parse()\n    }\n\n    return Parser(String(file), file) // eslint-disable-line new-cap\n  }\n\n  // Run transforms on a unist node representation of a file (in string or\n  // vfile representation), async.\n  function run(node, file, cb) {\n    assertNode(node)\n    freeze()\n\n    if (!cb && typeof file === 'function') {\n      cb = file\n      file = null\n    }\n\n    if (!cb) {\n      return new Promise(executor)\n    }\n\n    executor(null, cb)\n\n    function executor(resolve, reject) {\n      transformers.run(node, vfile(file), done)\n\n      function done(error, tree, file) {\n        tree = tree || node\n        if (error) {\n          reject(error)\n        } else if (resolve) {\n          resolve(tree)\n        } else {\n          cb(null, tree, file)\n        }\n      }\n    }\n  }\n\n  // Run transforms on a unist node representation of a file (in string or\n  // vfile representation), sync.\n  function runSync(node, file) {\n    var result\n    var complete\n\n    run(node, file, done)\n\n    assertDone('runSync', 'run', complete)\n\n    return result\n\n    function done(error, tree) {\n      complete = true\n      result = tree\n      bail(error)\n    }\n  }\n\n  // Stringify a unist node representation of a file (in string or vfile\n  // representation) into a string using the `Compiler` on the processor.\n  function stringify(node, doc) {\n    var file = vfile(doc)\n    var Compiler\n\n    freeze()\n    Compiler = processor.Compiler\n    assertCompiler('stringify', Compiler)\n    assertNode(node)\n\n    if (newable(Compiler, 'compile')) {\n      return new Compiler(node, file).compile()\n    }\n\n    return Compiler(node, file) // eslint-disable-line new-cap\n  }\n\n  // Parse a file (in string or vfile representation) into a unist node using\n  // the `Parser` on the processor, then run transforms on that node, and\n  // compile the resulting node using the `Compiler` on the processor, and\n  // store that result on the vfile.\n  function process(doc, cb) {\n    freeze()\n    assertParser('process', processor.Parser)\n    assertCompiler('process', processor.Compiler)\n\n    if (!cb) {\n      return new Promise(executor)\n    }\n\n    executor(null, cb)\n\n    function executor(resolve, reject) {\n      var file = vfile(doc)\n\n      pipeline.run(processor, {file: file}, done)\n\n      function done(error) {\n        if (error) {\n          reject(error)\n        } else if (resolve) {\n          resolve(file)\n        } else {\n          cb(null, file)\n        }\n      }\n    }\n  }\n\n  // Process the given document (in string or vfile representation), sync.\n  function processSync(doc) {\n    var file\n    var complete\n\n    freeze()\n    assertParser('processSync', processor.Parser)\n    assertCompiler('processSync', processor.Compiler)\n    file = vfile(doc)\n\n    process(file, done)\n\n    assertDone('processSync', 'process', complete)\n\n    return file\n\n    function done(error) {\n      complete = true\n      bail(error)\n    }\n  }\n}\n\n// Check if `value` is a constructor.\nfunction newable(value, name) {\n  return (\n    typeof value === 'function' &&\n    value.prototype &&\n    // A function with keys in its prototype is probably a constructor.\n    // Classes’ prototype methods are not enumerable, so we check if some value\n    // exists in the prototype.\n    (keys(value.prototype) || name in value.prototype)\n  )\n}\n\n// Check if `value` is an object with keys.\nfunction keys(value) {\n  var key\n  for (key in value) {\n    return true\n  }\n\n  return false\n}\n\n// Assert a parser is available.\nfunction assertParser(name, Parser) {\n  if (typeof Parser !== 'function') {\n    throw new Error('Cannot `' + name + '` without `Parser`')\n  }\n}\n\n// Assert a compiler is available.\nfunction assertCompiler(name, Compiler) {\n  if (typeof Compiler !== 'function') {\n    throw new Error('Cannot `' + name + '` without `Compiler`')\n  }\n}\n\n// Assert the processor is not frozen.\nfunction assertUnfrozen(name, frozen) {\n  if (frozen) {\n    throw new Error(\n      'Cannot invoke `' +\n        name +\n        '` on a frozen processor.\\nCreate a new processor first, by invoking it: use `processor()` instead of `processor`.'\n    )\n  }\n}\n\n// Assert `node` is a unist node.\nfunction assertNode(node) {\n  if (!node || typeof node.type !== 'string') {\n    throw new Error('Expected node, got `' + node + '`')\n  }\n}\n\n// Assert that `complete` is `true`.\nfunction assertDone(name, asyncName, complete) {\n  if (!complete) {\n    throw new Error(\n      '`' + name + '` finished async. Use `' + asyncName + '` instead'\n    )\n  }\n}\n","'use strict';\n\nmodule.exports = value => {\n\tif (Object.prototype.toString.call(value) !== '[object Object]') {\n\t\treturn false;\n\t}\n\n\tconst prototype = Object.getPrototypeOf(value);\n\treturn prototype === null || prototype === Object.prototype;\n};\n","'use strict'\n\nmodule.exports = convert\n\nfunction convert(test) {\n  if (test == null) {\n    return ok\n  }\n\n  if (typeof test === 'string') {\n    return typeFactory(test)\n  }\n\n  if (typeof test === 'object') {\n    return 'length' in test ? anyFactory(test) : allFactory(test)\n  }\n\n  if (typeof test === 'function') {\n    return test\n  }\n\n  throw new Error('Expected function, string, or object as test')\n}\n\n// Utility assert each property in `test` is represented in `node`, and each\n// values are strictly equal.\nfunction allFactory(test) {\n  return all\n\n  function all(node) {\n    var key\n\n    for (key in test) {\n      if (node[key] !== test[key]) return false\n    }\n\n    return true\n  }\n}\n\nfunction anyFactory(tests) {\n  var checks = []\n  var index = -1\n\n  while (++index < tests.length) {\n    checks[index] = convert(tests[index])\n  }\n\n  return any\n\n  function any() {\n    var index = -1\n\n    while (++index < checks.length) {\n      if (checks[index].apply(this, arguments)) {\n        return true\n      }\n    }\n\n    return false\n  }\n}\n\n// Utility to convert a string into a function which checks a given node’s type\n// for said string.\nfunction typeFactory(test) {\n  return type\n\n  function type(node) {\n    return Boolean(node && node.type === test)\n  }\n}\n\n// Utility to return true.\nfunction ok() {\n  return true\n}\n","'use strict'\n\nvar own = {}.hasOwnProperty\n\nmodule.exports = stringify\n\nfunction stringify(value) {\n  // Nothing.\n  if (!value || typeof value !== 'object') {\n    return ''\n  }\n\n  // Node.\n  if (own.call(value, 'position') || own.call(value, 'type')) {\n    return position(value.position)\n  }\n\n  // Position.\n  if (own.call(value, 'start') || own.call(value, 'end')) {\n    return position(value)\n  }\n\n  // Point.\n  if (own.call(value, 'line') || own.call(value, 'column')) {\n    return point(value)\n  }\n\n  // ?\n  return ''\n}\n\nfunction point(point) {\n  if (!point || typeof point !== 'object') {\n    point = {}\n  }\n\n  return index(point.line) + ':' + index(point.column)\n}\n\nfunction position(pos) {\n  if (!pos || typeof pos !== 'object') {\n    pos = {}\n  }\n\n  return point(pos.start) + '-' + point(pos.end)\n}\n\nfunction index(value) {\n  return value && typeof value === 'number' ? value : 1\n}\n","'use strict'\n\n/* Expose. */\nmodule.exports = visitParents\n\n/* Visit. */\nfunction visitParents(tree, type, visitor) {\n  var stack = []\n\n  if (typeof type === 'function') {\n    visitor = type\n    type = null\n  }\n\n  one(tree)\n\n  /* Visit a single node. */\n  function one(node) {\n    var result\n\n    if (!type || node.type === type) {\n      result = visitor(node, stack.concat())\n    }\n\n    if (node.children && result !== false) {\n      return all(node.children, node)\n    }\n\n    return result\n  }\n\n  /* Visit children in `parent`. */\n  function all(children, parent) {\n    var length = children.length\n    var index = -1\n    var child\n\n    stack.push(parent)\n\n    while (++index < length) {\n      child = children[index]\n\n      if (child && one(child) === false) {\n        return false\n      }\n    }\n\n    stack.pop()\n\n    return true\n  }\n}\n","'use strict'\n\nmodule.exports = visit\n\nvar visitParents = require('unist-util-visit-parents')\n\nvar CONTINUE = visitParents.CONTINUE\nvar SKIP = visitParents.SKIP\nvar EXIT = visitParents.EXIT\n\nvisit.CONTINUE = CONTINUE\nvisit.SKIP = SKIP\nvisit.EXIT = EXIT\n\nfunction visit(tree, test, visitor, reverse) {\n  if (typeof test === 'function' && typeof visitor !== 'function') {\n    reverse = visitor\n    visitor = test\n    test = null\n  }\n\n  visitParents(tree, test, overload, reverse)\n\n  function overload(node, parents) {\n    var parent = parents[parents.length - 1]\n    var index = parent ? parent.children.indexOf(node) : null\n    return visitor(node, index, parent)\n  }\n}\n","module.exports = identity\nfunction identity(d) {\n  return d\n}\n","'use strict'\n\nmodule.exports = visitParents\n\nvar convert = require('unist-util-is/convert')\nvar color = require('./color')\n\nvar CONTINUE = true\nvar SKIP = 'skip'\nvar EXIT = false\n\nvisitParents.CONTINUE = CONTINUE\nvisitParents.SKIP = SKIP\nvisitParents.EXIT = EXIT\n\nfunction visitParents(tree, test, visitor, reverse) {\n  var step\n  var is\n\n  if (typeof test === 'function' && typeof visitor !== 'function') {\n    reverse = visitor\n    visitor = test\n    test = null\n  }\n\n  is = convert(test)\n  step = reverse ? -1 : 1\n\n  factory(tree, null, [])()\n\n  function factory(node, index, parents) {\n    var value = typeof node === 'object' && node !== null ? node : {}\n    var name\n\n    if (typeof value.type === 'string') {\n      name =\n        typeof value.tagName === 'string'\n          ? value.tagName\n          : typeof value.name === 'string'\n          ? value.name\n          : undefined\n\n      visit.displayName =\n        'node (' + color(value.type + (name ? '<' + name + '>' : '')) + ')'\n    }\n\n    return visit\n\n    function visit() {\n      var grandparents = parents.concat(node)\n      var result = []\n      var subresult\n      var offset\n\n      if (!test || is(node, index, parents[parents.length - 1] || null)) {\n        result = toResult(visitor(node, parents))\n\n        if (result[0] === EXIT) {\n          return result\n        }\n      }\n\n      if (node.children && result[0] !== SKIP) {\n        offset = (reverse ? node.children.length : -1) + step\n\n        while (offset > -1 && offset < node.children.length) {\n          subresult = factory(node.children[offset], offset, grandparents)()\n\n          if (subresult[0] === EXIT) {\n            return subresult\n          }\n\n          offset =\n            typeof subresult[1] === 'number' ? subresult[1] : offset + step\n        }\n      }\n\n      return result\n    }\n  }\n}\n\nfunction toResult(value) {\n  if (value !== null && typeof value === 'object' && 'length' in value) {\n    return value\n  }\n\n  if (typeof value === 'number') {\n    return [CONTINUE, value]\n  }\n\n  return [value]\n}\n","'use strict'\n\nvar stringify = require('unist-util-stringify-position')\n\nmodule.exports = VMessage\n\n// Inherit from `Error#`.\nfunction VMessagePrototype() {}\nVMessagePrototype.prototype = Error.prototype\nVMessage.prototype = new VMessagePrototype()\n\n// Message properties.\nvar proto = VMessage.prototype\n\nproto.file = ''\nproto.name = ''\nproto.reason = ''\nproto.message = ''\nproto.stack = ''\nproto.fatal = null\nproto.column = null\nproto.line = null\n\n// Construct a new VMessage.\n//\n// Note: We cannot invoke `Error` on the created context, as that adds readonly\n// `line` and `column` attributes on Safari 9, thus throwing and failing the\n// data.\nfunction VMessage(reason, position, origin) {\n  var parts\n  var range\n  var location\n\n  if (typeof position === 'string') {\n    origin = position\n    position = null\n  }\n\n  parts = parseOrigin(origin)\n  range = stringify(position) || '1:1'\n\n  location = {\n    start: {line: null, column: null},\n    end: {line: null, column: null}\n  }\n\n  // Node.\n  if (position && position.position) {\n    position = position.position\n  }\n\n  if (position) {\n    // Position.\n    if (position.start) {\n      location = position\n      position = position.start\n    } else {\n      // Point.\n      location.start = position\n    }\n  }\n\n  if (reason.stack) {\n    this.stack = reason.stack\n    reason = reason.message\n  }\n\n  this.message = reason\n  this.name = range\n  this.reason = reason\n  this.line = position ? position.line : null\n  this.column = position ? position.column : null\n  this.location = location\n  this.source = parts[0]\n  this.ruleId = parts[1]\n}\n\nfunction parseOrigin(origin) {\n  var result = [null, null]\n  var index\n\n  if (typeof origin === 'string') {\n    index = origin.indexOf(':')\n\n    if (index === -1) {\n      result[1] = origin\n    } else {\n      result[0] = origin.slice(0, index)\n      result[1] = origin.slice(index + 1)\n    }\n  }\n\n  return result\n}\n","'use strict'\n\nmodule.exports = require('./lib')\n","'use strict'\n\nvar p = require('./minpath')\nvar proc = require('./minproc')\nvar buffer = require('is-buffer')\n\nmodule.exports = VFile\n\nvar own = {}.hasOwnProperty\n\n// Order of setting (least specific to most), we need this because otherwise\n// `{stem: 'a', path: '~/b.js'}` would throw, as a path is needed before a\n// stem can be set.\nvar order = ['history', 'path', 'basename', 'stem', 'extname', 'dirname']\n\nVFile.prototype.toString = toString\n\n// Access full path (`~/index.min.js`).\nObject.defineProperty(VFile.prototype, 'path', {get: getPath, set: setPath})\n\n// Access parent path (`~`).\nObject.defineProperty(VFile.prototype, 'dirname', {\n  get: getDirname,\n  set: setDirname\n})\n\n// Access basename (`index.min.js`).\nObject.defineProperty(VFile.prototype, 'basename', {\n  get: getBasename,\n  set: setBasename\n})\n\n// Access extname (`.js`).\nObject.defineProperty(VFile.prototype, 'extname', {\n  get: getExtname,\n  set: setExtname\n})\n\n// Access stem (`index.min`).\nObject.defineProperty(VFile.prototype, 'stem', {get: getStem, set: setStem})\n\n// Construct a new file.\nfunction VFile(options) {\n  var prop\n  var index\n\n  if (!options) {\n    options = {}\n  } else if (typeof options === 'string' || buffer(options)) {\n    options = {contents: options}\n  } else if ('message' in options && 'messages' in options) {\n    return options\n  }\n\n  if (!(this instanceof VFile)) {\n    return new VFile(options)\n  }\n\n  this.data = {}\n  this.messages = []\n  this.history = []\n  this.cwd = proc.cwd()\n\n  // Set path related properties in the correct order.\n  index = -1\n\n  while (++index < order.length) {\n    prop = order[index]\n\n    if (own.call(options, prop)) {\n      this[prop] = options[prop]\n    }\n  }\n\n  // Set non-path related properties.\n  for (prop in options) {\n    if (order.indexOf(prop) < 0) {\n      this[prop] = options[prop]\n    }\n  }\n}\n\nfunction getPath() {\n  return this.history[this.history.length - 1]\n}\n\nfunction setPath(path) {\n  assertNonEmpty(path, 'path')\n\n  if (this.path !== path) {\n    this.history.push(path)\n  }\n}\n\nfunction getDirname() {\n  return typeof this.path === 'string' ? p.dirname(this.path) : undefined\n}\n\nfunction setDirname(dirname) {\n  assertPath(this.path, 'dirname')\n  this.path = p.join(dirname || '', this.basename)\n}\n\nfunction getBasename() {\n  return typeof this.path === 'string' ? p.basename(this.path) : undefined\n}\n\nfunction setBasename(basename) {\n  assertNonEmpty(basename, 'basename')\n  assertPart(basename, 'basename')\n  this.path = p.join(this.dirname || '', basename)\n}\n\nfunction getExtname() {\n  return typeof this.path === 'string' ? p.extname(this.path) : undefined\n}\n\nfunction setExtname(extname) {\n  assertPart(extname, 'extname')\n  assertPath(this.path, 'extname')\n\n  if (extname) {\n    if (extname.charCodeAt(0) !== 46 /* `.` */) {\n      throw new Error('`extname` must start with `.`')\n    }\n\n    if (extname.indexOf('.', 1) > -1) {\n      throw new Error('`extname` cannot contain multiple dots')\n    }\n  }\n\n  this.path = p.join(this.dirname, this.stem + (extname || ''))\n}\n\nfunction getStem() {\n  return typeof this.path === 'string'\n    ? p.basename(this.path, this.extname)\n    : undefined\n}\n\nfunction setStem(stem) {\n  assertNonEmpty(stem, 'stem')\n  assertPart(stem, 'stem')\n  this.path = p.join(this.dirname || '', stem + (this.extname || ''))\n}\n\n// Get the value of the file.\nfunction toString(encoding) {\n  return (this.contents || '').toString(encoding)\n}\n\n// Assert that `part` is not a path (i.e., does not contain `p.sep`).\nfunction assertPart(part, name) {\n  if (part && part.indexOf(p.sep) > -1) {\n    throw new Error(\n      '`' + name + '` cannot be a path: did not expect `' + p.sep + '`'\n    )\n  }\n}\n\n// Assert that `part` is not empty.\nfunction assertNonEmpty(part, name) {\n  if (!part) {\n    throw new Error('`' + name + '` cannot be empty')\n  }\n}\n\n// Assert `path` exists.\nfunction assertPath(path, name) {\n  if (!path) {\n    throw new Error('Setting `' + name + '` requires `path` to be set too')\n  }\n}\n","'use strict'\n\nvar VMessage = require('vfile-message')\nvar VFile = require('./core.js')\n\nmodule.exports = VFile\n\nVFile.prototype.message = message\nVFile.prototype.info = info\nVFile.prototype.fail = fail\n\n// Create a message with `reason` at `position`.\n// When an error is passed in as `reason`, copies the stack.\nfunction message(reason, position, origin) {\n  var message = new VMessage(reason, position, origin)\n\n  if (this.path) {\n    message.name = this.path + ':' + message.name\n    message.file = this.path\n  }\n\n  message.fatal = false\n\n  this.messages.push(message)\n\n  return message\n}\n\n// Fail: creates a vmessage, associates it with the file, and throws it.\nfunction fail() {\n  var message = this.message.apply(this, arguments)\n\n  message.fatal = true\n\n  throw message\n}\n\n// Info: creates a vmessage, associates it with the file, and marks the fatality\n// as null.\nfunction info() {\n  var message = this.message.apply(this, arguments)\n\n  message.fatal = null\n\n  return message\n}\n","'use strict'\n\n// A derivative work based on:\n// <https://github.com/browserify/path-browserify>.\n// Which is licensed:\n//\n// MIT License\n//\n// Copyright (c) 2013 James Halliday\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy of\n// this software and associated documentation files (the \"Software\"), to deal in\n// the Software without restriction, including without limitation the rights to\n// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\n// the Software, and to permit persons to whom the Software is furnished to do so,\n// subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\n// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\n// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\n// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\n// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n// A derivative work based on:\n//\n// Parts of that are extracted from Node’s internal `path` module:\n// <https://github.com/nodejs/node/blob/master/lib/path.js>.\n// Which is licensed:\n//\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nexports.basename = basename\nexports.dirname = dirname\nexports.extname = extname\nexports.join = join\nexports.sep = '/'\n\nfunction basename(path, ext) {\n  var start = 0\n  var end = -1\n  var index\n  var firstNonSlashEnd\n  var seenNonSlash\n  var extIndex\n\n  if (ext !== undefined && typeof ext !== 'string') {\n    throw new TypeError('\"ext\" argument must be a string')\n  }\n\n  assertPath(path)\n  index = path.length\n\n  if (ext === undefined || !ext.length || ext.length > path.length) {\n    while (index--) {\n      if (path.charCodeAt(index) === 47 /* `/` */) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now.\n        if (seenNonSlash) {\n          start = index + 1\n          break\n        }\n      } else if (end < 0) {\n        // We saw the first non-path separator, mark this as the end of our\n        // path component.\n        seenNonSlash = true\n        end = index + 1\n      }\n    }\n\n    return end < 0 ? '' : path.slice(start, end)\n  }\n\n  if (ext === path) {\n    return ''\n  }\n\n  firstNonSlashEnd = -1\n  extIndex = ext.length - 1\n\n  while (index--) {\n    if (path.charCodeAt(index) === 47 /* `/` */) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now.\n      if (seenNonSlash) {\n        start = index + 1\n        break\n      }\n    } else {\n      if (firstNonSlashEnd < 0) {\n        // We saw the first non-path separator, remember this index in case\n        // we need it if the extension ends up not matching.\n        seenNonSlash = true\n        firstNonSlashEnd = index + 1\n      }\n\n      if (extIndex > -1) {\n        // Try to match the explicit extension.\n        if (path.charCodeAt(index) === ext.charCodeAt(extIndex--)) {\n          if (extIndex < 0) {\n            // We matched the extension, so mark this as the end of our path\n            // component\n            end = index\n          }\n        } else {\n          // Extension does not match, so our result is the entire path\n          // component\n          extIndex = -1\n          end = firstNonSlashEnd\n        }\n      }\n    }\n  }\n\n  if (start === end) {\n    end = firstNonSlashEnd\n  } else if (end < 0) {\n    end = path.length\n  }\n\n  return path.slice(start, end)\n}\n\nfunction dirname(path) {\n  var end\n  var unmatchedSlash\n  var index\n\n  assertPath(path)\n\n  if (!path.length) {\n    return '.'\n  }\n\n  end = -1\n  index = path.length\n\n  // Prefix `--` is important to not run on `0`.\n  while (--index) {\n    if (path.charCodeAt(index) === 47 /* `/` */) {\n      if (unmatchedSlash) {\n        end = index\n        break\n      }\n    } else if (!unmatchedSlash) {\n      // We saw the first non-path separator\n      unmatchedSlash = true\n    }\n  }\n\n  return end < 0\n    ? path.charCodeAt(0) === 47 /* `/` */\n      ? '/'\n      : '.'\n    : end === 1 && path.charCodeAt(0) === 47 /* `/` */\n    ? '//'\n    : path.slice(0, end)\n}\n\nfunction extname(path) {\n  var startDot = -1\n  var startPart = 0\n  var end = -1\n  // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find.\n  var preDotState = 0\n  var unmatchedSlash\n  var code\n  var index\n\n  assertPath(path)\n\n  index = path.length\n\n  while (index--) {\n    code = path.charCodeAt(index)\n\n    if (code === 47 /* `/` */) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now.\n      if (unmatchedSlash) {\n        startPart = index + 1\n        break\n      }\n\n      continue\n    }\n\n    if (end < 0) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension.\n      unmatchedSlash = true\n      end = index + 1\n    }\n\n    if (code === 46 /* `.` */) {\n      // If this is our first dot, mark it as the start of our extension.\n      if (startDot < 0) {\n        startDot = index\n      } else if (preDotState !== 1) {\n        preDotState = 1\n      }\n    } else if (startDot > -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension.\n      preDotState = -1\n    }\n  }\n\n  if (\n    startDot < 0 ||\n    end < 0 ||\n    // We saw a non-dot character immediately before the dot.\n    preDotState === 0 ||\n    // The (right-most) trimmed path component is exactly `..`.\n    (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)\n  ) {\n    return ''\n  }\n\n  return path.slice(startDot, end)\n}\n\nfunction join() {\n  var index = -1\n  var joined\n\n  while (++index < arguments.length) {\n    assertPath(arguments[index])\n\n    if (arguments[index]) {\n      joined =\n        joined === undefined\n          ? arguments[index]\n          : joined + '/' + arguments[index]\n    }\n  }\n\n  return joined === undefined ? '.' : normalize(joined)\n}\n\n// Note: `normalize` is not exposed as `path.normalize`, so some code is\n// manually removed from it.\nfunction normalize(path) {\n  var absolute\n  var value\n\n  assertPath(path)\n\n  absolute = path.charCodeAt(0) === 47 /* `/` */\n\n  // Normalize the path according to POSIX rules.\n  value = normalizeString(path, !absolute)\n\n  if (!value.length && !absolute) {\n    value = '.'\n  }\n\n  if (value.length && path.charCodeAt(path.length - 1) === 47 /* / */) {\n    value += '/'\n  }\n\n  return absolute ? '/' + value : value\n}\n\n// Resolve `.` and `..` elements in a path with directory names.\nfunction normalizeString(path, allowAboveRoot) {\n  var result = ''\n  var lastSegmentLength = 0\n  var lastSlash = -1\n  var dots = 0\n  var index = -1\n  var code\n  var lastSlashIndex\n\n  while (++index <= path.length) {\n    if (index < path.length) {\n      code = path.charCodeAt(index)\n    } else if (code === 47 /* `/` */) {\n      break\n    } else {\n      code = 47 /* `/` */\n    }\n\n    if (code === 47 /* `/` */) {\n      if (lastSlash === index - 1 || dots === 1) {\n        // Empty.\n      } else if (lastSlash !== index - 1 && dots === 2) {\n        if (\n          result.length < 2 ||\n          lastSegmentLength !== 2 ||\n          result.charCodeAt(result.length - 1) !== 46 /* `.` */ ||\n          result.charCodeAt(result.length - 2) !== 46 /* `.` */\n        ) {\n          if (result.length > 2) {\n            lastSlashIndex = result.lastIndexOf('/')\n\n            /* istanbul ignore else - No clue how to cover it. */\n            if (lastSlashIndex !== result.length - 1) {\n              if (lastSlashIndex < 0) {\n                result = ''\n                lastSegmentLength = 0\n              } else {\n                result = result.slice(0, lastSlashIndex)\n                lastSegmentLength = result.length - 1 - result.lastIndexOf('/')\n              }\n\n              lastSlash = index\n              dots = 0\n              continue\n            }\n          } else if (result.length) {\n            result = ''\n            lastSegmentLength = 0\n            lastSlash = index\n            dots = 0\n            continue\n          }\n        }\n\n        if (allowAboveRoot) {\n          result = result.length ? result + '/..' : '..'\n          lastSegmentLength = 2\n        }\n      } else {\n        if (result.length) {\n          result += '/' + path.slice(lastSlash + 1, index)\n        } else {\n          result = path.slice(lastSlash + 1, index)\n        }\n\n        lastSegmentLength = index - lastSlash - 1\n      }\n\n      lastSlash = index\n      dots = 0\n    } else if (code === 46 /* `.` */ && dots > -1) {\n      dots++\n    } else {\n      dots = -1\n    }\n  }\n\n  return result\n}\n\nfunction assertPath(path) {\n  if (typeof path !== 'string') {\n    throw new TypeError(\n      'Path must be a string. Received ' + JSON.stringify(path)\n    )\n  }\n}\n","'use strict'\n\n// Somewhat based on:\n// <https://github.com/defunctzombie/node-process/blob/master/browser.js>.\n// But I don’t think one tiny line of code can be copyrighted. 😅\nexports.cwd = cwd\n\nfunction cwd() {\n  return '/'\n}\n","module.exports = extend\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nfunction extend() {\n    var target = {}\n\n    for (var i = 0; i < arguments.length; i++) {\n        var source = arguments[i]\n\n        for (var key in source) {\n            if (hasOwnProperty.call(source, key)) {\n                target[key] = source[key]\n            }\n        }\n    }\n\n    return target\n}\n"],"names":["module","exports","err","hasOwn","Object","prototype","hasOwnProperty","toStr","toString","defineProperty","gOPD","getOwnPropertyDescriptor","isArray","arr","Array","call","isPlainObject","obj","key","hasOwnConstructor","hasIsPrototypeOf","constructor","setProperty","target","options","name","enumerable","configurable","value","newValue","writable","getProperty","extend","src","copy","copyIsArray","clone","arguments","i","length","deep","isBuffer","visitWithParents","require","ast","listNode","parents","n","depth","type","children","child","index","ordered","encoding","undefined","settings","config","extensions","extension","configure","transforms","canContainEols","enter","autolink","opener","link","autolinkProtocol","onenterdata","autolinkEmail","atxHeading","heading","blockQuote","characterEscape","characterReference","codeFenced","codeFlow","codeFencedFenceInfo","buffer","codeFencedFenceMeta","codeIndented","codeText","codeTextData","data","codeFlowValue","definition","definitionDestinationString","definitionLabelString","definitionTitleString","emphasis","hardBreakEscape","hardBreak","hardBreakTrailing","htmlFlow","html","htmlFlowData","htmlText","htmlTextData","image","label","listItem","listItemValue","onenterlistitemvalue","listOrdered","list","onenterlistordered","listUnordered","paragraph","reference","onenterreference","referenceString","resourceDestinationString","resourceTitleString","setextHeading","strong","thematicBreak","exit","closer","atxHeadingSequence","onexitatxheadingsequence","onexitautolinkemail","onexitautolinkprotocol","characterEscapeValue","onexitdata","characterReferenceMarkerHexadecimal","onexitcharacterreferencemarker","characterReferenceMarkerNumeric","characterReferenceValue","onexitcharacterreferencevalue","onexitcodefenced","codeFencedFence","onexitcodefencedfence","onexitcodefencedfenceinfo","onexitcodefencedfencemeta","onexitcodeindented","onexitcodetext","onexitdefinitiondestinationstring","onexitdefinitionlabelstring","onexitdefinitiontitlestring","onexithardbreak","onexithtmlflow","onexithtmltext","onexitimage","onexitlabel","labelText","onexitlabeltext","lineEnding","onexitlineending","onexitlink","onexitreferencestring","onexitresourcedestinationstring","onexitresourcetitlestring","resource","onexitresource","onexitsetextheading","setextHeadingLineSequence","onexitsetextheadinglinesequence","setextHeadingText","onexitsetextheadingtext","mdastExtensions","compile","events","handler","tree","tokenStack","listStack","context","stack","resume","setData","getData","push","prepareList","pop","own","assign","sliceSerialize","Error","stringifyPosition","start","end","position","point","line","column","offset","tailIndex","lineIndex","tailEvent","event","firstBlankLineIndex","atMarker","containerBalance","listSpread","_spread","splice","d","create","and","open","token","this","node","close","parseInt","lang","meta","replace","identifier","normalizeIdentifier","toLowerCase","title","url","charCodeAt","siblings","tail","text","indexOf","referenceType","fragment","alt","safeFromInt","decode","spread","checked","compiler","postprocess","parser","document","write","preprocessor","left","concat","all","values","result","join","asciiAlpha","regexCheck","asciiAlphanumeric","asciiAtext","code","asciiDigit","asciiHexDigit","asciiPunctuation","unicodePunctuationRegex","unicodePunctuation","unicodeWhitespace","fromCharCode","String","text$1","attention","headingAtx","labelEnd","labelStartImage","labelStartLink","setextUnderline","contentInitial","flowInitial","flow","string","insideSpan","null","resolver","disable","markdownLineEnding","factorySpace","tokenize","effects","previous","contentStart","attempt","constructs","consume","lineStart","contentType","next","partialBlankLine","inspectResult","childFlow","childToken","self","continued","inspectConstruct","ok","subcontinued","inspectStart","containerState","continuation","inspectContinue","inspectLess","currentConstruct","concrete","flowContinue","inspectDone","interrupt","interruptible","containerConstruct","inspectFlowEnd","_closeFlow","lazy","lazyFlowConstruct","check","inspectLazy","flowEnd","partial","documentContinue","documentContinued","flowStart","containerContinue","exitContainers","now","_tokenizer","continueFlow","documentAfterPeek","defineSkip","sliceStream","size","nok","content","initial","afterConstruct","shallow","initializeFactory","resolveAll","createResolver","field","notText","atBreak","resolveAllLineSuffixes","extraResolver","chunks","chunk","bufferIndex","tabs","eventIndex","_index","_bufferIndex","combineExtensions","createTokenizer","miniflat","defined","initializer","from","subtokenize","search","atCarriageReturn","match","startPosition","endPosition","lastIndex","exec","slice","Math","ceil","chunkedPush","chunkedSplice","classifyCharacter","movePoint","marker","before","sequence","after","_open","_close","group","openingSequence","closingSequence","use","nextEvents","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","contentContinue","indentedContentConstruct","afterPrefix","resolve","gap","tailExitIndex","headEnterIndex","contentEnd","continuationConstruct","prefixed","factoryDestination","factoryLabel","factoryWhitespace","factoryTitle","labelAfter","titleConstruct","literalType","literalMarkerType","rawType","stringType","limit","Infinity","balance","destinationEnclosedBefore","destinationRaw","destinationEnclosed","destinationEnclosedEscape","destinationRawEscape","markerType","labelEscape","prefix","atFirstTitleBreak","atTitleBreak","titleEscape","seen","fenceOpenInside","headingBreak","htmlBlockNames","htmlRawNames","kind","startTag","declarationStart","tagCloseStart","continuationDeclarationInside","tagName","commentOpenInside","cdataOpenInside","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","inside","onBlank","listItemPrefixWhitespaceConstruct","endOfPrefix","otherPrefix","initialBlankLine","furtherBlankLines","notInCurrentItem","indentConstruct","items","remove","parameters","chunkStart","unshift","apply","hook","right","existing","add","serializeChunks","sliceChunks","initialize","columnStart","resolveAllConstructs","accountForPotentialSkip","fields","constructFactory","construct","addResult","onsuccessfulcheck","main","state","chunkIndex","go","restore","onreturn","bogusState","listOfConstructs","constructIndex","handleListOfConstructs","handleConstruct","startPoint","startPrevious","startCurrentConstruct","startEventsIndex","startStack","store","toUpperCase","regex","called","base","atTab","object","view","startIndex","startBufferIndex","endIndex","endBufferIndex","subcontent","stream","entered","adjust","startPositions","tokenizer","childEvents","jumps","gaps","isInFirstContentOfListItem","_gfmTasklistFirstContentOfListItem","otherIndex","otherEvent","subevents","more","_movePreviousLineEndings","el","characters","char","entity","createElement","innerHTML","textContent","React","xtend","ReactIs","astToReact","parent","renderer","renderers","pos","isValidElementType","nodeProps","opts","props","isSimpleRenderer","Fragment","sourcePos","map","flattenPosition","rawSourcePos","sourcePosition","includeNodeIndex","parentChildCount","ref","definitions","assignDefined","className","nodeKey","level","loose","listItemLoose","listLoose","reduce","array","unwrapParagraphs","getListItemChildren","childNode","language","split","inline","linkTarget","href","transformLinkUri","transformImageUri","columnAlignment","align","isHeader","tag","isBlock","allowDangerousHtml","escapeHtml","skipHtml","parsedChildren","element","Children","toArray","cloneElement","mergeNodeChildren","getNodeProps","attrs","visit","ifNotMatch","allow","mode","filter","ofType","types","includes","selfClosingRe","simpleTagRe","currentParent","selfClosing","getSelfClosing","current","opening","getSimpleTag","matching","matchingTag","findAndPull","fromNode","toNode","fromIndex","toIndex","extracted","indent","virtual","unified","parse","PropTypes","addListMetadata","naiveHtml","disallowNode","wrapTableRows","getDefinitions","uriTransformer","defaultRenderers","symbols","allTypes","keys","ReactMarkdown","source","allowedTypes","disallowedTypes","processor","plugins","runSync","renderProps","removalMethod","unwrapDisallowed","allowNode","renderHtml","hasHtmlParser","astPlugins","some","transform","identity","HtmlParser","determineAstToReactTransforms","forEach","defaultProps","propTypes","bool","func","arrayOf","oneOf","oneOfType","supportsStringRender","version","SimpleRenderer","getCoreProps","break","blockquote","delete","linkReference","imageReference","table","bind","tableHead","tableBody","tableRow","tableCell","style","textAlign","coreProps","root","checkbox","readOnly","inlineCode","dangerous","dangerouslySetInnerHTML","__html","virtualHtml","parsedHtml","Symbol","protocols","uri","trim","first","charAt","colon","protocol","wrap","b","for","c","f","g","h","k","l","m","p","q","r","t","v","w","x","y","z","a","u","$$typeof","A","AsyncMode","ConcurrentMode","ContextConsumer","ContextProvider","Element","ForwardRef","Lazy","Memo","Portal","Profiler","StrictMode","Suspense","isAsyncMode","isConcurrentMode","isContextConsumer","isContextProvider","isElement","isForwardRef","isFragment","isLazy","isMemo","isPortal","isProfiler","isStrictMode","isSuspense","typeOf","Parser","doc","fromMarkdown","trough","fns","middleware","input","fn","callback","invoked","params","error","then","bail","plain","vfile","frozen","attachers","transformers","namespace","freezeIndex","assertUnfrozen","freeze","addPlugin","addList","addPreset","plugin","entry","find","file","assertParser","newable","stringify","Compiler","assertCompiler","assertNode","run","complete","assertDone","process","processSync","destination","transformer","cb","Promise","executor","reject","pipeline","ctx","contents","asyncName","getPrototypeOf","convert","Boolean","typeFactory","tests","checks","any","anyFactory","allFactory","visitor","one","visitParents","CONTINUE","SKIP","EXIT","reverse","color","step","is","factory","displayName","subresult","grandparents","toResult","VMessagePrototype","VMessage","proto","reason","origin","parts","range","location","parseOrigin","message","ruleId","fatal","proc","VFile","order","prop","messages","history","cwd","assertPart","part","sep","assertNonEmpty","assertPath","path","get","set","dirname","basename","extname","stem","fail","TypeError","JSON","ext","firstNonSlashEnd","seenNonSlash","extIndex","unmatchedSlash","startDot","startPart","preDotState","joined","absolute","allowAboveRoot","lastSlashIndex","lastSegmentLength","lastSlash","dots","lastIndexOf","normalizeString","normalize"],"sourceRoot":""}