{"version":3,"file":"49928.1f0888e7.es5.js","mappings":"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","sources":["webpack://assr-alfaleasing/./node_modules/bail/index.js","webpack://assr-alfaleasing/./node_modules/extend/index.js","webpack://assr-alfaleasing/./node_modules/is-buffer/index.js","webpack://assr-alfaleasing/./node_modules/mdast-add-list-metadata/index.js","webpack://assr-alfaleasing/./node_modules/mdast-add-list-metadata/node_modules/unist-util-visit-parents/index.js","webpack://assr-alfaleasing/./node_modules/mdast-util-from-markdown/dist/index.js","webpack://assr-alfaleasing/./node_modules/mdast-util-from-markdown/index.js","webpack://assr-alfaleasing/./node_modules/mdast-util-to-string/index.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/character/ascii-alpha.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/character/ascii-alphanumeric.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/character/ascii-atext.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/character/ascii-control.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/character/ascii-digit.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/character/ascii-hex-digit.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/character/ascii-punctuation.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/character/markdown-line-ending-or-space.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/character/markdown-line-ending.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/character/markdown-space.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/character/unicode-punctuation.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/character/unicode-whitespace.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/constant/assign.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/constant/from-char-code.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/constant/has-own-property.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/constant/html-block-names.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/constant/html-raw-names.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/constant/splice.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/constant/unicode-punctuation-regex.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/constructs.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/initialize/content.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/initialize/document.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/initialize/flow.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/initialize/text.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/parse.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/postprocess.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/preprocess.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/tokenize/attention.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/tokenize/autolink.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/tokenize/block-quote.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/tokenize/character-escape.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/tokenize/character-reference.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/tokenize/code-fenced.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/tokenize/code-indented.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/tokenize/code-text.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/tokenize/content.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/tokenize/definition.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/tokenize/factory-destination.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/tokenize/factory-label.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/tokenize/factory-space.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/tokenize/factory-title.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/tokenize/factory-whitespace.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/tokenize/hard-break-escape.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/tokenize/heading-atx.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/tokenize/html-flow.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/tokenize/html-text.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/tokenize/label-end.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/tokenize/label-start-image.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/tokenize/label-start-link.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/tokenize/line-ending.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/tokenize/list.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/tokenize/partial-blank-line.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/tokenize/setext-underline.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/tokenize/thematic-break.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/util/chunked-push.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/util/chunked-splice.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/util/classify-character.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/util/combine-extensions.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/util/create-tokenizer.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/util/miniflat.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/util/move-point.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/util/normalize-identifier.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/util/prefix-size.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/util/regex-check.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/util/resolve-all.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/util/safe-from-int.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/util/serialize-chunks.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/util/shallow.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/util/size-chunks.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/util/slice-chunks.js","webpack://assr-alfaleasing/./node_modules/micromark/dist/util/subtokenize.js","webpack://assr-alfaleasing/./node_modules/parse-entities/decode-entity.browser.js","webpack://assr-alfaleasing/./node_modules/react-markdown/lib/ast-to-react.js","webpack://assr-alfaleasing/./node_modules/react-markdown/lib/get-definitions.js","webpack://assr-alfaleasing/./node_modules/react-markdown/lib/plugins/disallow-node.js","webpack://assr-alfaleasing/./node_modules/react-markdown/lib/plugins/naive-html.js","webpack://assr-alfaleasing/./node_modules/react-markdown/lib/react-markdown.js","webpack://assr-alfaleasing/./node_modules/react-markdown/lib/renderers.js","webpack://assr-alfaleasing/./node_modules/react-markdown/lib/symbols.js","webpack://assr-alfaleasing/./node_modules/react-markdown/lib/uri-transformer.js","webpack://assr-alfaleasing/./node_modules/react-markdown/lib/wrap-table-rows.js","webpack://assr-alfaleasing/./node_modules/react-markdown/node_modules/is-plain-obj/index.js","webpack://assr-alfaleasing/./node_modules/react-markdown/node_modules/unified/index.js","webpack://assr-alfaleasing/./node_modules/react-markdown/node_modules/unist-util-visit-parents/color.browser.js","webpack://assr-alfaleasing/./node_modules/react-markdown/node_modules/unist-util-visit-parents/index.js","webpack://assr-alfaleasing/./node_modules/react-markdown/node_modules/unist-util-visit/index.js","webpack://assr-alfaleasing/./node_modules/react-markdown/node_modules/vfile-message/index.js","webpack://assr-alfaleasing/./node_modules/react-markdown/node_modules/vfile/index.js","webpack://assr-alfaleasing/./node_modules/react-markdown/node_modules/vfile/lib/core.js","webpack://assr-alfaleasing/./node_modules/react-markdown/node_modules/vfile/lib/index.js","webpack://assr-alfaleasing/./node_modules/react-markdown/node_modules/vfile/lib/minpath.browser.js","webpack://assr-alfaleasing/./node_modules/react-markdown/node_modules/vfile/lib/minproc.browser.js","webpack://assr-alfaleasing/./node_modules/remark-parse/index.js","webpack://assr-alfaleasing/./node_modules/trough/index.js","webpack://assr-alfaleasing/./node_modules/trough/wrap.js","webpack://assr-alfaleasing/./node_modules/unist-util-is/convert.js","webpack://assr-alfaleasing/./node_modules/unist-util-stringify-position/index.js","webpack://assr-alfaleasing/./node_modules/xtend/immutable.js","webpack://assr-alfaleasing/./node_modules/html-escaper/esm/index.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\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 = 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}","'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\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","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\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","'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","'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\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","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","/**\n * Copyright (C) 2017-present by Andrea Giammarchi - @WebReflection\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all 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,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nconst {replace} = '';\n\n// escape\nconst es = /&(?:amp|#38|lt|#60|gt|#62|apos|#39|quot|#34);/g;\nconst ca = /[&<>'\"]/g;\n\nconst esca = {\n  '&': '&amp;',\n  '<': '&lt;',\n  '>': '&gt;',\n  \"'\": '&#39;',\n  '\"': '&quot;'\n};\nconst pe = m => esca[m];\n\n/**\n * Safely escape HTML entities such as `&`, `<`, `>`, `\"`, and `'`.\n * @param {string} es the input to safely escape\n * @returns {string} the escaped input, and it **throws** an error if\n *  the input type is unexpected, except for boolean and numbers,\n *  converted as string.\n */\nexport const escape = es => replace.call(es, ca, pe);\n\n\n// unescape\nconst unes = {\n  '&amp;': '&',\n  '&#38;': '&',\n  '&lt;': '<',\n  '&#60;': '<',\n  '&gt;': '>',\n  '&#62;': '>',\n  '&apos;': \"'\",\n  '&#39;': \"'\",\n  '&quot;': '\"',\n  '&#34;': '\"'\n};\nconst cape = m => unes[m];\n\n/**\n * Safely unescape previously escaped entities such as `&`, `<`, `>`, `\"`,\n * and `'`.\n * @param {string} un a previously escaped string\n * @returns {string} the unescaped input, and it **throws** an error if\n *  the input type is unexpected, except for boolean and numbers,\n *  converted as string.\n */\nexport const unescape = un => replace.call(un, es, cape);\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","ast","listNode","parents","n","depth","type","children","child","index","ordered","tree","visitor","stack","one","node","result","concat","parent","push","pop","all","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","tokenStack","listStack","context","resume","setData","getData","prepareList","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","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","values","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","renderer","renderers","pos","isValidElementType","nodeProps","getNodeProps","resolveChildren","map","childNode","props","opts","isSimpleRenderer","Fragment","sourcePos","rawSourcePos","sourcePosition","includeNodeIndex","parentChildCount","ref","definitions","assignDefined","className","nodeKey","level","loose","listItemLoose","listLoose","reduce","array","unwrapParagraphs","getListItemChildren","language","split","inline","linkTarget","href","transformLinkUri","transformImageUri","columnAlignment","align","isHeader","tag","isBlock","allowDangerousHtml","escapeHtml","skipHtml","parsedChildren","element","Children","toArray","cloneElement","mergeNodeChildren","attrs","visit","ifNotMatch","allow","mode","filter","ofType","types","includes","selfClosingRe","simpleTagRe","currentParent","selfClosing","getSelfClosing","current","opening","getSimpleTag","matching","matchingTag","findAndPull","fromNode","toNode","fromIndex","toIndex","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","getPrototypeOf","bail","plain","trough","vfile","frozen","attachers","transformers","namespace","freezeIndex","assertUnfrozen","freeze","addPlugin","addList","addPreset","plugin","entry","find","doc","Parser","file","assertParser","newable","stringify","Compiler","assertCompiler","assertNode","run","complete","assertDone","error","process","processSync","destination","transformer","cb","Promise","executor","reject","pipeline","p","ctx","contents","asyncName","visitParents","convert","color","CONTINUE","SKIP","EXIT","reverse","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","normalize","absolute","allowAboveRoot","lastSlashIndex","lastSegmentLength","lastSlash","dots","lastIndexOf","normalizeString","TypeError","JSON","ext","firstNonSlashEnd","seenNonSlash","extIndex","unmatchedSlash","startDot","startPart","preDotState","joined","fromMarkdown","fns","middleware","input","fn","params","callback","invoked","then","Boolean","typeFactory","tests","checks","any","anyFactory","allFactory","es","unes","cape","m","unescape","un"],"sourceRoot":""}