{"version":3,"file":"c359fab71ec2afd45fea35487d24707dbc9b64cc-54768adfe2bcb55b3145.js","mappings":"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","sources":["webpack://Listener/./node_modules/bail/index.js","webpack://Listener/./node_modules/extend/index.js","webpack://Listener/./node_modules/is-buffer/index.js","webpack://Listener/./node_modules/mdast-add-list-metadata/index.js","webpack://Listener/./node_modules/mdast-add-list-metadata/node_modules/unist-util-visit-parents/index.js","webpack://Listener/./node_modules/parse-entities/decode-entity.browser.js","webpack://Listener/./node_modules/react-is/cjs/react-is.production.min.js","webpack://Listener/./node_modules/react-is/index.js","webpack://Listener/./node_modules/react-markdown/lib/ast-to-react.js","webpack://Listener/./node_modules/react-markdown/lib/get-definitions.js","webpack://Listener/./node_modules/react-markdown/lib/plugins/disallow-node.js","webpack://Listener/./node_modules/react-markdown/lib/plugins/naive-html.js","webpack://Listener/./node_modules/react-markdown/lib/react-markdown.js","webpack://Listener/./node_modules/react-markdown/lib/renderers.js","webpack://Listener/./node_modules/react-markdown/lib/symbols.js","webpack://Listener/./node_modules/react-markdown/lib/uri-transformer.js","webpack://Listener/./node_modules/react-markdown/lib/wrap-table-rows.js","webpack://Listener/./node_modules/remark-parse/index.js","webpack://Listener/./node_modules/remark-parse/node_modules/mdast-util-from-markdown/dist/index.js","webpack://Listener/./node_modules/remark-parse/node_modules/mdast-util-from-markdown/index.js","webpack://Listener/./node_modules/remark-parse/node_modules/mdast-util-to-string/index.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/character/ascii-alpha.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/character/ascii-alphanumeric.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/character/ascii-atext.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/character/ascii-control.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/character/ascii-digit.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/character/ascii-hex-digit.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/character/ascii-punctuation.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/character/markdown-line-ending-or-space.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/character/markdown-line-ending.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/character/markdown-space.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/character/unicode-punctuation.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/character/unicode-whitespace.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/constant/assign.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/constant/from-char-code.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/constant/has-own-property.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/constant/html-block-names.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/constant/html-raw-names.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/constant/splice.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/constant/unicode-punctuation-regex.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/constructs.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/initialize/content.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/initialize/document.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/initialize/flow.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/initialize/text.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/parse.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/postprocess.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/preprocess.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/tokenize/attention.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/tokenize/autolink.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/tokenize/block-quote.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/tokenize/character-escape.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/tokenize/character-reference.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/tokenize/code-fenced.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/tokenize/code-indented.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/tokenize/code-text.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/tokenize/content.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/tokenize/definition.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/tokenize/factory-destination.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/tokenize/factory-label.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/tokenize/factory-space.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/tokenize/factory-title.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/tokenize/factory-whitespace.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/tokenize/hard-break-escape.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/tokenize/heading-atx.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/tokenize/html-flow.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/tokenize/html-text.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/tokenize/label-end.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/tokenize/label-start-image.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/tokenize/label-start-link.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/tokenize/line-ending.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/tokenize/list.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/tokenize/partial-blank-line.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/tokenize/setext-underline.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/tokenize/thematic-break.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/util/chunked-push.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/util/chunked-splice.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/util/classify-character.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/util/combine-extensions.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/util/create-tokenizer.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/util/miniflat.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/util/move-point.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/util/normalize-identifier.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/util/prefix-size.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/util/regex-check.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/util/resolve-all.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/util/safe-from-int.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/util/serialize-chunks.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/util/shallow.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/util/size-chunks.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/util/slice-chunks.js","webpack://Listener/./node_modules/remark-parse/node_modules/micromark/dist/util/subtokenize.js","webpack://Listener/./node_modules/remark-parse/node_modules/unist-util-stringify-position/index.js","webpack://Listener/./node_modules/trough/index.js","webpack://Listener/./node_modules/trough/wrap.js","webpack://Listener/./node_modules/unified/index.js","webpack://Listener/./node_modules/unified/node_modules/is-plain-obj/index.js","webpack://Listener/./node_modules/unist-util-is/convert.js","webpack://Listener/./node_modules/unist-util-visit-parents/color.browser.js","webpack://Listener/./node_modules/unist-util-visit-parents/index.js","webpack://Listener/./node_modules/unist-util-visit/index.js","webpack://Listener/./node_modules/vfile/index.js","webpack://Listener/./node_modules/vfile/lib/core.js","webpack://Listener/./node_modules/vfile/lib/index.js","webpack://Listener/./node_modules/vfile/lib/minpath.browser.js","webpack://Listener/./node_modules/vfile/lib/minproc.browser.js","webpack://Listener/./node_modules/vfile/node_modules/unist-util-stringify-position/index.js","webpack://Listener/./node_modules/vfile/node_modules/vfile-message/index.js","webpack://Listener/./node_modules/xtend/immutable.js"],"sourcesContent":["'use strict';\n\nmodule.exports = bail;\nfunction bail(err) {\n  if (err) {\n    throw err;\n  }\n}","'use strict';\n\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar toStr = Object.prototype.toString;\nvar defineProperty = Object.defineProperty;\nvar gOPD = Object.getOwnPropertyDescriptor;\nvar isArray = function isArray(arr) {\n  if (typeof Array.isArray === 'function') {\n    return Array.isArray(arr);\n  }\n  return toStr.call(arr) === '[object Array]';\n};\nvar isPlainObject = function isPlainObject(obj) {\n  if (!obj || toStr.call(obj) !== '[object Object]') {\n    return false;\n  }\n  var hasOwnConstructor = hasOwn.call(obj, 'constructor');\n  var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf');\n  // Not own constructor property must be Object\n  if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {\n    return false;\n  }\n\n  // Own properties are enumerated firstly, so to speed up,\n  // if last one is own, then all properties are own.\n  var key;\n  for (key in obj) {/**/}\n  return 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  if (defineProperty && options.name === '__proto__') {\n    defineProperty(target, options.name, {\n      enumerable: true,\n      configurable: true,\n      value: options.newValue,\n      writable: true\n    });\n  } else {\n    target[options.name] = options.newValue;\n  }\n};\n\n// Return undefined instead of __proto__ if '__proto__' is not an own property\nvar getProperty = function getProperty(obj, name) {\n  if (name === '__proto__') {\n    if (!hasOwn.call(obj, name)) {\n      return void 0;\n    } else if (gOPD) {\n      // In early versions of node, obj['__proto__'] is buggy when obj has\n      // __proto__ as an own property. Object.getOwnPropertyDescriptor() works.\n      return gOPD(obj, name).value;\n    }\n  }\n  return obj[name];\n};\nmodule.exports = function extend() {\n  var options, name, src, copy, copyIsArray, clone;\n  var target = arguments[0];\n  var i = 1;\n  var length = arguments.length;\n  var deep = false;\n\n  // Handle a deep copy situation\n  if (typeof target === 'boolean') {\n    deep = target;\n    target = arguments[1] || {};\n    // skip the boolean and the target\n    i = 2;\n  }\n  if (target == null || typeof target !== 'object' && typeof target !== 'function') {\n    target = {};\n  }\n  for (; i < length; ++i) {\n    options = arguments[i];\n    // Only deal with non-null/undefined values\n    if (options != null) {\n      // Extend the base object\n      for (name in options) {\n        src = getProperty(target, name);\n        copy = getProperty(options, name);\n\n        // Prevent never-ending loop\n        if (target !== copy) {\n          // Recurse if we're merging plain objects or arrays\n          if (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {\n            if (copyIsArray) {\n              copyIsArray = false;\n              clone = src && isArray(src) ? src : [];\n            } else {\n              clone = src && isPlainObject(src) ? src : {};\n            }\n\n            // Never move original objects, clone them\n            setProperty(target, {\n              name: name,\n              newValue: extend(deep, clone, copy)\n            });\n\n            // Don't bring in undefined values\n          } else if (typeof copy !== 'undefined') {\n            setProperty(target, {\n              name: name,\n              newValue: copy\n            });\n          }\n        }\n      }\n    }\n  }\n\n  // Return the modified object\n  return target;\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 && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj);\n};","var visitWithParents = require('unist-util-visit-parents');\nfunction addListMetadata() {\n  return function (ast) {\n    visitWithParents(ast, 'list', function (listNode, parents) {\n      var depth = 0,\n        i,\n        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}\nmodule.exports = addListMetadata;","'use strict';\n\n/* Expose. */\nmodule.exports = visitParents;\n\n/* Visit. */\nfunction visitParents(tree, type, visitor) {\n  var stack = [];\n  if (typeof type === 'function') {\n    visitor = type;\n    type = null;\n  }\n  one(tree);\n\n  /* Visit a single node. */\n  function one(node) {\n    var result;\n    if (!type || node.type === type) {\n      result = visitor(node, stack.concat());\n    }\n    if (node.children && result !== false) {\n      return all(node.children, node);\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    stack.push(parent);\n    while (++index < length) {\n      child = children[index];\n      if (child && one(child) === false) {\n        return false;\n      }\n    }\n    stack.pop();\n    return true;\n  }\n}","'use strict';\n\n/* eslint-env browser */\nvar el;\nvar semicolon = 59; //  ';'\n\nmodule.exports = decodeEntity;\nfunction decodeEntity(characters) {\n  var entity = '&' + characters + ';';\n  var char;\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}","/** @license React v16.13.1\n * react-is.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar b = \"function\" === typeof Symbol && Symbol.for,\n  c = b ? Symbol.for(\"react.element\") : 60103,\n  d = b ? Symbol.for(\"react.portal\") : 60106,\n  e = b ? Symbol.for(\"react.fragment\") : 60107,\n  f = b ? Symbol.for(\"react.strict_mode\") : 60108,\n  g = b ? Symbol.for(\"react.profiler\") : 60114,\n  h = b ? Symbol.for(\"react.provider\") : 60109,\n  k = b ? Symbol.for(\"react.context\") : 60110,\n  l = b ? Symbol.for(\"react.async_mode\") : 60111,\n  m = b ? Symbol.for(\"react.concurrent_mode\") : 60111,\n  n = b ? Symbol.for(\"react.forward_ref\") : 60112,\n  p = b ? Symbol.for(\"react.suspense\") : 60113,\n  q = b ? Symbol.for(\"react.suspense_list\") : 60120,\n  r = b ? Symbol.for(\"react.memo\") : 60115,\n  t = b ? Symbol.for(\"react.lazy\") : 60116,\n  v = b ? Symbol.for(\"react.block\") : 60121,\n  w = b ? Symbol.for(\"react.fundamental\") : 60117,\n  x = b ? Symbol.for(\"react.responder\") : 60118,\n  y = b ? Symbol.for(\"react.scope\") : 60119;\nfunction z(a) {\n  if (\"object\" === typeof a && null !== a) {\n    var u = a.$$typeof;\n    switch (u) {\n      case c:\n        switch (a = a.type, a) {\n          case l:\n          case m:\n          case e:\n          case g:\n          case f:\n          case p:\n            return a;\n          default:\n            switch (a = a && a.$$typeof, a) {\n              case k:\n              case n:\n              case t:\n              case r:\n              case h:\n                return a;\n              default:\n                return u;\n            }\n        }\n      case d:\n        return u;\n    }\n  }\n}\nfunction A(a) {\n  return z(a) === m;\n}\nexports.AsyncMode = l;\nexports.ConcurrentMode = m;\nexports.ContextConsumer = k;\nexports.ContextProvider = h;\nexports.Element = c;\nexports.ForwardRef = n;\nexports.Fragment = e;\nexports.Lazy = t;\nexports.Memo = r;\nexports.Portal = d;\nexports.Profiler = g;\nexports.StrictMode = f;\nexports.Suspense = p;\nexports.isAsyncMode = function (a) {\n  return A(a) || z(a) === l;\n};\nexports.isConcurrentMode = A;\nexports.isContextConsumer = function (a) {\n  return z(a) === k;\n};\nexports.isContextProvider = function (a) {\n  return z(a) === h;\n};\nexports.isElement = function (a) {\n  return \"object\" === typeof a && null !== a && a.$$typeof === c;\n};\nexports.isForwardRef = function (a) {\n  return z(a) === n;\n};\nexports.isFragment = function (a) {\n  return z(a) === e;\n};\nexports.isLazy = function (a) {\n  return z(a) === t;\n};\nexports.isMemo = function (a) {\n  return z(a) === r;\n};\nexports.isPortal = function (a) {\n  return z(a) === d;\n};\nexports.isProfiler = function (a) {\n  return z(a) === g;\n};\nexports.isStrictMode = function (a) {\n  return z(a) === f;\n};\nexports.isSuspense = function (a) {\n  return z(a) === p;\n};\nexports.isValidElementType = function (a) {\n  return \"string\" === typeof a || \"function\" === typeof a || a === e || a === m || a === g || a === f || a === p || a === q || \"object\" === typeof a && null !== a && (a.$$typeof === t || a.$$typeof === r || a.$$typeof === h || a.$$typeof === k || a.$$typeof === n || a.$$typeof === w || a.$$typeof === x || a.$$typeof === y || a.$$typeof === v);\n};\nexports.typeOf = z;","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react-is.production.min.js');\n} else {\n  module.exports = require('./cjs/react-is.development.js');\n}","'use strict';\n\nvar React = require('react');\nvar xtend = require('xtend');\nvar ReactIs = require('react-is');\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  var pos = node.position.start;\n  var key = [node.type, pos.line, pos.column, index].join('-');\n  if (!ReactIs.isValidElementType(renderer)) {\n    throw new Error(\"Renderer for type `\".concat(node.type, \"` not defined or is not renderable\"));\n  }\n  var nodeProps = getNodeProps(node, key, options, renderer, parent, index);\n  return React.createElement(renderer, nodeProps, nodeProps.children || resolveChildren() || undefined);\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\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  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  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  var ref = node.identifier !== null && node.identifier !== undefined ? /* istanbul ignore next - plugins could inject an undefined reference. */\n  opts.definitions[node.identifier.toUpperCase()] || {} : null;\n  switch (node.type) {\n    case 'root':\n      assignDefined(props, {\n        className: opts.className\n      });\n      break;\n    case 'text':\n      props.nodeKey = key;\n      props.children = node.value;\n      break;\n    case 'heading':\n      props.level = node.depth;\n      break;\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    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    case 'definition':\n      assignDefined(props, {\n        identifier: node.identifier,\n        title: node.title,\n        url: node.url\n      });\n      break;\n    case 'code':\n      assignDefined(props, {\n        language: node.lang && node.lang.split(/\\s/, 1)[0]\n      });\n      break;\n    case 'inlineCode':\n      props.children = node.value;\n      props.inline = true;\n      break;\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    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    case 'linkReference':\n      assignDefined(props, xtend(ref, {\n        href: opts.transformLinkUri ? opts.transformLinkUri(ref.href) : ref.href\n      }));\n      break;\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    case 'table':\n    case 'tableHead':\n    case 'tableBody':\n      props.columnAlignment = node.align;\n      break;\n    case 'tableRow':\n      props.isHeader = parent.node.type === 'tableHead';\n      props.columnAlignment = parent.props.columnAlignment;\n      break;\n    case 'tableCell':\n      assignDefined(props, {\n        isHeader: parent.props.isHeader,\n        align: parent.props.columnAlignment[index]\n      });\n      break;\n    case 'virtualHtml':\n      props.tag = node.tag;\n      break;\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    case 'parsedHtml':\n      {\n        var parsedChildren;\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        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    default:\n      assignDefined(props, xtend(node, {\n        type: undefined,\n        position: undefined,\n        children: undefined\n      }));\n  }\n  if (!isSimpleRenderer && node.value) {\n    props.value = node.value;\n  }\n  if (!isSimpleRenderer) {\n    props.node = node;\n  }\n  return props;\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}\nfunction mergeNodeChildren(node, parsedChildren) {\n  var el = node.element;\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  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  return React.cloneElement(el, null);\n}\nfunction flattenPosition(pos) {\n  return [pos.start.line, ':', pos.start.column, '-', pos.end.line, ':', pos.end.column].map(String).join('');\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}\nfunction unwrapParagraphs(node) {\n  return node.children.reduce(function (array, child) {\n    return array.concat(child.type === 'paragraph' ? child.children : [child]);\n  }, []);\n}\nfunction listLoose(node) {\n  var children = node.children;\n  var loose = node.spread;\n  var index = -1;\n  while (!loose && ++index < children.length) {\n    loose = listItemLoose(children[index]);\n  }\n  return loose;\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}\nmodule.exports = astToReact;","'use strict';\n\nvar visit = require('unist-util-visit');\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');\nvar splice = [].splice;\nexports.ofType = function (types, mode) {\n  return ifNotMatch(allow, mode);\n  function allow(node, index, parent) {\n    return !types.includes(node.type);\n  }\n};\nexports.ifNotMatch = ifNotMatch;\nfunction ifNotMatch(allow, mode) {\n  return transform;\n  function transform(tree) {\n    visit(tree, filter);\n    return tree;\n  } // eslint-disable-next-line consistent-return\n\n  function filter(node, index, parent) {\n    if (parent && !allow(node, index, parent)) {\n      var parameters = [index, 1];\n      if (mode === 'unwrap' && node.children) {\n        parameters = parameters.concat(node.children);\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');\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*>$/;\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    var selfClosing = getSelfClosing(node);\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    var current = getSimpleTag(node, parent);\n    if (!current) {\n      return true;\n    }\n    var matching = findAndPull(open, current.tag);\n    if (matching) {\n      parent.children.splice(index, 0, virtual(current, matching, parent));\n    } else if (!current.opening) {\n      open.push(current);\n    }\n    return true;\n  }, true // Iterate in reverse\n  );\n\n  return tree;\n};\nfunction findAndPull(open, matchingTag) {\n  var i = open.length;\n  while (i--) {\n    if (open[i].tag === matchingTag) {\n      return open.splice(i, 1)[0];\n    }\n  }\n  return false;\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}\nfunction getSelfClosing(node) {\n  var match = node.value.match(selfClosingRe);\n  return match ? match[1] : false;\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');\nvar unified = require('unified');\nvar parse = require('remark-parse');\nvar PropTypes = require('prop-types');\nvar addListMetadata = require('mdast-add-list-metadata');\nvar naiveHtml = require('./plugins/naive-html');\nvar disallowNode = require('./plugins/disallow-node');\nvar astToReact = require('./ast-to-react');\nvar wrapTableRows = require('./wrap-table-rows');\nvar getDefinitions = require('./get-definitions');\nvar uriTransformer = require('./uri-transformer');\nvar defaultRenderers = require('./renderers');\nvar symbols = require('./symbols');\nvar allTypes = Object.keys(defaultRenderers);\nvar ReactMarkdown = function ReactMarkdown(props) {\n  // To do in next major: remove `source`.\n  var src = props.source || props.children || '';\n  if (props.allowedTypes && props.disallowedTypes) {\n    throw new Error('Only one of `allowedTypes` and `disallowedTypes` should be defined');\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};\nfunction determineAstToReactTransforms(props) {\n  var transforms = [wrapTableRows, addListMetadata()];\n  var disallowedTypes = props.disallowedTypes;\n  if (props.allowedTypes) {\n    disallowedTypes = allTypes.filter(function (type) {\n      return type !== 'root' && props.allowedTypes.indexOf(type) === -1;\n    });\n  }\n  var removalMethod = props.unwrapDisallowed ? 'unwrap' : 'remove';\n  if (disallowedTypes && disallowedTypes.length > 0) {\n    transforms.push(disallowNode.ofType(disallowedTypes, removalMethod));\n  }\n  if (props.allowNode) {\n    transforms.push(disallowNode.ifNotMatch(props.allowNode, removalMethod));\n  } // To do in next major: remove `escapeHtml`.\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  if (renderHtml && !hasHtmlParser) {\n    transforms.push(naiveHtml);\n  }\n  if (props.astPlugins) {\n    transforms = transforms.concat(props.astPlugins);\n  } // Add the final transform to turn everything into React.\n\n  transforms.push(astToReact);\n  return transforms;\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');\nvar React = require('react');\n/* istanbul ignore next - Don’t crash on old React. */\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};\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}\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}\nfunction SimpleRenderer(tag, props) {\n  return createElement(tag, getCoreProps(props), props.children);\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}\nfunction Heading(props) {\n  return createElement(\"h\".concat(props.level), getCoreProps(props), props.children);\n}\nfunction List(props) {\n  var attrs = getCoreProps(props);\n  if (props.start !== null && props.start !== 1 && props.start !== undefined) {\n    attrs.start = props.start.toString();\n  }\n  return createElement(props.ordered ? 'ol' : 'ul', attrs, props.children);\n}\nfunction ListItem(props) {\n  var checkbox = null;\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  return createElement('li', getCoreProps(props), checkbox, props.children);\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}\nfunction InlineCode(props) {\n  return createElement('code', getCoreProps(props), props.children);\n}\nfunction Html(props) {\n  if (props.skipHtml) {\n    return null;\n  }\n  var dangerous = props.allowDangerousHtml || props.escapeHtml === false;\n  var tag = props.isBlock ? 'div' : 'span';\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  var nodeProps = {\n    dangerouslySetInnerHTML: {\n      __html: props.value\n    }\n  };\n  return createElement(tag, nodeProps);\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}\nfunction VirtualHtml(props) {\n  return createElement(props.tag, getCoreProps(props), props.children);\n}\nfunction NullRenderer() {\n  return null;\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'];\nmodule.exports = function uriTransformer(uri) {\n  var url = (uri || '').trim();\n  var first = url.charAt(0);\n  if (first === '#' || first === '/') {\n    return url;\n  }\n  var colon = url.indexOf(':');\n  if (colon === -1) {\n    return url;\n  }\n  var length = protocols.length;\n  var index = -1;\n  while (++index < length) {\n    var protocol = protocols[index];\n    if (colon === protocol.length && url.slice(0, protocol.length).toLowerCase() === protocol) {\n      return url;\n    }\n  }\n  index = url.indexOf('?');\n  if (index !== -1 && colon > index) {\n    return url;\n  }\n  index = url.indexOf('#');\n  if (index !== -1 && colon > index) {\n    return url;\n  } // eslint-disable-next-line no-script-url\n\n  return 'javascript:void(0)';\n};","'use strict';\n\nvar visit = require('unist-util-visit');\nmodule.exports = function (node) {\n  visit(node, 'table', wrap);\n  return node;\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  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 = parse;\nvar fromMarkdown = require('mdast-util-from-markdown');\nfunction parse(options) {\n  var self = this;\n  this.Parser = parse;\n  function parse(doc) {\n    return fromMarkdown(doc, 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}","'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');\nfunction fromMarkdown(value, encoding, options) {\n  if (typeof encoding !== 'string') {\n    options = encoding;\n    encoding = undefined;\n  }\n  return compiler(options)(postprocess(parser(options).document().write(preprocessor()(value, encoding, true))));\n}\n\n// Note this compiler only understand complete buffering, not streaming.\nfunction compiler(options) {\n  var settings = options || {};\n  var config = configure({\n    transforms: [],\n    canContainEols: ['emphasis', 'fragment', 'heading', 'paragraph', 'strong'],\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    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  }, settings.mdastExtensions || []);\n  var data = {};\n  return compile;\n  function compile(events) {\n    var tree = {\n      type: 'root',\n      children: []\n    };\n    var stack = [tree];\n    var tokenStack = [];\n    var listStack = [];\n    var index = -1;\n    var handler;\n    var listStart;\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    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 (events[index][1].type === 'listOrdered' || events[index][1].type === 'listUnordered') {\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    index = -1;\n    while (++index < events.length) {\n      handler = config[events[index][0]];\n      if (own.call(handler, events[index][1].type)) {\n        handler[events[index][1].type].call(assign({\n          sliceSerialize: events[index][2].sliceSerialize\n        }, context), events[index][1]);\n      }\n    }\n    if (tokenStack.length) {\n      throw new Error('Cannot close document, a token (`' + tokenStack[tokenStack.length - 1].type + '`, ' + stringifyPosition({\n        start: tokenStack[tokenStack.length - 1].start,\n        end: tokenStack[tokenStack.length - 1].end\n      }) + ') is still open');\n    }\n\n    // Figure out `root` position.\n    tree.position = {\n      start: point(events.length ? events[0][1].start : {\n        line: 1,\n        column: 1,\n        offset: 0\n      }),\n      end: point(events.length ? events[events.length - 2][1].end : {\n        line: 1,\n        column: 1,\n        offset: 0\n      })\n    };\n    index = -1;\n    while (++index < config.transforms.length) {\n      tree = config.transforms[index](tree) || tree;\n    }\n    return tree;\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    while (++index <= length) {\n      event = events[index];\n      if (event[1].type === 'listUnordered' || event[1].type === 'listOrdered' || event[1].type === 'blockQuote') {\n        if (event[0] === 'enter') {\n          containerBalance++;\n        } else {\n          containerBalance--;\n        }\n        atMarker = undefined;\n      } else if (event[1].type === 'lineEndingBlank') {\n        if (event[0] === 'enter') {\n          if (listItem && !atMarker && !containerBalance && !firstBlankLineIndex) {\n            firstBlankLineIndex = index;\n          }\n          atMarker = undefined;\n        }\n      } else if (event[1].type === 'linePrefix' || event[1].type === 'listItemValue' || event[1].type === 'listItemMarker' || event[1].type === 'listItemPrefix' || event[1].type === 'listItemPrefixWhitespace') {\n        // Empty.\n      } else {\n        atMarker = undefined;\n      }\n      if (!containerBalance && event[0] === 'enter' && event[1].type === 'listItemPrefix' || containerBalance === -1 && event[0] === 'exit' && (event[1].type === 'listUnordered' || event[1].type === 'listOrdered')) {\n        if (listItem) {\n          tailIndex = index;\n          lineIndex = undefined;\n          while (tailIndex--) {\n            tailEvent = events[tailIndex];\n            if (tailEvent[1].type === 'lineEnding' || tailEvent[1].type === 'lineEndingBlank') {\n              if (tailEvent[0] === 'exit') continue;\n              if (lineIndex) {\n                events[lineIndex][1].type = 'lineEndingBlank';\n                listSpread = true;\n              }\n              tailEvent[1].type = 'lineEnding';\n              lineIndex = tailIndex;\n            } else if (tailEvent[1].type === 'linePrefix' || tailEvent[1].type === 'blockQuotePrefix' || tailEvent[1].type === 'blockQuotePrefixWhitespace' || tailEvent[1].type === 'blockQuoteMarker' || tailEvent[1].type === 'listItemIndent') {\n              // Empty\n            } else {\n              break;\n            }\n          }\n          if (firstBlankLineIndex && (!lineIndex || firstBlankLineIndex < lineIndex)) {\n            listItem._spread = true;\n          }\n\n          // Fix position.\n          listItem.end = point(lineIndex ? events[lineIndex][1].start : event[1].end);\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          events.splice(index, 0, ['enter', listItem, event[2]]);\n          index++;\n          length++;\n          firstBlankLineIndex = undefined;\n          atMarker = true;\n        }\n      }\n    }\n    events[start][1]._spread = listSpread;\n    return length;\n  }\n  function setData(key, value) {\n    data[key] = value;\n  }\n  function getData(key) {\n    return data[key];\n  }\n  function point(d) {\n    return {\n      line: d.line,\n      column: d.column,\n      offset: d.offset\n    };\n  }\n  function opener(create, and) {\n    return open;\n    function open(token) {\n      enter.call(this, create(token), token);\n      if (and) and.call(this, token);\n    }\n  }\n  function buffer() {\n    this.stack.push({\n      type: 'fragment',\n      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 = {\n      start: point(token.start)\n    };\n    return node;\n  }\n  function closer(and) {\n    return close;\n    function close(token) {\n      if (and) and.call(this, token);\n      exit.call(this, token);\n    }\n  }\n  function exit(token) {\n    var node = this.stack.pop();\n    var open = this.tokenStack.pop();\n    if (!open) {\n      throw new Error('Cannot close `' + token.type + '` (' + stringifyPosition({\n        start: token.start,\n        end: token.end\n      }) + '): it’s not open');\n    } else if (open.type !== token.type) {\n      throw new Error('Cannot close `' + token.type + '` (' + stringifyPosition({\n        start: token.start,\n        end: token.end\n      }) + '): a different token (`' + open.type + '`, ' + stringifyPosition({\n        start: open.start,\n        end: open.end\n      }) + ') is open');\n    }\n    node.position.end = point(token.end);\n    return node;\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  function onenterlistitemvalue(token) {\n    if (getData('expectingFirstListItemValue')) {\n      this.stack[this.stack.length - 2].start = parseInt(this.sliceSerialize(token), 10);\n      setData('expectingFirstListItemValue');\n    }\n  }\n  function onexitcodefencedfenceinfo() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].lang = data;\n  }\n  function onexitcodefencedfencemeta() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].meta = data;\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  function onexitcodefenced() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].value = data.replace(/^(\\r?\\n|\\r)|(\\r?\\n|\\r)$/g, '');\n    setData('flowCodeInside');\n  }\n  function onexitcodeindented() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].value = data;\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(this.sliceSerialize(token)).toLowerCase();\n  }\n  function onexitdefinitiontitlestring() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].title = data;\n  }\n  function onexitdefinitiondestinationstring() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].url = data;\n  }\n  function onexitatxheadingsequence(token) {\n    if (!this.stack[this.stack.length - 1].depth) {\n      this.stack[this.stack.length - 1].depth = this.sliceSerialize(token).length;\n    }\n  }\n  function onexitsetextheadingtext() {\n    setData('setextHeadingSlurpLineEnding', true);\n  }\n  function onexitsetextheadinglinesequence(token) {\n    this.stack[this.stack.length - 1].depth = this.sliceSerialize(token).charCodeAt(0) === 61 ? 1 : 2;\n  }\n  function onexitsetextheading() {\n    setData('setextHeadingSlurpLineEnding');\n  }\n  function onenterdata(token) {\n    var siblings = this.stack[this.stack.length - 1].children;\n    var tail = siblings[siblings.length - 1];\n    if (!tail || tail.type !== 'text') {\n      // Add a new text node.\n      tail = text();\n      tail.position = {\n        start: point(token.start)\n      };\n      this.stack[this.stack.length - 1].children.push(tail);\n    }\n    this.stack.push(tail);\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  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(token.end);\n      setData('atHardBreak');\n      return;\n    }\n    if (!getData('setextHeadingSlurpLineEnding') && config.canContainEols.indexOf(context.type) > -1) {\n      onenterdata.call(this, token);\n      onexitdata.call(this, token);\n    }\n  }\n  function onexithardbreak() {\n    setData('atHardBreak', true);\n  }\n  function onexithtmlflow() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].value = data;\n  }\n  function onexithtmltext() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].value = data;\n  }\n  function onexitcodetext() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].value = data;\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    setData('referenceType');\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    setData('referenceType');\n  }\n  function onexitlabeltext(token) {\n    this.stack[this.stack.length - 2].identifier = normalizeIdentifier(this.sliceSerialize(token)).toLowerCase();\n  }\n  function onexitlabel() {\n    var fragment = this.stack[this.stack.length - 1];\n    var value = this.resume();\n    this.stack[this.stack.length - 1].label = value;\n\n    // Assume a reference.\n    setData('inReference', true);\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  function onexitresourcedestinationstring() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].url = data;\n  }\n  function onexitresourcetitlestring() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].title = data;\n  }\n  function onexitresource() {\n    setData('inReference');\n  }\n  function onenterreference() {\n    setData('referenceType', 'collapsed');\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(this.sliceSerialize(token)).toLowerCase();\n    setData('referenceType', 'full');\n  }\n  function onexitcharacterreferencemarker(token) {\n    setData('characterReferenceType', token.type);\n  }\n  function onexitcharacterreferencevalue(token) {\n    var data = this.sliceSerialize(token);\n    var type = getData('characterReferenceType');\n    var value;\n    var tail;\n    if (type) {\n      value = safeFromInt(data, type === 'characterReferenceMarkerNumeric' ? 10 : 16);\n      setData('characterReferenceType');\n    } else {\n      value = decode(data);\n    }\n    tail = this.stack.pop();\n    tail.value += value;\n    tail.position.end = point(token.end);\n  }\n  function onexitautolinkprotocol(token) {\n    onexitdata.call(this, token);\n    this.stack[this.stack.length - 1].url = this.sliceSerialize(token);\n  }\n  function onexitautolinkemail(token) {\n    onexitdata.call(this, token);\n    this.stack[this.stack.length - 1].url = 'mailto:' + this.sliceSerialize(token);\n  }\n\n  //\n  // Creaters.\n  //\n\n  function blockQuote() {\n    return {\n      type: 'blockquote',\n      children: []\n    };\n  }\n  function codeFlow() {\n    return {\n      type: 'code',\n      lang: null,\n      meta: null,\n      value: ''\n    };\n  }\n  function codeText() {\n    return {\n      type: 'inlineCode',\n      value: ''\n    };\n  }\n  function definition() {\n    return {\n      type: 'definition',\n      identifier: '',\n      label: null,\n      title: null,\n      url: ''\n    };\n  }\n  function emphasis() {\n    return {\n      type: 'emphasis',\n      children: []\n    };\n  }\n  function heading() {\n    return {\n      type: 'heading',\n      depth: undefined,\n      children: []\n    };\n  }\n  function hardBreak() {\n    return {\n      type: 'break'\n    };\n  }\n  function html() {\n    return {\n      type: 'html',\n      value: ''\n    };\n  }\n  function image() {\n    return {\n      type: 'image',\n      title: null,\n      url: '',\n      alt: null\n    };\n  }\n  function link() {\n    return {\n      type: 'link',\n      title: null,\n      url: '',\n      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  function listItem(token) {\n    return {\n      type: 'listItem',\n      spread: token._spread,\n      checked: null,\n      children: []\n    };\n  }\n  function paragraph() {\n    return {\n      type: 'paragraph',\n      children: []\n    };\n  }\n  function strong() {\n    return {\n      type: 'strong',\n      children: []\n    };\n  }\n  function text() {\n    return {\n      type: 'text',\n      value: ''\n    };\n  }\n  function thematicBreak() {\n    return {\n      type: 'thematicBreak'\n    };\n  }\n}\nfunction configure(config, extensions) {\n  var index = -1;\n  while (++index < extensions.length) {\n    extension(config, extensions[index]);\n  }\n  return config;\n}\nfunction extension(config, extension) {\n  var key;\n  var left;\n  for (key in extension) {\n    left = own.call(config, key) ? config[key] : config[key] = {};\n    if (key === 'canContainEols' || key === 'transforms') {\n      config[key] = [].concat(left, extension[key]);\n    } else {\n      Object.assign(left, extension[key]);\n    }\n  }\n}","'use strict';\n\nmodule.exports = require('./dist');","'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 node && (node.value || node.alt || node.title || 'children' in node && all(node.children) || 'length' in node && all(node)) || '';\n}\nfunction all(values) {\n  var result = [];\n  var index = -1;\n  while (++index < values.length) {\n    result[index] = toString(values[index]);\n  }\n  return result.join('');\n}","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\nvar asciiAlpha = regexCheck(/[A-Za-z]/);\nmodule.exports = asciiAlpha;","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\nvar asciiAlphanumeric = regexCheck(/[\\dA-Za-z]/);\nmodule.exports = asciiAlphanumeric;","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\nvar asciiAtext = regexCheck(/[#-'*+\\--9=?A-Z^-~]/);\nmodule.exports = asciiAtext;","'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}\nmodule.exports = asciiControl;","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\nvar asciiDigit = regexCheck(/\\d/);\nmodule.exports = asciiDigit;","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\nvar asciiHexDigit = regexCheck(/[\\dA-Fa-f]/);\nmodule.exports = asciiHexDigit;","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\nvar asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/);\nmodule.exports = asciiPunctuation;","'use strict';\n\nfunction markdownLineEndingOrSpace(code) {\n  return code < 0 || code === 32;\n}\nmodule.exports = markdownLineEndingOrSpace;","'use strict';\n\nfunction markdownLineEnding(code) {\n  return code < -2;\n}\nmodule.exports = markdownLineEnding;","'use strict';\n\nfunction markdownSpace(code) {\n  return code === -2 || code === -1 || code === 32;\n}\nmodule.exports = markdownSpace;","'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);\nmodule.exports = unicodePunctuation;","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\nvar unicodeWhitespace = regexCheck(/\\s/);\nmodule.exports = unicodeWhitespace;","'use strict';\n\nvar assign = Object.assign;\nmodule.exports = assign;","'use strict';\n\nvar fromCharCode = String.fromCharCode;\nmodule.exports = fromCharCode;","'use strict';\n\nvar own = {}.hasOwnProperty;\nmodule.exports = own;","'use strict';\n\n// This module is copied from <https://spec.commonmark.org/0.29/#html-blocks>.\nvar basics = ['address', 'article', 'aside', 'base', 'basefont', 'blockquote', 'body', 'caption', 'center', 'col', 'colgroup', 'dd', 'details', 'dialog', 'dir', 'div', 'dl', 'dt', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'frame', 'frameset', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hr', 'html', 'iframe', 'legend', 'li', 'link', 'main', 'menu', 'menuitem', 'nav', 'noframes', 'ol', 'optgroup', 'option', 'p', 'param', 'section', 'source', 'summary', 'table', 'tbody', 'td', 'tfoot', 'th', 'thead', 'title', 'tr', 'track', 'ul'];\nmodule.exports = basics;","'use strict';\n\n// This module is copied from <https://spec.commonmark.org/0.29/#html-blocks>.\nvar raws = ['pre', 'script', 'style', 'textarea'];\nmodule.exports = raws;","'use strict';\n\nvar splice = [].splice;\nmodule.exports = splice;","'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]/;\nmodule.exports = unicodePunctuation;","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  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');\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};\n\nvar contentInitial = {\n  91: definition // Left square bracket\n};\n\nvar flowInitial = {\n  '-2': codeIndented,\n  // Horizontal tab\n  '-1': codeIndented,\n  // Virtual space\n  32: codeIndented // Space\n};\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};\n\nvar string = {\n  38: characterReference,\n  // Ampersand\n  92: characterEscape // Backslash\n};\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};\n\nvar insideSpan = {\n  null: [attention, text$1.resolver]\n};\nvar disable = {\n  null: []\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;","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\nvar factorySpace = require('../tokenize/factory-space.js');\nvar tokenize = initializeContent;\nfunction initializeContent(effects) {\n  var contentStart = effects.attempt(this.parser.constructs.contentInitial, afterContentStartConstruct, paragraphInitial);\n  var previous;\n  return contentStart;\n  function afterContentStartConstruct(code) {\n    if (code === null) {\n      effects.consume(code);\n      return;\n    }\n    effects.enter('lineEnding');\n    effects.consume(code);\n    effects.exit('lineEnding');\n    return factorySpace(effects, contentStart, 'linePrefix');\n  }\n  function paragraphInitial(code) {\n    effects.enter('paragraph');\n    return lineStart(code);\n  }\n  function lineStart(code) {\n    var token = effects.enter('chunkText', {\n      contentType: 'text',\n      previous: previous\n    });\n    if (previous) {\n      previous.next = token;\n    }\n    previous = token;\n    return data(code);\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    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}\nexports.tokenize = tokenize;","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  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');\nvar tokenize = initializeDocument;\nvar containerConstruct = {\n  tokenize: tokenizeContainer\n};\nvar lazyFlowConstruct = {\n  tokenize: tokenizeLazyFlow\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  function start(code) {\n    if (continued < stack.length) {\n      self.containerState = stack[continued][1];\n      return effects.attempt(stack[continued][0].continuation, documentContinue, documentContinued)(code);\n    }\n    return documentContinued(code);\n  }\n  function documentContinue(code) {\n    continued++;\n    return start(code);\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    self.interrupt = childFlow && childFlow.currentConstruct && childFlow.currentConstruct.interruptible;\n    self.containerState = {};\n    return effects.attempt(containerConstruct, containerContinue, flowStart)(code);\n  }\n  function containerContinue(code) {\n    stack.push([self.currentConstruct, self.containerState]);\n    self.containerState = undefined;\n    return documentContinued(code);\n  }\n  function flowStart(code) {\n    if (code === null) {\n      exitContainers(0, true);\n      effects.consume(code);\n      return;\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  function flowContinue(code) {\n    if (code === null) {\n      continueFlow(effects.exit('chunkFlow'));\n      return flowStart(code);\n    }\n    if (markdownLineEnding(code)) {\n      effects.consume(code);\n      continueFlow(effects.exit('chunkFlow'));\n      return effects.check(inspectConstruct, documentAfterPeek);\n    }\n    effects.consume(code);\n    return flowContinue;\n  }\n  function documentAfterPeek(code) {\n    exitContainers(inspectResult.continued, inspectResult && inspectResult.flowEnd);\n    continued = 0;\n    return start(code);\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  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    stack.length = size;\n  }\n  function tokenizeInspect(effects, ok) {\n    var subcontinued = 0;\n    inspectResult = {};\n    return inspectStart;\n    function inspectStart(code) {\n      if (subcontinued < stack.length) {\n        self.containerState = stack[subcontinued][1];\n        return effects.attempt(stack[subcontinued][0].continuation, inspectContinue, inspectLess)(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      self.interrupt = childFlow.currentConstruct && childFlow.currentConstruct.interruptible;\n      self.containerState = {};\n      return effects.attempt(containerConstruct, inspectFlowEnd, inspectDone)(code);\n    }\n    function inspectContinue(code) {\n      subcontinued++;\n      return self.containerState._closeFlow ? inspectFlowEnd(code) : inspectStart(code);\n    }\n    function inspectLess(code) {\n      if (childFlow.currentConstruct && childFlow.currentConstruct.lazy) {\n        // Maybe another container?\n        self.containerState = {};\n        return effects.attempt(containerConstruct, inspectFlowEnd,\n        // Maybe flow, or a blank line?\n        effects.attempt(lazyFlowConstruct, inspectFlowEnd, effects.check(partialBlankLine, inspectFlowEnd, inspectLazy)))(code);\n      } // Otherwise we’re interrupting.\n\n      return inspectFlowEnd(code);\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    function inspectDone(code) {\n      inspectResult.continued = subcontinued;\n      self.interrupt = self.containerState = undefined;\n      return ok(code);\n    }\n  }\n}\nfunction tokenizeContainer(effects, ok, nok) {\n  return factorySpace(effects, effects.attempt(this.parser.constructs.document, ok, nok), 'linePrefix', this.parser.constructs.disable.null.indexOf('codeIndented') > -1 ? undefined : 4);\n}\nfunction tokenizeLazyFlow(effects, ok, nok) {\n  return factorySpace(effects, effects.lazy(this.parser.constructs.flow, ok, nok), 'linePrefix', this.parser.constructs.disable.null.indexOf('codeIndented') > -1 ? undefined : 4);\n}\nexports.tokenize = tokenize;","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\nvar content = require('../tokenize/content.js');\nvar factorySpace = require('../tokenize/factory-space.js');\nvar partialBlankLine = require('../tokenize/partial-blank-line.js');\nvar tokenize = initializeFlow;\nfunction initializeFlow(effects) {\n  var self = this;\n  var initial = effects.attempt(\n  // Try to parse a blank line.\n  partialBlankLine, atBlankEnding,\n  // Try to parse initial flow (essentially, only code).\n  effects.attempt(this.parser.constructs.flowInitial, afterConstruct, factorySpace(effects, effects.attempt(this.parser.constructs.flow, afterConstruct, effects.attempt(content, afterConstruct)), 'linePrefix')));\n  return initial;\n  function atBlankEnding(code) {\n    if (code === null) {\n      effects.consume(code);\n      return;\n    }\n    effects.enter('lineEndingBlank');\n    effects.consume(code);\n    effects.exit('lineEndingBlank');\n    self.currentConstruct = undefined;\n    return initial;\n  }\n  function afterConstruct(code) {\n    if (code === null) {\n      effects.consume(code);\n      return;\n    }\n    effects.enter('lineEnding');\n    effects.consume(code);\n    effects.exit('lineEnding');\n    self.currentConstruct = undefined;\n    return initial;\n  }\n}\nexports.tokenize = tokenize;","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\nvar assign = require('../constant/assign.js');\nvar shallow = require('../util/shallow.js');\nvar text = initializeFactory('text');\nvar string = initializeFactory('string');\nvar resolver = {\n  resolveAll: createResolver()\n};\nfunction initializeFactory(field) {\n  return {\n    tokenize: initializeText,\n    resolveAll: createResolver(field === 'text' ? resolveAllLineSuffixes : undefined)\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    function start(code) {\n      return atBreak(code) ? text(code) : notText(code);\n    }\n    function notText(code) {\n      if (code === null) {\n        effects.consume(code);\n        return;\n      }\n      effects.enter('data');\n      effects.consume(code);\n      return data;\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    function atBreak(code) {\n      var list = constructs[code];\n      var index = -1;\n      if (code === null) {\n        return true;\n      }\n      if (list) {\n        while (++index < list.length) {\n          if (!list[index].previous || list[index].previous.call(self, self.previous)) {\n            return true;\n          }\n        }\n      }\n    }\n  }\n}\nfunction createResolver(extraResolver) {\n  return resolveAllText;\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        enter = undefined;\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  while (++eventIndex <= events.length) {\n    if ((eventIndex === events.length || events[eventIndex][1].type === 'lineEnding') && events[eventIndex - 1][1].type === 'data') {\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      while (index--) {\n        chunk = chunks[index];\n        if (typeof chunk === 'string') {\n          bufferIndex = chunk.length;\n          while (chunk.charCodeAt(bufferIndex - 1) === 32) {\n            size++;\n            bufferIndex--;\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) ;else {\n          // Replacement character, exit.\n          index++;\n          break;\n        }\n      }\n      if (size) {\n        token = {\n          type: eventIndex === events.length || tabs || size < 2 ? 'lineSuffix' : '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 ? bufferIndex : data.start._bufferIndex + bufferIndex\n          },\n          end: shallow(data.end)\n        };\n        data.end = shallow(token.start);\n        if (data.start.offset === data.end.offset) {\n          assign(data, token);\n        } else {\n          events.splice(eventIndex, 0, ['enter', token, context], ['exit', token, context]);\n          eventIndex += 2;\n        }\n      }\n      eventIndex++;\n    }\n  }\n  return events;\n}\nexports.resolver = resolver;\nexports.string = string;\nexports.text = text;","'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');\nfunction parse(options) {\n  var settings = options || {};\n  var parser = {\n    defined: [],\n    constructs: combineExtensions([constructs].concat(miniflat(settings.extensions))),\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  function create(initializer) {\n    return creator;\n    function creator(from) {\n      return createTokenizer(parser, initializer, from);\n    }\n  }\n}\nmodule.exports = parse;","'use strict';\n\nvar subtokenize = require('./util/subtokenize.js');\nfunction postprocess(events) {\n  while (!subtokenize(events)) {\n    // Empty\n  }\n  return events;\n}\nmodule.exports = postprocess;","'use strict';\n\nvar search = /[\\0\\t\\n\\r]/g;\nfunction preprocess() {\n  var start = true;\n  var column = 1;\n  var buffer = '';\n  var atCarriageReturn;\n  return preprocessor;\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    if (start) {\n      if (value.charCodeAt(0) === 65279) {\n        startPosition++;\n      }\n      start = undefined;\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      if (!match) {\n        buffer = value.slice(startPosition);\n        break;\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        if (startPosition < endPosition) {\n          chunks.push(value.slice(startPosition, endPosition));\n          column += endPosition - startPosition;\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          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      startPosition = endPosition + 1;\n    }\n    if (end) {\n      if (atCarriageReturn) chunks.push(-5);\n      if (buffer) chunks.push(buffer);\n      chunks.push(null);\n    }\n    return chunks;\n  }\n}\nmodule.exports = preprocess;","'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');\nvar attention = {\n  name: 'attention',\n  tokenize: tokenizeAttention,\n  resolveAll: resolveAllAttention\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 (events[index][0] === 'enter' && events[index][1].type === 'attentionSequence' && events[index][1]._close) {\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 (events[open][0] === 'exit' && events[open][1].type === 'attentionSequence' && events[open][1]._open &&\n        // If the markers are the same:\n        context.sliceSerialize(events[open][1]).charCodeAt(0) === context.sliceSerialize(events[index][1]).charCodeAt(0)) {\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 ((events[open][1]._close || events[index][1]._open) && (events[index][1].end.offset - events[index][1].start.offset) % 3 && !((events[open][1].end.offset - events[open][1].start.offset + events[index][1].end.offset - events[index][1].start.offset) % 3)) {\n            continue;\n          } // Number of markers to use from the sequence.\n\n          use = events[open][1].end.offset - events[open][1].start.offset > 1 && events[index][1].end.offset - events[index][1].start.offset > 1 ? 2 : 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, [['enter', events[open][1], context], ['exit', events[open][1], context]]);\n          } // Opening.\n\n          nextEvents = chunkedPush(nextEvents, [['enter', group, context], ['enter', openingSequence, context], ['exit', openingSequence, context], ['enter', text, context]]); // Between.\n\n          nextEvents = chunkedPush(nextEvents, resolveAll(context.parser.constructs.insideSpan.null, events.slice(open + 1, index), context)); // Closing.\n\n          nextEvents = chunkedPush(nextEvents, [['exit', text, context], ['enter', closingSequence, context], ['exit', closingSequence, context], ['exit', group, context]]); // 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, [['enter', events[index][1], context], ['exit', events[index][1], context]]);\n          } else {\n            offset = 0;\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  while (++index < events.length) {\n    if (events[index][1].type === 'attentionSequence') {\n      events[index][1].type = 'data';\n    }\n  }\n  return events;\n}\nfunction tokenizeAttention(effects, ok) {\n  var before = classifyCharacter(this.previous);\n  var marker;\n  return start;\n  function start(code) {\n    effects.enter('attentionSequence');\n    marker = code;\n    return sequence(code);\n  }\n  function sequence(code) {\n    var token;\n    var after;\n    var open;\n    var close;\n    if (code === marker) {\n      effects.consume(code);\n      return sequence;\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}\nmodule.exports = attention;","'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');\nvar autolink = {\n  name: 'autolink',\n  tokenize: tokenizeAutolink\n};\nfunction tokenizeAutolink(effects, ok, nok) {\n  var size = 1;\n  return start;\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  function open(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return schemeOrEmailAtext;\n    }\n    return asciiAtext(code) ? emailAtext(code) : nok(code);\n  }\n  function schemeOrEmailAtext(code) {\n    return code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code) ? schemeInsideOrEmailAtext(code) : emailAtext(code);\n  }\n  function schemeInsideOrEmailAtext(code) {\n    if (code === 58) {\n      effects.consume(code);\n      return urlInside;\n    }\n    if ((code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) && size++ < 32) {\n      effects.consume(code);\n      return schemeInsideOrEmailAtext;\n    }\n    return emailAtext(code);\n  }\n  function urlInside(code) {\n    if (code === 62) {\n      effects.exit('autolinkProtocol');\n      return end(code);\n    }\n    if (code === 32 || code === 60 || asciiControl(code)) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return urlInside;\n  }\n  function emailAtext(code) {\n    if (code === 64) {\n      effects.consume(code);\n      size = 0;\n      return emailAtSignOrDot;\n    }\n    if (asciiAtext(code)) {\n      effects.consume(code);\n      return emailAtext;\n    }\n    return nok(code);\n  }\n  function emailAtSignOrDot(code) {\n    return asciiAlphanumeric(code) ? emailLabel(code) : nok(code);\n  }\n  function emailLabel(code) {\n    if (code === 46) {\n      effects.consume(code);\n      size = 0;\n      return emailAtSignOrDot;\n    }\n    if (code === 62) {\n      // Exit, then change the type.\n      effects.exit('autolinkProtocol').type = 'autolinkEmail';\n      return end(code);\n    }\n    return emailValue(code);\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    return nok(code);\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}\nmodule.exports = autolink;","'use strict';\n\nvar markdownSpace = require('../character/markdown-space.js');\nvar factorySpace = require('./factory-space.js');\nvar blockQuote = {\n  name: 'blockQuote',\n  tokenize: tokenizeBlockQuoteStart,\n  continuation: {\n    tokenize: tokenizeBlockQuoteContinuation\n  },\n  exit: exit\n};\nfunction tokenizeBlockQuoteStart(effects, ok, nok) {\n  var self = this;\n  return start;\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      effects.enter('blockQuotePrefix');\n      effects.enter('blockQuoteMarker');\n      effects.consume(code);\n      effects.exit('blockQuoteMarker');\n      return after;\n    }\n    return nok(code);\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    effects.exit('blockQuotePrefix');\n    return ok(code);\n  }\n}\nfunction tokenizeBlockQuoteContinuation(effects, ok, nok) {\n  return factorySpace(effects, effects.attempt(blockQuote, ok, nok), 'linePrefix', this.parser.constructs.disable.null.indexOf('codeIndented') > -1 ? undefined : 4);\n}\nfunction exit(effects) {\n  effects.exit('blockQuote');\n}\nmodule.exports = blockQuote;","'use strict';\n\nvar asciiPunctuation = require('../character/ascii-punctuation.js');\nvar characterEscape = {\n  name: 'characterEscape',\n  tokenize: tokenizeCharacterEscape\n};\nfunction tokenizeCharacterEscape(effects, ok, nok) {\n  return start;\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  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    return nok(code);\n  }\n}\nmodule.exports = characterEscape;","'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');\nfunction _interopDefaultLegacy(e) {\n  return e && typeof e === 'object' && 'default' in e ? e : {\n    default: e\n  };\n}\nvar decodeEntity__default = /*#__PURE__*/_interopDefaultLegacy(decodeEntity);\nvar characterReference = {\n  name: 'characterReference',\n  tokenize: tokenizeCharacterReference\n};\nfunction tokenizeCharacterReference(effects, ok, nok) {\n  var self = this;\n  var size = 0;\n  var max;\n  var test;\n  return start;\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  function open(code) {\n    if (code === 35) {\n      effects.enter('characterReferenceMarkerNumeric');\n      effects.consume(code);\n      effects.exit('characterReferenceMarkerNumeric');\n      return numeric;\n    }\n    effects.enter('characterReferenceValue');\n    max = 31;\n    test = asciiAlphanumeric;\n    return value(code);\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    effects.enter('characterReferenceValue');\n    max = 7;\n    test = asciiDigit;\n    return value(code);\n  }\n  function value(code) {\n    var token;\n    if (code === 59 && size) {\n      token = effects.exit('characterReferenceValue');\n      if (test === asciiAlphanumeric && !decodeEntity__default['default'](self.sliceSerialize(token))) {\n        return nok(code);\n      }\n      effects.enter('characterReferenceMarker');\n      effects.consume(code);\n      effects.exit('characterReferenceMarker');\n      effects.exit('characterReference');\n      return ok;\n    }\n    if (test(code) && size++ < max) {\n      effects.consume(code);\n      return value;\n    }\n    return nok(code);\n  }\n}\nmodule.exports = characterReference;","'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');\nvar codeFenced = {\n  name: 'codeFenced',\n  tokenize: tokenizeCodeFenced,\n  concrete: true\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  function start(code) {\n    effects.enter('codeFenced');\n    effects.enter('codeFencedFence');\n    effects.enter('codeFencedFenceSequence');\n    marker = code;\n    return sequenceOpen(code);\n  }\n  function sequenceOpen(code) {\n    if (code === marker) {\n      effects.consume(code);\n      sizeOpen++;\n      return sequenceOpen;\n    }\n    effects.exit('codeFencedFenceSequence');\n    return sizeOpen < 3 ? nok(code) : factorySpace(effects, infoOpen, 'whitespace')(code);\n  }\n  function infoOpen(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return openAfter(code);\n    }\n    effects.enter('codeFencedFenceInfo');\n    effects.enter('chunkString', {\n      contentType: 'string'\n    });\n    return info(code);\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    if (code === 96 && code === marker) return nok(code);\n    effects.consume(code);\n    return info;\n  }\n  function infoAfter(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return openAfter(code);\n    }\n    effects.enter('codeFencedFenceMeta');\n    effects.enter('chunkString', {\n      contentType: 'string'\n    });\n    return meta(code);\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    if (code === 96 && code === marker) return nok(code);\n    effects.consume(code);\n    return meta;\n  }\n  function openAfter(code) {\n    effects.exit('codeFencedFence');\n    return self.interrupt ? ok(code) : content(code);\n  }\n  function content(code) {\n    if (code === null) {\n      return after(code);\n    }\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding');\n      effects.consume(code);\n      effects.exit('lineEnding');\n      return effects.attempt(closingFenceConstruct, after, initialPrefix ? factorySpace(effects, content, 'linePrefix', initialPrefix + 1) : content);\n    }\n    effects.enter('codeFlowValue');\n    return contentContinue(code);\n  }\n  function contentContinue(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('codeFlowValue');\n      return content(code);\n    }\n    effects.consume(code);\n    return contentContinue;\n  }\n  function after(code) {\n    effects.exit('codeFenced');\n    return ok(code);\n  }\n  function tokenizeClosingFence(effects, ok, nok) {\n    var size = 0;\n    return factorySpace(effects, closingSequenceStart, 'linePrefix', this.parser.constructs.disable.null.indexOf('codeIndented') > -1 ? undefined : 4);\n    function closingSequenceStart(code) {\n      effects.enter('codeFencedFence');\n      effects.enter('codeFencedFenceSequence');\n      return closingSequence(code);\n    }\n    function closingSequence(code) {\n      if (code === marker) {\n        effects.consume(code);\n        size++;\n        return closingSequence;\n      }\n      if (size < sizeOpen) return nok(code);\n      effects.exit('codeFencedFenceSequence');\n      return factorySpace(effects, closingSequenceEnd, 'whitespace')(code);\n    }\n    function closingSequenceEnd(code) {\n      if (code === null || markdownLineEnding(code)) {\n        effects.exit('codeFencedFence');\n        return ok(code);\n      }\n      return nok(code);\n    }\n  }\n}\nmodule.exports = codeFenced;","'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');\nvar codeIndented = {\n  name: 'codeIndented',\n  tokenize: tokenizeCodeIndented,\n  resolve: resolveCodeIndented\n};\nvar indentedContentConstruct = {\n  tokenize: tokenizeIndentedContent,\n  partial: true\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}\nfunction tokenizeCodeIndented(effects, ok, nok) {\n  return effects.attempt(indentedContentConstruct, afterPrefix, nok);\n  function afterPrefix(code) {\n    if (code === null) {\n      return ok(code);\n    }\n    if (markdownLineEnding(code)) {\n      return effects.attempt(indentedContentConstruct, afterPrefix, ok)(code);\n    }\n    effects.enter('codeFlowValue');\n    return content(code);\n  }\n  function content(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('codeFlowValue');\n      return afterPrefix(code);\n    }\n    effects.consume(code);\n    return content;\n  }\n}\nfunction tokenizeIndentedContent(effects, ok, nok) {\n  var self = this;\n  return factorySpace(effects, afterPrefix, 'linePrefix', 4 + 1);\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    return prefixSize(self.events, 'linePrefix') < 4 ? nok(code) : ok(code);\n  }\n}\nmodule.exports = codeIndented;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\nvar codeText = {\n  name: 'codeText',\n  tokenize: tokenizeCodeText,\n  resolve: resolveCodeText,\n  previous: previous\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 ((events[headEnterIndex][1].type === 'lineEnding' || events[headEnterIndex][1].type === 'space') && (events[tailExitIndex][1].type === 'lineEnding' || events[tailExitIndex][1].type === 'space')) {\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 = '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  while (++index <= tailExitIndex) {\n    if (enter === undefined) {\n      if (index !== tailExitIndex && events[index][1].type !== 'lineEnding') {\n        enter = index;\n      }\n    } else if (index === tailExitIndex || events[index][1].type === 'lineEnding') {\n      events[enter][1].type = 'codeTextData';\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      enter = undefined;\n    }\n  }\n  return events;\n}\nfunction previous(code) {\n  // If there is a previous code, there will always be a tail.\n  return code !== 96 || this.events[this.events.length - 1][1].type === 'characterEscape';\n}\nfunction tokenizeCodeText(effects, ok, nok) {\n  var sizeOpen = 0;\n  var size;\n  var token;\n  return start;\n  function start(code) {\n    effects.enter('codeText');\n    effects.enter('codeTextSequence');\n    return openingSequence(code);\n  }\n  function openingSequence(code) {\n    if (code === 96) {\n      effects.consume(code);\n      sizeOpen++;\n      return openingSequence;\n    }\n    effects.exit('codeTextSequence');\n    return gap(code);\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    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 (code === null || code === 32 || code === 96 || markdownLineEnding(code)) {\n      effects.exit('codeTextData');\n      return gap(code);\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}\nmodule.exports = codeText;","'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}\nfunction tokenizeContent(effects, ok) {\n  var previous;\n  return start;\n  function start(code) {\n    effects.enter('content');\n    previous = effects.enter('chunkContent', {\n      contentType: 'content'\n    });\n    return data(code);\n  }\n  function data(code) {\n    if (code === null) {\n      return contentEnd(code);\n    }\n    if (markdownLineEnding(code)) {\n      return effects.check(continuationConstruct, contentContinue, contentEnd)(code);\n    } // Data.\n\n    effects.consume(code);\n    return data;\n  }\n  function contentEnd(code) {\n    effects.exit('chunkContent');\n    effects.exit('content');\n    return ok(code);\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}\nfunction tokenizeContinuation(effects, ok, nok) {\n  var self = this;\n  return startLookahead;\n  function startLookahead(code) {\n    effects.enter('lineEnding');\n    effects.consume(code);\n    effects.exit('lineEnding');\n    return factorySpace(effects, prefixed, 'linePrefix');\n  }\n  function prefixed(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code);\n    }\n    if (self.parser.constructs.disable.null.indexOf('codeIndented') > -1 || prefixSize(self.events, 'linePrefix') < 4) {\n      return effects.interrupt(self.parser.constructs.flow, nok, ok)(code);\n    }\n    return ok(code);\n  }\n}\nmodule.exports = content;","'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');\nvar definition = {\n  name: 'definition',\n  tokenize: tokenizeDefinition\n};\nvar titleConstruct = {\n  tokenize: tokenizeTitle,\n  partial: true\n};\nfunction tokenizeDefinition(effects, ok, nok) {\n  var self = this;\n  var identifier;\n  return start;\n  function start(code) {\n    effects.enter('definition');\n    return factoryLabel.call(self, effects, labelAfter, nok, 'definitionLabel', 'definitionLabelMarker', 'definitionLabelString')(code);\n  }\n  function labelAfter(code) {\n    identifier = normalizeIdentifier(self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1));\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(effects, factoryDestination(effects, effects.attempt(titleConstruct, factorySpace(effects, after, 'whitespace'), factorySpace(effects, after, 'whitespace')), nok, 'definitionDestination', 'definitionDestinationLiteral', 'definitionDestinationLiteralMarker', 'definitionDestinationRaw', 'definitionDestinationString'));\n    }\n    return nok(code);\n  }\n  function after(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('definition');\n      if (self.parser.defined.indexOf(identifier) < 0) {\n        self.parser.defined.push(identifier);\n      }\n      return ok(code);\n    }\n    return nok(code);\n  }\n}\nfunction tokenizeTitle(effects, ok, nok) {\n  return start;\n  function start(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, before)(code) : nok(code);\n  }\n  function before(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      return factoryTitle(effects, factorySpace(effects, after, 'whitespace'), nok, 'definitionTitle', 'definitionTitleMarker', 'definitionTitleString')(code);\n    }\n    return nok(code);\n  }\n  function after(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code);\n  }\n}\nmodule.exports = definition;","'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(effects, ok, nok, type, literalType, literalMarkerType, rawType, stringType, max) {\n  var limit = max || Infinity;\n  var balance = 0;\n  return start;\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    if (asciiControl(code) || code === 41) {\n      return nok(code);\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  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    effects.enter(stringType);\n    effects.enter('chunkString', {\n      contentType: 'string'\n    });\n    return destinationEnclosed(code);\n  }\n  function destinationEnclosed(code) {\n    if (code === 62) {\n      effects.exit('chunkString');\n      effects.exit(stringType);\n      return destinationEnclosedBefore(code);\n    }\n    if (code === null || code === 60 || markdownLineEnding(code)) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return code === 92 ? destinationEnclosedEscape : destinationEnclosed;\n  }\n  function destinationEnclosedEscape(code) {\n    if (code === 60 || code === 62 || code === 92) {\n      effects.consume(code);\n      return destinationEnclosed;\n    }\n    return destinationEnclosed(code);\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    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      effects.consume(code);\n      return destinationRaw;\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    if (asciiControl(code)) return nok(code);\n    effects.consume(code);\n    return code === 92 ? destinationRawEscape : destinationRaw;\n  }\n  function destinationRawEscape(code) {\n    if (code === 40 || code === 41 || code === 92) {\n      effects.consume(code);\n      return destinationRaw;\n    }\n    return destinationRaw(code);\n  }\n}\nmodule.exports = destinationFactory;","'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  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  function atBreak(code) {\n    if (code === null || code === 91 || code === 93 && !data || /* c8 ignore next */\n    code === 94 && /* c8 ignore next */\n    !size && /* c8 ignore next */\n    '_hiddenFootnoteSupport' in self.parser.constructs || size > 999) {\n      return nok(code);\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    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding');\n      effects.consume(code);\n      effects.exit('lineEnding');\n      return atBreak;\n    }\n    effects.enter('chunkString', {\n      contentType: 'string'\n    });\n    return label(code);\n  }\n  function label(code) {\n    if (code === null || code === 91 || code === 93 || markdownLineEnding(code) || size++ > 999) {\n      effects.exit('chunkString');\n      return atBreak(code);\n    }\n    effects.consume(code);\n    data = data || !markdownSpace(code);\n    return code === 92 ? labelEscape : label;\n  }\n  function labelEscape(code) {\n    if (code === 91 || code === 92 || code === 93) {\n      effects.consume(code);\n      size++;\n      return label;\n    }\n    return label(code);\n  }\n}\nmodule.exports = labelFactory;","'use strict';\n\nvar markdownSpace = require('../character/markdown-space.js');\nfunction spaceFactory(effects, ok, type, max) {\n  var limit = max ? max - 1 : Infinity;\n  var size = 0;\n  return start;\n  function start(code) {\n    if (markdownSpace(code)) {\n      effects.enter(type);\n      return prefix(code);\n    }\n    return ok(code);\n  }\n  function prefix(code) {\n    if (markdownSpace(code) && size++ < limit) {\n      effects.consume(code);\n      return prefix;\n    }\n    effects.exit(type);\n    return ok(code);\n  }\n}\nmodule.exports = spaceFactory;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\nvar factorySpace = require('./factory-space.js');\nfunction titleFactory(effects, ok, nok, type, markerType, stringType) {\n  var marker;\n  return start;\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  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    effects.enter(stringType);\n    return atTitleBreak(code);\n  }\n  function atTitleBreak(code) {\n    if (code === marker) {\n      effects.exit(stringType);\n      return atFirstTitleBreak(marker);\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    effects.enter('chunkString', {\n      contentType: 'string'\n    });\n    return title(code);\n  }\n  function title(code) {\n    if (code === marker || code === null || markdownLineEnding(code)) {\n      effects.exit('chunkString');\n      return atTitleBreak(code);\n    }\n    effects.consume(code);\n    return code === 92 ? titleEscape : title;\n  }\n  function titleEscape(code) {\n    if (code === marker || code === 92) {\n      effects.consume(code);\n      return title;\n    }\n    return title(code);\n  }\n}\nmodule.exports = titleFactory;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\nvar markdownSpace = require('../character/markdown-space.js');\nvar factorySpace = require('./factory-space.js');\nfunction whitespaceFactory(effects, ok) {\n  var seen;\n  return start;\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    if (markdownSpace(code)) {\n      return factorySpace(effects, start, seen ? 'linePrefix' : 'lineSuffix')(code);\n    }\n    return ok(code);\n  }\n}\nmodule.exports = whitespaceFactory;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\nvar hardBreakEscape = {\n  name: 'hardBreakEscape',\n  tokenize: tokenizeHardBreakEscape\n};\nfunction tokenizeHardBreakEscape(effects, ok, nok) {\n  return start;\n  function start(code) {\n    effects.enter('hardBreakEscape');\n    effects.enter('escapeMarker');\n    effects.consume(code);\n    return open;\n  }\n  function open(code) {\n    if (markdownLineEnding(code)) {\n      effects.exit('escapeMarker');\n      effects.exit('hardBreakEscape');\n      return ok(code);\n    }\n    return nok(code);\n  }\n}\nmodule.exports = hardBreakEscape;","'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');\nvar headingAtx = {\n  name: 'headingAtx',\n  tokenize: tokenizeHeadingAtx,\n  resolve: resolveHeadingAtx\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 (contentEnd - 2 > contentStart && events[contentEnd][1].type === 'whitespace') {\n    contentEnd -= 2;\n  }\n  if (events[contentEnd][1].type === 'atxHeadingSequence' && (contentStart === contentEnd - 1 || contentEnd - 4 > contentStart && events[contentEnd - 2][1].type === 'whitespace')) {\n    contentEnd -= contentStart + 1 === contentEnd ? 2 : 4;\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, [['enter', content, context], ['enter', text, context], ['exit', text, context], ['exit', content, context]]);\n  }\n  return events;\n}\nfunction tokenizeHeadingAtx(effects, ok, nok) {\n  var self = this;\n  var size = 0;\n  return start;\n  function start(code) {\n    effects.enter('atxHeading');\n    effects.enter('atxHeadingSequence');\n    return fenceOpenInside(code);\n  }\n  function fenceOpenInside(code) {\n    if (code === 35 && size++ < 6) {\n      effects.consume(code);\n      return fenceOpenInside;\n    }\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      effects.exit('atxHeadingSequence');\n      return self.interrupt ? ok(code) : headingBreak(code);\n    }\n    return nok(code);\n  }\n  function headingBreak(code) {\n    if (code === 35) {\n      effects.enter('atxHeadingSequence');\n      return sequence(code);\n    }\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('atxHeading');\n      return ok(code);\n    }\n    if (markdownSpace(code)) {\n      return factorySpace(effects, headingBreak, 'whitespace')(code);\n    }\n    effects.enter('atxHeadingText');\n    return data(code);\n  }\n  function sequence(code) {\n    if (code === 35) {\n      effects.consume(code);\n      return sequence;\n    }\n    effects.exit('atxHeadingSequence');\n    return headingBreak(code);\n  }\n  function data(code) {\n    if (code === null || code === 35 || markdownLineEndingOrSpace(code)) {\n      effects.exit('atxHeadingText');\n      return headingBreak(code);\n    }\n    effects.consume(code);\n    return data;\n  }\n}\nmodule.exports = headingAtx;","'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');\nvar htmlFlow = {\n  name: 'htmlFlow',\n  tokenize: tokenizeHtmlFlow,\n  resolveTo: resolveToHtmlFlow,\n  concrete: true\n};\nvar nextBlankConstruct = {\n  tokenize: tokenizeNextBlank,\n  partial: true\n};\nfunction resolveToHtmlFlow(events) {\n  var index = events.length;\n  while (index--) {\n    if (events[index][0] === 'enter' && events[index][1].type === 'htmlFlow') {\n      break;\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  return events;\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  function start(code) {\n    effects.enter('htmlFlow');\n    effects.enter('htmlFlowData');\n    effects.consume(code);\n    return open;\n  }\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code);\n      return declarationStart;\n    }\n    if (code === 47) {\n      effects.consume(code);\n      return tagCloseStart;\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    if (asciiAlpha(code)) {\n      effects.consume(code);\n      buffer = fromCharCode(code);\n      startTag = true;\n      return tagName;\n    }\n    return nok(code);\n  }\n  function declarationStart(code) {\n    if (code === 45) {\n      effects.consume(code);\n      kind = 2;\n      return commentOpenInside;\n    }\n    if (code === 91) {\n      effects.consume(code);\n      kind = 5;\n      buffer = 'CDATA[';\n      index = 0;\n      return cdataOpenInside;\n    }\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      kind = 4;\n      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n    return nok(code);\n  }\n  function commentOpenInside(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n    return nok(code);\n  }\n  function cdataOpenInside(code) {\n    if (code === buffer.charCodeAt(index++)) {\n      effects.consume(code);\n      return index === buffer.length ? self.interrupt ? ok : continuation : cdataOpenInside;\n    }\n    return nok(code);\n  }\n  function tagCloseStart(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      buffer = fromCharCode(code);\n      return tagName;\n    }\n    return nok(code);\n  }\n  function tagName(code) {\n    if (code === null || code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      if (code !== 47 && startTag && htmlRawNames.indexOf(buffer.toLowerCase()) > -1) {\n        kind = 1;\n        return self.interrupt ? ok(code) : continuation(code);\n      }\n      if (htmlBlockNames.indexOf(buffer.toLowerCase()) > -1) {\n        kind = 6;\n        if (code === 47) {\n          effects.consume(code);\n          return basicSelfClosing;\n        }\n        return self.interrupt ? ok(code) : continuation(code);\n      }\n      kind = 7; // Do not support complete HTML when interrupting.\n\n      return self.interrupt ? nok(code) : startTag ? completeAttributeNameBefore(code) : completeClosingTagAfter(code);\n    }\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      buffer += fromCharCode(code);\n      return tagName;\n    }\n    return nok(code);\n  }\n  function basicSelfClosing(code) {\n    if (code === 62) {\n      effects.consume(code);\n      return self.interrupt ? ok : continuation;\n    }\n    return nok(code);\n  }\n  function completeClosingTagAfter(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeClosingTagAfter;\n    }\n    return completeEnd(code);\n  }\n  function completeAttributeNameBefore(code) {\n    if (code === 47) {\n      effects.consume(code);\n      return completeEnd;\n    }\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code);\n      return completeAttributeName;\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeNameBefore;\n    }\n    return completeEnd(code);\n  }\n  function completeAttributeName(code) {\n    if (code === 45 || code === 46 || code === 58 || code === 95 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return completeAttributeName;\n    }\n    return completeAttributeNameAfter(code);\n  }\n  function completeAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code);\n      return completeAttributeValueBefore;\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeNameAfter;\n    }\n    return completeAttributeNameBefore(code);\n  }\n  function completeAttributeValueBefore(code) {\n    if (code === null || code === 60 || code === 61 || code === 62 || code === 96) {\n      return nok(code);\n    }\n    if (code === 34 || code === 39) {\n      effects.consume(code);\n      marker = code;\n      return completeAttributeValueQuoted;\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeValueBefore;\n    }\n    marker = undefined;\n    return completeAttributeValueUnquoted(code);\n  }\n  function completeAttributeValueQuoted(code) {\n    if (code === marker) {\n      effects.consume(code);\n      return completeAttributeValueQuotedAfter;\n    }\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return completeAttributeValueQuoted;\n  }\n  function completeAttributeValueUnquoted(code) {\n    if (code === null || code === 34 || code === 39 || code === 60 || code === 61 || code === 62 || code === 96 || markdownLineEndingOrSpace(code)) {\n      return completeAttributeNameAfter(code);\n    }\n    effects.consume(code);\n    return completeAttributeValueUnquoted;\n  }\n  function completeAttributeValueQuotedAfter(code) {\n    if (code === 47 || code === 62 || markdownSpace(code)) {\n      return completeAttributeNameBefore(code);\n    }\n    return nok(code);\n  }\n  function completeEnd(code) {\n    if (code === 62) {\n      effects.consume(code);\n      return completeAfter;\n    }\n    return nok(code);\n  }\n  function completeAfter(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAfter;\n    }\n    return code === null || markdownLineEnding(code) ? continuation(code) : nok(code);\n  }\n  function continuation(code) {\n    if (code === 45 && kind === 2) {\n      effects.consume(code);\n      return continuationCommentInside;\n    }\n    if (code === 60 && kind === 1) {\n      effects.consume(code);\n      return continuationRawTagOpen;\n    }\n    if (code === 62 && kind === 4) {\n      effects.consume(code);\n      return continuationClose;\n    }\n    if (code === 63 && kind === 3) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n    if (code === 93 && kind === 5) {\n      effects.consume(code);\n      return continuationCharacterDataInside;\n    }\n    if (markdownLineEnding(code) && (kind === 6 || kind === 7)) {\n      return effects.check(nextBlankConstruct, continuationClose, continuationAtLineEnding)(code);\n    }\n    if (code === null || markdownLineEnding(code)) {\n      return continuationAtLineEnding(code);\n    }\n    effects.consume(code);\n    return continuation;\n  }\n  function continuationAtLineEnding(code) {\n    effects.exit('htmlFlowData');\n    return htmlContinueStart(code);\n  }\n  function htmlContinueStart(code) {\n    if (code === null) {\n      return done(code);\n    }\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding');\n      effects.consume(code);\n      effects.exit('lineEnding');\n      return htmlContinueStart;\n    }\n    effects.enter('htmlFlowData');\n    return continuation(code);\n  }\n  function continuationCommentInside(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n    return continuation(code);\n  }\n  function continuationRawTagOpen(code) {\n    if (code === 47) {\n      effects.consume(code);\n      buffer = '';\n      return continuationRawEndTag;\n    }\n    return continuation(code);\n  }\n  function continuationRawEndTag(code) {\n    if (code === 62 && htmlRawNames.indexOf(buffer.toLowerCase()) > -1) {\n      effects.consume(code);\n      return continuationClose;\n    }\n    if (asciiAlpha(code) && buffer.length < 8) {\n      effects.consume(code);\n      buffer += fromCharCode(code);\n      return continuationRawEndTag;\n    }\n    return continuation(code);\n  }\n  function continuationCharacterDataInside(code) {\n    if (code === 93) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n    return continuation(code);\n  }\n  function continuationDeclarationInside(code) {\n    if (code === 62) {\n      effects.consume(code);\n      return continuationClose;\n    }\n    return continuation(code);\n  }\n  function continuationClose(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('htmlFlowData');\n      return done(code);\n    }\n    effects.consume(code);\n    return continuationClose;\n  }\n  function done(code) {\n    effects.exit('htmlFlow');\n    return ok(code);\n  }\n}\nfunction tokenizeNextBlank(effects, ok, nok) {\n  return start;\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}\nmodule.exports = htmlFlow;","'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');\nvar htmlText = {\n  name: 'htmlText',\n  tokenize: tokenizeHtmlText\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  function start(code) {\n    effects.enter('htmlText');\n    effects.enter('htmlTextData');\n    effects.consume(code);\n    return open;\n  }\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code);\n      return declarationOpen;\n    }\n    if (code === 47) {\n      effects.consume(code);\n      return tagCloseStart;\n    }\n    if (code === 63) {\n      effects.consume(code);\n      return instruction;\n    }\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return tagOpen;\n    }\n    return nok(code);\n  }\n  function declarationOpen(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return commentOpen;\n    }\n    if (code === 91) {\n      effects.consume(code);\n      buffer = 'CDATA[';\n      index = 0;\n      return cdataOpen;\n    }\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return declaration;\n    }\n    return nok(code);\n  }\n  function commentOpen(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return commentStart;\n    }\n    return nok(code);\n  }\n  function commentStart(code) {\n    if (code === null || code === 62) {\n      return nok(code);\n    }\n    if (code === 45) {\n      effects.consume(code);\n      return commentStartDash;\n    }\n    return comment(code);\n  }\n  function commentStartDash(code) {\n    if (code === null || code === 62) {\n      return nok(code);\n    }\n    return comment(code);\n  }\n  function comment(code) {\n    if (code === null) {\n      return nok(code);\n    }\n    if (code === 45) {\n      effects.consume(code);\n      return commentClose;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = comment;\n      return atLineEnding(code);\n    }\n    effects.consume(code);\n    return comment;\n  }\n  function commentClose(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return end;\n    }\n    return comment(code);\n  }\n  function cdataOpen(code) {\n    if (code === buffer.charCodeAt(index++)) {\n      effects.consume(code);\n      return index === buffer.length ? cdata : cdataOpen;\n    }\n    return nok(code);\n  }\n  function cdata(code) {\n    if (code === null) {\n      return nok(code);\n    }\n    if (code === 93) {\n      effects.consume(code);\n      return cdataClose;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = cdata;\n      return atLineEnding(code);\n    }\n    effects.consume(code);\n    return cdata;\n  }\n  function cdataClose(code) {\n    if (code === 93) {\n      effects.consume(code);\n      return cdataEnd;\n    }\n    return cdata(code);\n  }\n  function cdataEnd(code) {\n    if (code === 62) {\n      return end(code);\n    }\n    if (code === 93) {\n      effects.consume(code);\n      return cdataEnd;\n    }\n    return cdata(code);\n  }\n  function declaration(code) {\n    if (code === null || code === 62) {\n      return end(code);\n    }\n    if (markdownLineEnding(code)) {\n      returnState = declaration;\n      return atLineEnding(code);\n    }\n    effects.consume(code);\n    return declaration;\n  }\n  function instruction(code) {\n    if (code === null) {\n      return nok(code);\n    }\n    if (code === 63) {\n      effects.consume(code);\n      return instructionClose;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = instruction;\n      return atLineEnding(code);\n    }\n    effects.consume(code);\n    return instruction;\n  }\n  function instructionClose(code) {\n    return code === 62 ? end(code) : instruction(code);\n  }\n  function tagCloseStart(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return tagClose;\n    }\n    return nok(code);\n  }\n  function tagClose(code) {\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagClose;\n    }\n    return tagCloseBetween(code);\n  }\n  function tagCloseBetween(code) {\n    if (markdownLineEnding(code)) {\n      returnState = tagCloseBetween;\n      return atLineEnding(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagCloseBetween;\n    }\n    return end(code);\n  }\n  function tagOpen(code) {\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagOpen;\n    }\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n    return nok(code);\n  }\n  function tagOpenBetween(code) {\n    if (code === 47) {\n      effects.consume(code);\n      return end;\n    }\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code);\n      return tagOpenAttributeName;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenBetween;\n      return atLineEnding(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenBetween;\n    }\n    return end(code);\n  }\n  function tagOpenAttributeName(code) {\n    if (code === 45 || code === 46 || code === 58 || code === 95 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagOpenAttributeName;\n    }\n    return tagOpenAttributeNameAfter(code);\n  }\n  function tagOpenAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code);\n      return tagOpenAttributeValueBefore;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeNameAfter;\n      return atLineEnding(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenAttributeNameAfter;\n    }\n    return tagOpenBetween(code);\n  }\n  function tagOpenAttributeValueBefore(code) {\n    if (code === null || code === 60 || code === 61 || code === 62 || code === 96) {\n      return nok(code);\n    }\n    if (code === 34 || code === 39) {\n      effects.consume(code);\n      marker = code;\n      return tagOpenAttributeValueQuoted;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueBefore;\n      return atLineEnding(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenAttributeValueBefore;\n    }\n    effects.consume(code);\n    marker = undefined;\n    return tagOpenAttributeValueUnquoted;\n  }\n  function tagOpenAttributeValueQuoted(code) {\n    if (code === marker) {\n      effects.consume(code);\n      return tagOpenAttributeValueQuotedAfter;\n    }\n    if (code === null) {\n      return nok(code);\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueQuoted;\n      return atLineEnding(code);\n    }\n    effects.consume(code);\n    return tagOpenAttributeValueQuoted;\n  }\n  function tagOpenAttributeValueQuotedAfter(code) {\n    if (code === 62 || code === 47 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n    return nok(code);\n  }\n  function tagOpenAttributeValueUnquoted(code) {\n    if (code === null || code === 34 || code === 39 || code === 60 || code === 61 || code === 96) {\n      return nok(code);\n    }\n    if (code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\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(effects, afterPrefix, 'linePrefix', self.parser.constructs.disable.null.indexOf('codeIndented') > -1 ? undefined : 4);\n  }\n  function afterPrefix(code) {\n    effects.enter('htmlTextData');\n    return returnState(code);\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    return nok(code);\n  }\n}\nmodule.exports = htmlText;","'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');\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};\nfunction resolveAllLabelEnd(events) {\n  var index = -1;\n  var token;\n  while (++index < events.length) {\n    token = events[index][1];\n    if (!token._used && (token.type === 'labelImage' || token.type === 'labelLink' || token.type === 'labelEnd')) {\n      // Remove the marker.\n      events.splice(index + 1, token.type === 'labelImage' ? 4 : 2);\n      token.type = 'data';\n      index++;\n    }\n  }\n  return events;\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    if (open) {\n      // If we see another link, or inactive link label, we’ve been here before.\n      if (token.type === 'link' || token.type === 'labelLink' && token._inactive) {\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 (events[index][0] === 'enter' && (token.type === 'labelImage' || token.type === 'labelLink') && !token._balanced) {\n        open = index;\n        if (token.type !== 'labelLink') {\n          offset = 2;\n          break;\n        }\n      }\n    } else if (token.type === 'labelEnd') {\n      close = index;\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 = [['enter', group, context], ['enter', label, context]]; // 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(media, resolveAll(context.parser.constructs.insideSpan.null, events.slice(open + offset + 4, close - 3), context)); // Text close, marker close, label close.\n\n  media = chunkedPush(media, [['exit', text, context], events[close - 2], events[close - 1], ['exit', label, context]]); // 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}\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 ((self.events[index][1].type === 'labelImage' || self.events[index][1].type === 'labelLink') && !self.events[index][1]._balanced) {\n      labelStart = self.events[index][1];\n      break;\n    }\n  }\n  return start;\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 = self.parser.defined.indexOf(normalizeIdentifier(self.sliceSerialize({\n      start: labelStart.end,\n      end: self.now()\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  function afterLabelEnd(code) {\n    // Resource: `[asd](fgh)`.\n    if (code === 40) {\n      return effects.attempt(resourceConstruct, ok, defined ? ok : balanced)(code);\n    } // Collapsed (`[asd][]`) or full (`[asd][fgh]`) reference?\n\n    if (code === 91) {\n      return effects.attempt(fullReferenceConstruct, ok, defined ? effects.attempt(collapsedReferenceConstruct, ok, balanced) : balanced)(code);\n    } // Shortcut reference: `[asd]`?\n\n    return defined ? ok(code) : balanced(code);\n  }\n  function balanced(code) {\n    labelStart._balanced = true;\n    return nok(code);\n  }\n}\nfunction tokenizeResource(effects, ok, nok) {\n  return start;\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  function open(code) {\n    if (code === 41) {\n      return end(code);\n    }\n    return factoryDestination(effects, destinationAfter, nok, 'resourceDestination', 'resourceDestinationLiteral', 'resourceDestinationLiteralMarker', 'resourceDestinationRaw', 'resourceDestinationString', 3)(code);\n  }\n  function destinationAfter(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, between)(code) : end(code);\n  }\n  function between(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      return factoryTitle(effects, factoryWhitespace(effects, end), nok, 'resourceTitle', 'resourceTitleMarker', 'resourceTitleString')(code);\n    }\n    return end(code);\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    return nok(code);\n  }\n}\nfunction tokenizeFullReference(effects, ok, nok) {\n  var self = this;\n  return start;\n  function start(code) {\n    return factoryLabel.call(self, effects, afterLabel, nok, 'reference', 'referenceMarker', 'referenceString')(code);\n  }\n  function afterLabel(code) {\n    return self.parser.defined.indexOf(normalizeIdentifier(self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1))) < 0 ? nok(code) : ok(code);\n  }\n}\nfunction tokenizeCollapsedReference(effects, ok, nok) {\n  return start;\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  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    return nok(code);\n  }\n}\nmodule.exports = labelEnd;","'use strict';\n\nvar labelEnd = require('./label-end.js');\nvar labelStartImage = {\n  name: 'labelStartImage',\n  tokenize: tokenizeLabelStartImage,\n  resolveAll: labelEnd.resolveAll\n};\nfunction tokenizeLabelStartImage(effects, ok, nok) {\n  var self = this;\n  return start;\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  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    return nok(code);\n  }\n  function after(code) {\n    /* c8 ignore next */\n    return code === 94 && /* c8 ignore next */\n    '_hiddenFootnoteSupport' in self.parser.constructs ? /* c8 ignore next */\n    nok(code) : ok(code);\n  }\n}\nmodule.exports = labelStartImage;","'use strict';\n\nvar labelEnd = require('./label-end.js');\nvar labelStartLink = {\n  name: 'labelStartLink',\n  tokenize: tokenizeLabelStartLink,\n  resolveAll: labelEnd.resolveAll\n};\nfunction tokenizeLabelStartLink(effects, ok, nok) {\n  var self = this;\n  return start;\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  function after(code) {\n    /* c8 ignore next */\n    return code === 94 && /* c8 ignore next */\n    '_hiddenFootnoteSupport' in self.parser.constructs ? /* c8 ignore next */\n    nok(code) : ok(code);\n  }\n}\nmodule.exports = labelStartLink;","'use strict';\n\nvar factorySpace = require('./factory-space.js');\nvar lineEnding = {\n  name: 'lineEnding',\n  tokenize: tokenizeLineEnding\n};\nfunction tokenizeLineEnding(effects, ok) {\n  return start;\n  function start(code) {\n    effects.enter('lineEnding');\n    effects.consume(code);\n    effects.exit('lineEnding');\n    return factorySpace(effects, ok, 'linePrefix');\n  }\n}\nmodule.exports = lineEnding;","'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');\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};\nfunction tokenizeListStart(effects, ok, nok) {\n  var self = this;\n  var initialSize = prefixSize(self.events, 'linePrefix');\n  var size = 0;\n  return start;\n  function start(code) {\n    var kind = self.containerState.type || (code === 42 || code === 43 || code === 45 ? 'listUnordered' : 'listOrdered');\n    if (kind === 'listUnordered' ? !self.containerState.marker || code === self.containerState.marker : asciiDigit(code)) {\n      if (!self.containerState.type) {\n        self.containerState.type = kind;\n        effects.enter(kind, {\n          _container: true\n        });\n      }\n      if (kind === 'listUnordered') {\n        effects.enter('listItemPrefix');\n        return code === 42 || code === 45 ? effects.check(thematicBreak, nok, atMarker)(code) : atMarker(code);\n      }\n      if (!self.interrupt || code === 49) {\n        effects.enter('listItemPrefix');\n        effects.enter('listItemValue');\n        return inside(code);\n      }\n    }\n    return nok(code);\n  }\n  function inside(code) {\n    if (asciiDigit(code) && ++size < 10) {\n      effects.consume(code);\n      return inside;\n    }\n    if ((!self.interrupt || size < 2) && (self.containerState.marker ? code === self.containerState.marker : code === 41 || code === 46)) {\n      effects.exit('listItemValue');\n      return atMarker(code);\n    }\n    return nok(code);\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(partialBlankLine,\n    // Can’t be empty when interrupting.\n    self.interrupt ? nok : onBlank, effects.attempt(listItemPrefixWhitespaceConstruct, endOfPrefix, otherPrefix));\n  }\n  function onBlank(code) {\n    self.containerState.initialBlankLine = true;\n    initialSize++;\n    return endOfPrefix(code);\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    return nok(code);\n  }\n  function endOfPrefix(code) {\n    self.containerState.size = initialSize + sizeChunks(self.sliceStream(effects.exit('listItemPrefix')));\n    return ok(code);\n  }\n}\nfunction tokenizeListContinuation(effects, ok, nok) {\n  var self = this;\n  self.containerState._closeFlow = undefined;\n  return effects.check(partialBlankLine, onBlank, notBlank);\n  function onBlank(code) {\n    self.containerState.furtherBlankLines = self.containerState.furtherBlankLines || self.containerState.initialBlankLine; // We have a blank line.\n    // Still, try to consume at most the items size.\n\n    return factorySpace(effects, ok, 'listItemIndent', self.containerState.size + 1)(code);\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    self.containerState.furtherBlankLines = self.containerState.initialBlankLine = undefined;\n    return effects.attempt(indentConstruct, ok, notInCurrentItem)(code);\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(effects, effects.attempt(list, ok, nok), 'linePrefix', self.parser.constructs.disable.null.indexOf('codeIndented') > -1 ? undefined : 4)(code);\n  }\n}\nfunction tokenizeIndent(effects, ok, nok) {\n  var self = this;\n  return factorySpace(effects, afterPrefix, 'listItemIndent', self.containerState.size + 1);\n  function afterPrefix(code) {\n    return prefixSize(self.events, 'listItemIndent') === self.containerState.size ? ok(code) : nok(code);\n  }\n}\nfunction tokenizeListEnd(effects) {\n  effects.exit(this.containerState.type);\n}\nfunction tokenizeListItemPrefixWhitespace(effects, ok, nok) {\n  var self = this;\n  return factorySpace(effects, afterPrefix, 'listItemPrefixWhitespace', self.parser.constructs.disable.null.indexOf('codeIndented') > -1 ? undefined : 4 + 1);\n  function afterPrefix(code) {\n    return markdownSpace(code) || !prefixSize(self.events, 'listItemPrefixWhitespace') ? nok(code) : ok(code);\n  }\n}\nmodule.exports = list;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\nvar factorySpace = require('./factory-space.js');\nvar partialBlankLine = {\n  tokenize: tokenizePartialBlankLine,\n  partial: true\n};\nfunction tokenizePartialBlankLine(effects, ok, nok) {\n  return factorySpace(effects, afterWhitespace, 'linePrefix');\n  function afterWhitespace(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code);\n  }\n}\nmodule.exports = partialBlankLine;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\nvar shallow = require('../util/shallow.js');\nvar factorySpace = require('./factory-space.js');\nvar setextUnderline = {\n  name: 'setextUnderline',\n  tokenize: tokenizeSetextUnderline,\n  resolveTo: resolveToSetextUnderline\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      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      if (!definition && events[index][1].type === 'definition') {\n        definition = index;\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}\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 (self.events[index][1].type !== 'lineEnding' && self.events[index][1].type !== 'linePrefix' && self.events[index][1].type !== 'content') {\n      paragraph = self.events[index][1].type === 'paragraph';\n      break;\n    }\n  }\n  return start;\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    return nok(code);\n  }\n  function closingSequence(code) {\n    if (code === marker) {\n      effects.consume(code);\n      return closingSequence;\n    }\n    effects.exit('setextHeadingLineSequence');\n    return factorySpace(effects, closingSequenceEnd, 'lineSuffix')(code);\n  }\n  function closingSequenceEnd(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('setextHeadingLine');\n      return ok(code);\n    }\n    return nok(code);\n  }\n}\nmodule.exports = setextUnderline;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\nvar markdownSpace = require('../character/markdown-space.js');\nvar factorySpace = require('./factory-space.js');\nvar thematicBreak = {\n  name: 'thematicBreak',\n  tokenize: tokenizeThematicBreak\n};\nfunction tokenizeThematicBreak(effects, ok, nok) {\n  var size = 0;\n  var marker;\n  return start;\n  function start(code) {\n    effects.enter('thematicBreak');\n    marker = code;\n    return atBreak(code);\n  }\n  function atBreak(code) {\n    if (code === marker) {\n      effects.enter('thematicBreakSequence');\n      return sequence(code);\n    }\n    if (markdownSpace(code)) {\n      return factorySpace(effects, atBreak, 'whitespace')(code);\n    }\n    if (size < 3 || code !== null && !markdownLineEnding(code)) {\n      return nok(code);\n    }\n    effects.exit('thematicBreak');\n    return ok(code);\n  }\n  function sequence(code) {\n    if (code === marker) {\n      effects.consume(code);\n      size++;\n      return sequence;\n    }\n    effects.exit('thematicBreakSequence');\n    return atBreak(code);\n  }\n}\nmodule.exports = thematicBreak;","'use strict';\n\nvar chunkedSplice = require('./chunked-splice.js');\nfunction chunkedPush(list, items) {\n  if (list.length) {\n    chunkedSplice(list, list.length, 0, items);\n    return list;\n  }\n  return items;\n}\nmodule.exports = chunkedPush;","'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  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}\nmodule.exports = chunkedSplice;","'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 (code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) {\n    return 1;\n  }\n  if (unicodePunctuation(code)) {\n    return 2;\n  }\n}\nmodule.exports = classifyCharacter;","'use strict';\n\nvar hasOwnProperty = require('../constant/has-own-property.js');\nvar chunkedSplice = require('./chunked-splice.js');\nvar miniflat = require('./miniflat.js');\nfunction combineExtensions(extensions) {\n  var all = {};\n  var index = -1;\n  while (++index < extensions.length) {\n    extension(all, extensions[index]);\n  }\n  return all;\n}\nfunction extension(all, extension) {\n  var hook;\n  var left;\n  var right;\n  var code;\n  for (hook in extension) {\n    left = hasOwnProperty.call(all, hook) ? all[hook] : all[hook] = {};\n    right = extension[hook];\n    for (code in right) {\n      left[code] = constructs(miniflat(right[code]), hasOwnProperty.call(left, code) ? left[code] : []);\n    }\n  }\n}\nfunction constructs(list, existing) {\n  var index = -1;\n  var before = [];\n  while (++index < list.length) {\n    ;\n    (list[index].add === 'after' ? existing : before).push(list[index]);\n  }\n  chunkedSplice(existing, 0, 0, before);\n  return existing;\n}\nmodule.exports = combineExtensions;","'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 ? shallow(from) : {\n    line: 1,\n    column: 1,\n    offset: 0\n  };\n  var columnStart = {};\n  var resolveAllConstructs = [];\n  var chunks = [];\n  var stack = [];\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  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    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  function sliceStream(token) {\n    return sliceChunks(chunks, token);\n  }\n  function now() {\n    return shallow(point);\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    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        if (point._bufferIndex < 0) {\n          point._bufferIndex = 0;\n        }\n        while (point._index === chunkIndex && point._bufferIndex < chunk.length) {\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 ? handleListOfConstructs(miniflat(constructs)) : handleMapOfConstructs;\n      function handleMapOfConstructs(code) {\n        if (code in constructs || null in constructs) {\n          return handleListOfConstructs(constructs.null ? /* c8 ignore next */\n          miniflat(constructs[code]).concat(miniflat(constructs.null)) : constructs[code])(code);\n        }\n        return bogusState(code);\n      }\n      function handleListOfConstructs(list) {\n        listOfConstructs = list;\n        constructIndex = 0;\n        return handleConstruct(list[constructIndex]);\n      }\n      function handleConstruct(construct) {\n        return start;\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          if (!construct.partial) {\n            context.currentConstruct = construct;\n          }\n          if (construct.name && context.parser.constructs.disable.null.indexOf(construct.name) > -1) {\n            return nok();\n          }\n          return construct.tokenize.call(fields ? assign({}, context, fields) : context, effects, ok, nok)(code);\n        }\n      }\n      function ok(code) {\n        onreturn(currentConstruct, info);\n        return returnState;\n      }\n      function nok(code) {\n        info.restore();\n        if (++constructIndex < listOfConstructs.length) {\n          return handleConstruct(listOfConstructs[constructIndex]);\n        }\n        return bogusState;\n      }\n    }\n  }\n  function addResult(construct, from) {\n    if (construct.resolveAll && resolveAllConstructs.indexOf(construct) < 0) {\n      resolveAllConstructs.push(construct);\n    }\n    if (construct.resolve) {\n      chunkedSplice(context.events, from, context.events.length - from, construct.resolve(context.events.slice(from), context));\n    }\n    if (construct.resolveTo) {\n      context.events = construct.resolveTo(context.events, context);\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    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  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}\nmodule.exports = createTokenizer;","'use strict';\n\nfunction miniflat(value) {\n  return value === null || value === undefined ? [] : 'length' in value ? value : [value];\n}\nmodule.exports = miniflat;","'use strict';\n\n// chunks (replacement characters, tabs, or line endings).\nfunction movePoint(point, offset) {\n  point.column += offset;\n  point.offset += offset;\n  point._bufferIndex += offset;\n  return point;\n}\nmodule.exports = movePoint;","'use strict';\n\nfunction normalizeIdentifier(value) {\n  return 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().toUpperCase();\n}\nmodule.exports = normalizeIdentifier;","'use strict';\n\nvar sizeChunks = require('./size-chunks.js');\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}\nmodule.exports = prefixSize;","'use strict';\n\nvar fromCharCode = require('../constant/from-char-code.js');\nfunction regexCheck(regex) {\n  return check;\n  function check(code) {\n    return regex.test(fromCharCode(code));\n  }\n}\nmodule.exports = regexCheck;","'use strict';\n\nfunction resolveAll(constructs, events, context) {\n  var called = [];\n  var index = -1;\n  var resolve;\n  while (++index < constructs.length) {\n    resolve = constructs[index].resolveAll;\n    if (resolve && called.indexOf(resolve) < 0) {\n      events = resolve(events, context);\n      called.push(resolve);\n    }\n  }\n  return events;\n}\nmodule.exports = resolveAll;","'use strict';\n\nvar fromCharCode = require('../constant/from-char-code.js');\nfunction safeFromInt(value, base) {\n  var code = parseInt(value, base);\n  if (\n  // C0 except for HT, LF, FF, CR, space\n  code < 9 || code === 11 || code > 13 && code < 32 ||\n  // Control character (DEL) of the basic block and C1 controls.\n  code > 126 && code < 160 ||\n  // Lone high surrogates and low surrogates.\n  code > 55295 && code < 57344 ||\n  // Noncharacters.\n  code > 64975 && code < 65008 || (code & 65535) === 65535 || (code & 65535) === 65534 ||\n  // Out of range\n  code > 1114111) {\n    return '\\uFFFD';\n  }\n  return fromCharCode(code);\n}\nmodule.exports = safeFromInt;","'use strict';\n\nvar fromCharCode = require('../constant/from-char-code.js');\nfunction serializeChunks(chunks) {\n  var index = -1;\n  var result = [];\n  var chunk;\n  var value;\n  var atTab;\n  while (++index < chunks.length) {\n    chunk = chunks[index];\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    atTab = chunk === -2;\n    result.push(value);\n  }\n  return result.join('');\n}\nmodule.exports = serializeChunks;","'use strict';\n\nvar assign = require('../constant/assign.js');\nfunction shallow(object) {\n  return assign({}, object);\n}\nmodule.exports = shallow;","'use strict';\n\n// Counts tabs based on their expanded size, and CR+LF as one character.\nfunction sizeChunks(chunks) {\n  var index = -1;\n  var size = 0;\n  while (++index < chunks.length) {\n    size += typeof chunks[index] === 'string' ? chunks[index].length : 1;\n  }\n  return size;\n}\nmodule.exports = sizeChunks;","'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  if (startIndex === endIndex) {\n    view = [chunks[startIndex].slice(startBufferIndex, endBufferIndex)];\n  } else {\n    view = chunks.slice(startIndex, endIndex);\n    if (startBufferIndex > -1) {\n      view[0] = view[0].slice(startBufferIndex);\n    }\n    if (endBufferIndex > 0) {\n      view.push(chunks[endIndex].slice(0, endBufferIndex));\n    }\n  }\n  return view;\n}\nmodule.exports = sliceChunks;","'use strict';\n\nvar assign = require('../constant/assign.js');\nvar chunkedSplice = require('./chunked-splice.js');\nvar shallow = require('./shallow.js');\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  while (++index < events.length) {\n    while (index in jumps) {\n      index = jumps[index];\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 (index && event[1].type === 'chunkFlow' && events[index - 1][1].type === 'listItemPrefix') {\n      subevents = event[1]._tokenizer.events;\n      otherIndex = 0;\n      if (otherIndex < subevents.length && subevents[otherIndex][1].type === 'lineEndingBlank') {\n        otherIndex += 2;\n      }\n      if (otherIndex < subevents.length && subevents[otherIndex][1].type === 'content') {\n        while (++otherIndex < subevents.length) {\n          if (subevents[otherIndex][1].type === 'content') {\n            break;\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      while (otherIndex--) {\n        otherEvent = events[otherIndex];\n        if (otherEvent[1].type === 'lineEnding' || otherEvent[1].type === 'lineEndingBlank') {\n          if (otherEvent[0] === 'enter') {\n            if (lineIndex) {\n              events[lineIndex][1].type = 'lineEndingBlank';\n            }\n            otherEvent[1].type = 'lineEnding';\n            lineIndex = otherIndex;\n          }\n        } else {\n          break;\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  return !more;\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 = 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    startPositions.push(startPosition);\n    if (!token._tokenizer) {\n      stream = context.sliceStream(token);\n      if (!token.next) {\n        stream.push(null);\n      }\n      if (previous) {\n        tokenizer.defineSkip(token.start);\n      }\n      if (token.isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = true;\n      }\n      tokenizer.write(stream);\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  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 && childEvents[index][1].type === childEvents[index - 1][1].type && childEvents[index][1].start.line !== childEvents[index][1].end.line) {\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  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  return gaps;\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}\nmodule.exports = subtokenize;","'use strict';\n\nvar own = {}.hasOwnProperty;\nmodule.exports = stringify;\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}\nfunction point(point) {\n  if (!point || typeof point !== 'object') {\n    point = {};\n  }\n  return index(point.line) + ':' + index(point.column);\n}\nfunction position(pos) {\n  if (!pos || typeof pos !== 'object') {\n    pos = {};\n  }\n  return point(pos.start) + '-' + point(pos.end);\n}\nfunction index(value) {\n  return value && typeof value === 'number' ? value : 1;\n}","'use strict';\n\nvar wrap = require('./wrap.js');\nmodule.exports = trough;\ntrough.wrap = wrap;\nvar slice = [].slice;\n\n// Create new middleware.\nfunction trough() {\n  var fns = [];\n  var middleware = {};\n  middleware.run = run;\n  middleware.use = use;\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    if (typeof done !== 'function') {\n      throw new Error('Expected function as last argument, not ' + done);\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      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      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    fns.push(fn);\n    return middleware;\n  }\n}","'use strict';\n\nvar slice = [].slice;\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  return wrapped;\n  function wrapped() {\n    var params = slice.call(arguments, 0);\n    var callback = fn.length > params.length;\n    var result;\n    if (callback) {\n      params.push(done);\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      return done(error);\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      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}","'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();\nvar slice = [].slice;\nvar own = {}.hasOwnProperty;\n\n// Process pipeline.\nvar pipeline = trough().use(pipelineParse).use(pipelineRun).use(pipelineStringify);\nfunction pipelineParse(p, ctx) {\n  ctx.tree = p.parse(ctx.file);\n}\nfunction pipelineRun(p, ctx, next) {\n  p.run(ctx.tree, ctx.file, done);\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}\nfunction pipelineStringify(p, ctx) {\n  var result = p.stringify(ctx.tree, ctx.file);\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    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    while (++index < attachers.length) {\n      destination.use.apply(null, attachers[index]);\n    }\n    destination.data(extend(true, {}, namespace));\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    if (frozen) {\n      return processor;\n    }\n    while (++freezeIndex < attachers.length) {\n      values = attachers[freezeIndex];\n      if (values[1] === false) {\n        continue;\n      }\n      if (values[1] === true) {\n        values[1] = undefined;\n      }\n      transformer = values[0].apply(processor, values.slice(1));\n      if (typeof transformer === 'function') {\n        transformers.use(transformer);\n      }\n    }\n    frozen = true;\n    freezeIndex = Infinity;\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    assertUnfrozen('use', frozen);\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    if (settings) {\n      namespace.settings = extend(namespace.settings || {}, settings);\n    }\n    return processor;\n    function addPreset(result) {\n      addList(result.plugins);\n      if (result.settings) {\n        settings = extend(settings || {}, result.settings);\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    function addList(plugins) {\n      var index = -1;\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    function addPlugin(plugin, value) {\n      var entry = find(plugin);\n      if (entry) {\n        if (plain(entry[1]) && plain(value)) {\n          value = extend(true, entry[1], value);\n        }\n        entry[1] = value;\n      } else {\n        attachers.push(slice.call(arguments));\n      }\n    }\n  }\n  function find(plugin) {\n    var index = -1;\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    freeze();\n    Parser = processor.Parser;\n    assertParser('parse', Parser);\n    if (newable(Parser, 'parse')) {\n      return new Parser(String(file), file).parse();\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    if (!cb && typeof file === 'function') {\n      cb = file;\n      file = null;\n    }\n    if (!cb) {\n      return new Promise(executor);\n    }\n    executor(null, cb);\n    function executor(resolve, reject) {\n      transformers.run(node, vfile(file), done);\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    run(node, file, done);\n    assertDone('runSync', 'run', complete);\n    return result;\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    freeze();\n    Compiler = processor.Compiler;\n    assertCompiler('stringify', Compiler);\n    assertNode(node);\n    if (newable(Compiler, 'compile')) {\n      return new Compiler(node, file).compile();\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    if (!cb) {\n      return new Promise(executor);\n    }\n    executor(null, cb);\n    function executor(resolve, reject) {\n      var file = vfile(doc);\n      pipeline.run(processor, {\n        file: file\n      }, done);\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    freeze();\n    assertParser('processSync', processor.Parser);\n    assertCompiler('processSync', processor.Compiler);\n    file = vfile(doc);\n    process(file, done);\n    assertDone('processSync', 'process', complete);\n    return file;\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 typeof value === 'function' && 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// Check if `value` is an object with keys.\nfunction keys(value) {\n  var key;\n  for (key in value) {\n    return true;\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('Cannot invoke `' + name + '` on a frozen processor.\\nCreate a new processor first, by invoking it: use `processor()` instead of `processor`.');\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('`' + name + '` finished async. Use `' + asyncName + '` instead');\n  }\n}","'use strict';\n\nmodule.exports = value => {\n  if (Object.prototype.toString.call(value) !== '[object Object]') {\n    return false;\n  }\n  const prototype = Object.getPrototypeOf(value);\n  return prototype === null || prototype === Object.prototype;\n};","'use strict';\n\nmodule.exports = convert;\nfunction convert(test) {\n  if (test == null) {\n    return ok;\n  }\n  if (typeof test === 'string') {\n    return typeFactory(test);\n  }\n  if (typeof test === 'object') {\n    return 'length' in test ? anyFactory(test) : allFactory(test);\n  }\n  if (typeof test === 'function') {\n    return test;\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  function all(node) {\n    var key;\n    for (key in test) {\n      if (node[key] !== test[key]) return false;\n    }\n    return true;\n  }\n}\nfunction anyFactory(tests) {\n  var checks = [];\n  var index = -1;\n  while (++index < tests.length) {\n    checks[index] = convert(tests[index]);\n  }\n  return any;\n  function any() {\n    var index = -1;\n    while (++index < checks.length) {\n      if (checks[index].apply(this, arguments)) {\n        return true;\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  function type(node) {\n    return Boolean(node && node.type === test);\n  }\n}\n\n// Utility to return true.\nfunction ok() {\n  return true;\n}","module.exports = identity;\nfunction identity(d) {\n  return d;\n}","'use strict';\n\nmodule.exports = visitParents;\nvar convert = require('unist-util-is/convert');\nvar color = require('./color');\nvar CONTINUE = true;\nvar SKIP = 'skip';\nvar EXIT = false;\nvisitParents.CONTINUE = CONTINUE;\nvisitParents.SKIP = SKIP;\nvisitParents.EXIT = EXIT;\nfunction visitParents(tree, test, visitor, reverse) {\n  var step;\n  var is;\n  if (typeof test === 'function' && typeof visitor !== 'function') {\n    reverse = visitor;\n    visitor = test;\n    test = null;\n  }\n  is = convert(test);\n  step = reverse ? -1 : 1;\n  factory(tree, null, [])();\n  function factory(node, index, parents) {\n    var value = typeof node === 'object' && node !== null ? node : {};\n    var name;\n    if (typeof value.type === 'string') {\n      name = typeof value.tagName === 'string' ? value.tagName : typeof value.name === 'string' ? value.name : undefined;\n      visit.displayName = 'node (' + color(value.type + (name ? '<' + name + '>' : '')) + ')';\n    }\n    return visit;\n    function visit() {\n      var grandparents = parents.concat(node);\n      var result = [];\n      var subresult;\n      var offset;\n      if (!test || is(node, index, parents[parents.length - 1] || null)) {\n        result = toResult(visitor(node, parents));\n        if (result[0] === EXIT) {\n          return result;\n        }\n      }\n      if (node.children && result[0] !== SKIP) {\n        offset = (reverse ? node.children.length : -1) + step;\n        while (offset > -1 && offset < node.children.length) {\n          subresult = factory(node.children[offset], offset, grandparents)();\n          if (subresult[0] === EXIT) {\n            return subresult;\n          }\n          offset = typeof subresult[1] === 'number' ? subresult[1] : offset + step;\n        }\n      }\n      return result;\n    }\n  }\n}\nfunction toResult(value) {\n  if (value !== null && typeof value === 'object' && 'length' in value) {\n    return value;\n  }\n  if (typeof value === 'number') {\n    return [CONTINUE, value];\n  }\n  return [value];\n}","'use strict';\n\nmodule.exports = visit;\nvar visitParents = require('unist-util-visit-parents');\nvar CONTINUE = visitParents.CONTINUE;\nvar SKIP = visitParents.SKIP;\nvar EXIT = visitParents.EXIT;\nvisit.CONTINUE = CONTINUE;\nvisit.SKIP = SKIP;\nvisit.EXIT = EXIT;\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  visitParents(tree, test, overload, reverse);\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}","'use strict';\n\nmodule.exports = require('./lib');","'use strict';\n\nvar p = require('./minpath');\nvar proc = require('./minproc');\nvar buffer = require('is-buffer');\nmodule.exports = VFile;\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'];\nVFile.prototype.toString = toString;\n\n// Access full path (`~/index.min.js`).\nObject.defineProperty(VFile.prototype, 'path', {\n  get: getPath,\n  set: setPath\n});\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', {\n  get: getStem,\n  set: setStem\n});\n\n// Construct a new file.\nfunction VFile(options) {\n  var prop;\n  var index;\n  if (!options) {\n    options = {};\n  } else if (typeof options === 'string' || buffer(options)) {\n    options = {\n      contents: options\n    };\n  } else if ('message' in options && 'messages' in options) {\n    return options;\n  }\n  if (!(this instanceof VFile)) {\n    return new VFile(options);\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  while (++index < order.length) {\n    prop = order[index];\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}\nfunction getPath() {\n  return this.history[this.history.length - 1];\n}\nfunction setPath(path) {\n  assertNonEmpty(path, 'path');\n  if (this.path !== path) {\n    this.history.push(path);\n  }\n}\nfunction getDirname() {\n  return typeof this.path === 'string' ? p.dirname(this.path) : undefined;\n}\nfunction setDirname(dirname) {\n  assertPath(this.path, 'dirname');\n  this.path = p.join(dirname || '', this.basename);\n}\nfunction getBasename() {\n  return typeof this.path === 'string' ? p.basename(this.path) : undefined;\n}\nfunction setBasename(basename) {\n  assertNonEmpty(basename, 'basename');\n  assertPart(basename, 'basename');\n  this.path = p.join(this.dirname || '', basename);\n}\nfunction getExtname() {\n  return typeof this.path === 'string' ? p.extname(this.path) : undefined;\n}\nfunction setExtname(extname) {\n  assertPart(extname, 'extname');\n  assertPath(this.path, 'extname');\n  if (extname) {\n    if (extname.charCodeAt(0) !== 46 /* `.` */) {\n      throw new Error('`extname` must start with `.`');\n    }\n    if (extname.indexOf('.', 1) > -1) {\n      throw new Error('`extname` cannot contain multiple dots');\n    }\n  }\n  this.path = p.join(this.dirname, this.stem + (extname || ''));\n}\nfunction getStem() {\n  return typeof this.path === 'string' ? p.basename(this.path, this.extname) : undefined;\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('`' + name + '` cannot be a path: did not expect `' + p.sep + '`');\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}","'use strict';\n\nvar VMessage = require('vfile-message');\nvar VFile = require('./core.js');\nmodule.exports = VFile;\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  if (this.path) {\n    message.name = this.path + ':' + message.name;\n    message.file = this.path;\n  }\n  message.fatal = false;\n  this.messages.push(message);\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  message.fatal = true;\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  message.fatal = null;\n  return message;\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.\nexports.basename = basename;\nexports.dirname = dirname;\nexports.extname = extname;\nexports.join = join;\nexports.sep = '/';\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  if (ext !== undefined && typeof ext !== 'string') {\n    throw new TypeError('\"ext\" argument must be a string');\n  }\n  assertPath(path);\n  index = path.length;\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    return end < 0 ? '' : path.slice(start, end);\n  }\n  if (ext === path) {\n    return '';\n  }\n  firstNonSlashEnd = -1;\n  extIndex = ext.length - 1;\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      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  if (start === end) {\n    end = firstNonSlashEnd;\n  } else if (end < 0) {\n    end = path.length;\n  }\n  return path.slice(start, end);\n}\nfunction dirname(path) {\n  var end;\n  var unmatchedSlash;\n  var index;\n  assertPath(path);\n  if (!path.length) {\n    return '.';\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  return end < 0 ? path.charCodeAt(0) === 47 /* `/` */ ? '/' : '.' : end === 1 && path.charCodeAt(0) === 47 /* `/` */ ? '//' : path.slice(0, end);\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  assertPath(path);\n  index = path.length;\n  while (index--) {\n    code = path.charCodeAt(index);\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      continue;\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    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  if (startDot < 0 || 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    return '';\n  }\n  return path.slice(startDot, end);\n}\nfunction join() {\n  var index = -1;\n  var joined;\n  while (++index < arguments.length) {\n    assertPath(arguments[index]);\n    if (arguments[index]) {\n      joined = joined === undefined ? arguments[index] : joined + '/' + arguments[index];\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  assertPath(path);\n  absolute = path.charCodeAt(0) === 47; /* `/` */\n\n  // Normalize the path according to POSIX rules.\n  value = normalizeString(path, !absolute);\n  if (!value.length && !absolute) {\n    value = '.';\n  }\n  if (value.length && path.charCodeAt(path.length - 1) === 47 /* / */) {\n    value += '/';\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  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 (result.length < 2 || lastSegmentLength !== 2 || result.charCodeAt(result.length - 1) !== 46 /* `.` */ || result.charCodeAt(result.length - 2) !== 46 /* `.` */) {\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              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        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        lastSegmentLength = index - lastSlash - 1;\n      }\n      lastSlash = index;\n      dots = 0;\n    } else if (code === 46 /* `.` */ && dots > -1) {\n      dots++;\n    } else {\n      dots = -1;\n    }\n  }\n  return result;\n}\nfunction assertPath(path) {\n  if (typeof path !== 'string') {\n    throw new TypeError('Path must be a string. Received ' + JSON.stringify(path));\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;\nfunction cwd() {\n  return '/';\n}","'use strict';\n\nvar own = {}.hasOwnProperty;\nmodule.exports = stringify;\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}\nfunction point(point) {\n  if (!point || typeof point !== 'object') {\n    point = {};\n  }\n  return index(point.line) + ':' + index(point.column);\n}\nfunction position(pos) {\n  if (!pos || typeof pos !== 'object') {\n    pos = {};\n  }\n  return point(pos.start) + '-' + point(pos.end);\n}\nfunction index(value) {\n  return value && typeof value === 'number' ? value : 1;\n}","'use strict';\n\nvar stringify = require('unist-util-stringify-position');\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;\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  if (typeof position === 'string') {\n    origin = position;\n    position = null;\n  }\n  parts = parseOrigin(origin);\n  range = stringify(position) || '1:1';\n  location = {\n    start: {\n      line: null,\n      column: null\n    },\n    end: {\n      line: null,\n      column: null\n    }\n  };\n\n  // Node.\n  if (position && position.position) {\n    position = position.position;\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  if (reason.stack) {\n    this.stack = reason.stack;\n    reason = reason.message;\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}\nfunction parseOrigin(origin) {\n  var result = [null, null];\n  var index;\n  if (typeof origin === 'string') {\n    index = origin.indexOf(':');\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  return result;\n}","module.exports = extend;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nfunction extend() {\n  var target = {};\n  for (var i = 0; i < arguments.length; i++) {\n    var source = arguments[i];\n    for (var key in source) {\n      if (hasOwnProperty.call(source, key)) {\n        target[key] = source[key];\n      }\n    }\n  }\n  return target;\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","el","characters","char","entity","document","createElement","innerHTML","textContent","charCodeAt","b","Symbol","for","c","d","e","f","g","h","k","l","m","p","q","r","t","v","w","x","y","z","a","u","$$typeof","A","AsyncMode","ConcurrentMode","ContextConsumer","ContextProvider","Element","ForwardRef","Fragment","Lazy","Memo","Portal","Profiler","StrictMode","Suspense","isAsyncMode","isConcurrentMode","isContextConsumer","isContextProvider","isElement","isForwardRef","isFragment","isLazy","isMemo","isPortal","isProfiler","isStrictMode","isSuspense","isValidElementType","typeOf","React","xtend","ReactIs","astToReact","undefined","renderer","renderers","position","start","line","column","offset","end","pos","join","Error","nodeProps","opts","props","isSimpleRenderer","sourcePos","map","String","flattenPosition","rawSourcePos","sourcePosition","includeNodeIndex","indexOf","parentChildCount","ref","identifier","definitions","toUpperCase","assignDefined","className","nodeKey","level","spread","checked","loose","listItemLoose","listLoose","reduce","array","unwrapParagraphs","getListItemChildren","childNode","title","url","language","lang","split","inline","linkTarget","href","transformLinkUri","transformImageUri","alt","columnAlignment","align","isHeader","tag","isBlock","allowDangerousHtml","escapeHtml","skipHtml","parsedChildren","element","Children","toArray","cloneElement","mergeNodeChildren","getNodeProps","attrs","visit","splice","ifNotMatch","allow","mode","filter","parameters","apply","ofType","types","includes","selfClosingRe","simpleTagRe","open","currentParent","selfClosing","match","getSelfClosing","current","opening","getSimpleTag","matching","matchingTag","findAndPull","fromNode","toNode","fromIndex","toIndex","extracted","slice","indent","virtual","unified","parse","PropTypes","addListMetadata","naiveHtml","disallowNode","wrapTableRows","getDefinitions","uriTransformer","defaultRenderers","symbols","allTypes","keys","ReactMarkdown","source","allowedTypes","disallowedTypes","processor","use","plugins","runSync","renderProps","transforms","removalMethod","unwrapDisallowed","allowNode","renderHtml","hasHtmlParser","astPlugins","some","transform","identity","HtmlParser","determineAstToReactTransforms","forEach","defaultProps","propTypes","string","bool","func","arrayOf","oneOf","oneOfType","object","supportsStringRender","parseInt","version","SimpleRenderer","getCoreProps","break","paragraph","emphasis","strong","thematicBreak","blockquote","delete","link","image","linkReference","imageReference","table","bind","tableHead","tableBody","tableRow","tableCell","style","textAlign","coreProps","root","text","list","listItem","checkbox","readOnly","definition","heading","inlineCode","code","html","dangerous","dangerouslySetInnerHTML","__html","virtualHtml","parsedHtml","protocols","uri","trim","first","charAt","colon","protocol","toLowerCase","wrap","self","this","Parser","doc","fromMarkdown","assign","data","extensions","mdastExtensions","encoding","settings","config","extension","configure","canContainEols","enter","autolink","opener","autolinkProtocol","onenterdata","autolinkEmail","atxHeading","blockQuote","characterEscape","characterReference","codeFenced","codeFlow","codeFencedFenceInfo","buffer","codeFencedFenceMeta","codeIndented","codeText","codeTextData","codeFlowValue","definitionDestinationString","definitionLabelString","definitionTitleString","hardBreakEscape","hardBreak","hardBreakTrailing","htmlFlow","htmlFlowData","htmlText","htmlTextData","label","listItemValue","onenterlistitemvalue","listOrdered","onenterlistordered","listUnordered","reference","onenterreference","referenceString","resourceDestinationString","resourceTitleString","setextHeading","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","compile","events","handler","tokenStack","listStack","context","resume","setData","getData","prepareList","own","sliceSerialize","stringifyPosition","point","tailIndex","lineIndex","tailEvent","event","firstBlankLineIndex","atMarker","containerBalance","listSpread","_spread","create","and","token","close","meta","replace","normalizeIdentifier","siblings","tail","referenceType","fragment","safeFromInt","decode","compiler","postprocess","parser","write","preprocessor","left","values","asciiAlpha","regexCheck","asciiAlphanumeric","asciiAtext","asciiDigit","asciiHexDigit","asciiPunctuation","unicodePunctuationRegex","unicodePunctuation","unicodeWhitespace","fromCharCode","text$1","attention","headingAtx","labelEnd","labelStartImage","labelStartLink","setextUnderline","contentInitial","flowInitial","flow","insideSpan","null","resolver","disable","markdownLineEnding","factorySpace","tokenize","effects","previous","contentStart","attempt","constructs","consume","lineStart","contentType","next","partialBlankLine","inspectResult","childFlow","childToken","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","startPosition","endPosition","lastIndex","exec","Math","ceil","chunkedPush","chunkedSplice","classifyCharacter","movePoint","marker","before","sequence","after","_open","_close","group","openingSequence","closingSequence","nextEvents","asciiControl","schemeOrEmailAtext","emailAtext","schemeInsideOrEmailAtext","urlInside","emailAtSignOrDot","emailLabel","emailValue","markdownSpace","_container","decodeEntity","_interopDefaultLegacy","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","chunkStart","unshift","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","regex","called","base","atTab","view","startIndex","startBufferIndex","endIndex","endBufferIndex","subcontent","stream","entered","adjust","startPositions","tokenizer","childEvents","jumps","gaps","isInFirstContentOfListItem","_gfmTasklistFirstContentOfListItem","otherIndex","otherEvent","subevents","more","_movePreviousLineEndings","trough","fns","middleware","input","fn","callback","invoked","params","error","then","bail","plain","vfile","frozen","attachers","transformers","namespace","freezeIndex","assertUnfrozen","freeze","addPlugin","addList","addPreset","plugin","entry","find","file","assertParser","newable","stringify","Compiler","assertCompiler","assertNode","run","complete","assertDone","process","processSync","destination","transformer","cb","Promise","executor","reject","pipeline","ctx","contents","asyncName","getPrototypeOf","convert","Boolean","typeFactory","tests","checks","any","anyFactory","allFactory","visitParents","color","CONTINUE","SKIP","EXIT","reverse","step","is","factory","displayName","subresult","grandparents","toResult","proc","VFile","order","prop","messages","history","cwd","assertPart","part","sep","assertNonEmpty","assertPath","path","get","set","dirname","basename","extname","stem","VMessage","message","reason","origin","fatal","fail","TypeError","JSON","ext","firstNonSlashEnd","seenNonSlash","extIndex","unmatchedSlash","startDot","startPart","preDotState","joined","absolute","allowAboveRoot","lastSlashIndex","lastSegmentLength","lastSlash","dots","lastIndexOf","normalizeString","normalize","VMessagePrototype","proto","parts","range","location","parseOrigin","ruleId"],"sourceRoot":""}