{"version":3,"file":"7d022848047af916b8447fd5574346ac347348b9-a03c5ac215ee5eb40660.js","mappings":"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","sources":["webpack://n-ou/./node_modules/bail/index.js","webpack://n-ou/./node_modules/ccount/index.js","webpack://n-ou/./node_modules/extend/index.js","webpack://n-ou/./node_modules/is-buffer/index.js","webpack://n-ou/./node_modules/markdown-table/index.js","webpack://n-ou/./node_modules/mdast-add-list-metadata/index.js","webpack://n-ou/./node_modules/mdast-add-list-metadata/node_modules/unist-util-visit-parents/index.js","webpack://n-ou/./node_modules/mdast-util-find-and-replace/index.js","webpack://n-ou/./node_modules/mdast-util-find-and-replace/node_modules/escape-string-regexp/index.js","webpack://n-ou/./node_modules/mdast-util-from-markdown/dist/index.js","webpack://n-ou/./node_modules/mdast-util-from-markdown/index.js","webpack://n-ou/./node_modules/mdast-util-gfm-autolink-literal/from-markdown.js","webpack://n-ou/./node_modules/mdast-util-gfm-autolink-literal/to-markdown.js","webpack://n-ou/./node_modules/mdast-util-gfm-strikethrough/from-markdown.js","webpack://n-ou/./node_modules/mdast-util-gfm-strikethrough/to-markdown.js","webpack://n-ou/./node_modules/mdast-util-gfm-table/from-markdown.js","webpack://n-ou/./node_modules/mdast-util-gfm-table/to-markdown.js","webpack://n-ou/./node_modules/mdast-util-gfm-task-list-item/from-markdown.js","webpack://n-ou/./node_modules/mdast-util-gfm-task-list-item/to-markdown.js","webpack://n-ou/./node_modules/mdast-util-gfm/from-markdown.js","webpack://n-ou/./node_modules/mdast-util-gfm/to-markdown.js","webpack://n-ou/./node_modules/mdast-util-to-markdown/lib/configure.js","webpack://n-ou/./node_modules/mdast-util-to-markdown/lib/handle/inline-code.js","webpack://n-ou/./node_modules/mdast-util-to-markdown/lib/handle/list-item.js","webpack://n-ou/./node_modules/mdast-util-to-markdown/lib/util/check-bullet.js","webpack://n-ou/./node_modules/mdast-util-to-markdown/lib/util/check-list-item-indent.js","webpack://n-ou/./node_modules/mdast-util-to-markdown/lib/util/container-flow.js","webpack://n-ou/./node_modules/mdast-util-to-markdown/lib/util/container-phrasing.js","webpack://n-ou/./node_modules/mdast-util-to-markdown/lib/util/indent-lines.js","webpack://n-ou/./node_modules/mdast-util-to-markdown/lib/util/pattern-compile.js","webpack://n-ou/./node_modules/mdast-util-to-string/index.js","webpack://n-ou/./node_modules/micromark-extension-gfm-autolink-literal/index.js","webpack://n-ou/./node_modules/micromark-extension-gfm-autolink-literal/syntax.js","webpack://n-ou/./node_modules/micromark-extension-gfm-strikethrough/index.js","webpack://n-ou/./node_modules/micromark-extension-gfm-table/index.js","webpack://n-ou/./node_modules/micromark-extension-gfm-table/syntax.js","webpack://n-ou/./node_modules/micromark-extension-gfm-task-list-item/index.js","webpack://n-ou/./node_modules/micromark-extension-gfm-task-list-item/syntax.js","webpack://n-ou/./node_modules/micromark-extension-gfm/index.js","webpack://n-ou/./node_modules/micromark-extension-gfm/syntax.js","webpack://n-ou/./node_modules/micromark/dist/character/ascii-alpha.js","webpack://n-ou/./node_modules/micromark/dist/character/ascii-alphanumeric.js","webpack://n-ou/./node_modules/micromark/dist/character/ascii-atext.js","webpack://n-ou/./node_modules/micromark/dist/character/ascii-control.js","webpack://n-ou/./node_modules/micromark/dist/character/ascii-digit.js","webpack://n-ou/./node_modules/micromark/dist/character/ascii-hex-digit.js","webpack://n-ou/./node_modules/micromark/dist/character/ascii-punctuation.js","webpack://n-ou/./node_modules/micromark/dist/character/markdown-line-ending-or-space.js","webpack://n-ou/./node_modules/micromark/dist/character/markdown-line-ending.js","webpack://n-ou/./node_modules/micromark/dist/character/markdown-space.js","webpack://n-ou/./node_modules/micromark/dist/character/unicode-punctuation.js","webpack://n-ou/./node_modules/micromark/dist/character/unicode-whitespace.js","webpack://n-ou/./node_modules/micromark/dist/constant/assign.js","webpack://n-ou/./node_modules/micromark/dist/constant/from-char-code.js","webpack://n-ou/./node_modules/micromark/dist/constant/has-own-property.js","webpack://n-ou/./node_modules/micromark/dist/constant/html-block-names.js","webpack://n-ou/./node_modules/micromark/dist/constant/html-raw-names.js","webpack://n-ou/./node_modules/micromark/dist/constant/splice.js","webpack://n-ou/./node_modules/micromark/dist/constant/unicode-punctuation-regex.js","webpack://n-ou/./node_modules/micromark/dist/constructs.js","webpack://n-ou/./node_modules/micromark/dist/initialize/content.js","webpack://n-ou/./node_modules/micromark/dist/initialize/document.js","webpack://n-ou/./node_modules/micromark/dist/initialize/flow.js","webpack://n-ou/./node_modules/micromark/dist/initialize/text.js","webpack://n-ou/./node_modules/micromark/dist/parse.js","webpack://n-ou/./node_modules/micromark/dist/postprocess.js","webpack://n-ou/./node_modules/micromark/dist/preprocess.js","webpack://n-ou/./node_modules/micromark/dist/tokenize/attention.js","webpack://n-ou/./node_modules/micromark/dist/tokenize/autolink.js","webpack://n-ou/./node_modules/micromark/dist/tokenize/block-quote.js","webpack://n-ou/./node_modules/micromark/dist/tokenize/character-escape.js","webpack://n-ou/./node_modules/micromark/dist/tokenize/character-reference.js","webpack://n-ou/./node_modules/micromark/dist/tokenize/code-fenced.js","webpack://n-ou/./node_modules/micromark/dist/tokenize/code-indented.js","webpack://n-ou/./node_modules/micromark/dist/tokenize/code-text.js","webpack://n-ou/./node_modules/micromark/dist/tokenize/content.js","webpack://n-ou/./node_modules/micromark/dist/tokenize/definition.js","webpack://n-ou/./node_modules/micromark/dist/tokenize/factory-destination.js","webpack://n-ou/./node_modules/micromark/dist/tokenize/factory-label.js","webpack://n-ou/./node_modules/micromark/dist/tokenize/factory-space.js","webpack://n-ou/./node_modules/micromark/dist/tokenize/factory-title.js","webpack://n-ou/./node_modules/micromark/dist/tokenize/factory-whitespace.js","webpack://n-ou/./node_modules/micromark/dist/tokenize/hard-break-escape.js","webpack://n-ou/./node_modules/micromark/dist/tokenize/heading-atx.js","webpack://n-ou/./node_modules/micromark/dist/tokenize/html-flow.js","webpack://n-ou/./node_modules/micromark/dist/tokenize/html-text.js","webpack://n-ou/./node_modules/micromark/dist/tokenize/label-end.js","webpack://n-ou/./node_modules/micromark/dist/tokenize/label-start-image.js","webpack://n-ou/./node_modules/micromark/dist/tokenize/label-start-link.js","webpack://n-ou/./node_modules/micromark/dist/tokenize/line-ending.js","webpack://n-ou/./node_modules/micromark/dist/tokenize/list.js","webpack://n-ou/./node_modules/micromark/dist/tokenize/partial-blank-line.js","webpack://n-ou/./node_modules/micromark/dist/tokenize/setext-underline.js","webpack://n-ou/./node_modules/micromark/dist/tokenize/thematic-break.js","webpack://n-ou/./node_modules/micromark/dist/util/chunked-push.js","webpack://n-ou/./node_modules/micromark/dist/util/chunked-splice.js","webpack://n-ou/./node_modules/micromark/dist/util/classify-character.js","webpack://n-ou/./node_modules/micromark/dist/util/combine-extensions.js","webpack://n-ou/./node_modules/micromark/dist/util/create-tokenizer.js","webpack://n-ou/./node_modules/micromark/dist/util/miniflat.js","webpack://n-ou/./node_modules/micromark/dist/util/move-point.js","webpack://n-ou/./node_modules/micromark/dist/util/normalize-identifier.js","webpack://n-ou/./node_modules/micromark/dist/util/prefix-size.js","webpack://n-ou/./node_modules/micromark/dist/util/regex-check.js","webpack://n-ou/./node_modules/micromark/dist/util/resolve-all.js","webpack://n-ou/./node_modules/micromark/dist/util/safe-from-int.js","webpack://n-ou/./node_modules/micromark/dist/util/serialize-chunks.js","webpack://n-ou/./node_modules/micromark/dist/util/shallow.js","webpack://n-ou/./node_modules/micromark/dist/util/size-chunks.js","webpack://n-ou/./node_modules/micromark/dist/util/slice-chunks.js","webpack://n-ou/./node_modules/micromark/dist/util/subtokenize.js","webpack://n-ou/./node_modules/parse-entities/decode-entity.browser.js","webpack://n-ou/./node_modules/react-is/cjs/react-is.production.min.js","webpack://n-ou/./node_modules/react-is/index.js","webpack://n-ou/./node_modules/react-markdown/lib/ast-to-react.js","webpack://n-ou/./node_modules/react-markdown/lib/get-definitions.js","webpack://n-ou/./node_modules/react-markdown/lib/plugins/disallow-node.js","webpack://n-ou/./node_modules/react-markdown/lib/plugins/naive-html.js","webpack://n-ou/./node_modules/react-markdown/lib/react-markdown.js","webpack://n-ou/./node_modules/react-markdown/lib/renderers.js","webpack://n-ou/./node_modules/react-markdown/lib/symbols.js","webpack://n-ou/./node_modules/react-markdown/lib/uri-transformer.js","webpack://n-ou/./node_modules/react-markdown/lib/wrap-table-rows.js","webpack://n-ou/./node_modules/react-markdown/node_modules/is-plain-obj/index.js","webpack://n-ou/./node_modules/react-markdown/node_modules/remark-parse/index.js","webpack://n-ou/./node_modules/react-markdown/node_modules/unified/index.js","webpack://n-ou/./node_modules/remark-gfm/index.js","webpack://n-ou/./node_modules/repeat-string/index.js","webpack://n-ou/./node_modules/slugger/slugger.js","webpack://n-ou/./node_modules/trough/index.js","webpack://n-ou/./node_modules/trough/wrap.js","webpack://n-ou/./node_modules/unist-util-is/convert.js","webpack://n-ou/./node_modules/unist-util-stringify-position/index.js","webpack://n-ou/./node_modules/unist-util-visit-parents/color.browser.js","webpack://n-ou/./node_modules/unist-util-visit-parents/index.js","webpack://n-ou/./node_modules/unist-util-visit/index.js","webpack://n-ou/./node_modules/vfile-message/index.js","webpack://n-ou/./node_modules/vfile/index.js","webpack://n-ou/./node_modules/vfile/lib/core.js","webpack://n-ou/./node_modules/vfile/lib/index.js","webpack://n-ou/./node_modules/vfile/lib/minpath.browser.js","webpack://n-ou/./node_modules/vfile/lib/minproc.browser.js","webpack://n-ou/./node_modules/xtend/immutable.js","webpack://n-ou/./utils/language.js","webpack://n-ou/./utils/rendermarkdown.js"],"sourcesContent":["'use strict';\n\nmodule.exports = bail;\n\nfunction bail(err) {\n  if (err) {\n    throw err;\n  }\n}","'use strict';\n\nmodule.exports = ccount;\n\nfunction ccount(source, character) {\n  var value = String(source);\n  var count = 0;\n  var index;\n\n  if (typeof character !== 'string') {\n    throw new Error('Expected character');\n  }\n\n  index = value.indexOf(character);\n\n  while (index !== -1) {\n    count++;\n    index = value.indexOf(character, index + character.length);\n  }\n\n  return count;\n}","'use strict';\n\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar toStr = Object.prototype.toString;\nvar defineProperty = Object.defineProperty;\nvar gOPD = Object.getOwnPropertyDescriptor;\n\nvar isArray = function isArray(arr) {\n  if (typeof Array.isArray === 'function') {\n    return Array.isArray(arr);\n  }\n\n  return toStr.call(arr) === '[object Array]';\n};\n\nvar isPlainObject = function isPlainObject(obj) {\n  if (!obj || toStr.call(obj) !== '[object Object]') {\n    return false;\n  }\n\n  var hasOwnConstructor = hasOwn.call(obj, 'constructor');\n  var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf'); // Not own constructor property must be Object\n\n  if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {\n    return false;\n  } // Own properties are enumerated firstly, so to speed up,\n  // if last one is own, then all properties are own.\n\n\n  var key;\n\n  for (key in obj) {\n    /**/\n  }\n\n  return typeof key === 'undefined' || hasOwn.call(obj, key);\n}; // If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target\n\n\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}; // Return undefined instead of __proto__ if '__proto__' is not an own property\n\n\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\n  return obj[name];\n};\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; // Handle a deep copy situation\n\n  if (typeof target === 'boolean') {\n    deep = target;\n    target = arguments[1] || {}; // skip the boolean and the target\n\n    i = 2;\n  }\n\n  if (target == null || typeof target !== 'object' && typeof target !== 'function') {\n    target = {};\n  }\n\n  for (; i < length; ++i) {\n    options = arguments[i]; // Only deal with non-null/undefined values\n\n    if (options != null) {\n      // Extend the base object\n      for (name in options) {\n        src = getProperty(target, name);\n        copy = getProperty(options, name); // Prevent never-ending loop\n\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            } // Never move original objects, clone them\n\n\n            setProperty(target, {\n              name: name,\n              newValue: extend(deep, clone, copy)\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  } // Return the modified object\n\n\n  return target;\n};","/*!\n * Determine if an object is a Buffer\n *\n * @author   Feross Aboukhadijeh <https://feross.org>\n * @license  MIT\n */\nmodule.exports = function isBuffer(obj) {\n  return obj != null && obj.constructor != null && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj);\n};","'use strict';\n\nvar repeat = require('repeat-string');\n\nmodule.exports = markdownTable;\nvar trailingWhitespace = / +$/; // Characters.\n\nvar space = ' ';\nvar lineFeed = '\\n';\nvar dash = '-';\nvar colon = ':';\nvar verticalBar = '|';\nvar x = 0;\nvar C = 67;\nvar L = 76;\nvar R = 82;\nvar c = 99;\nvar l = 108;\nvar r = 114; // Create a table from a matrix of strings.\n\nfunction markdownTable(table, options) {\n  var settings = options || {};\n  var padding = settings.padding !== false;\n  var start = settings.delimiterStart !== false;\n  var end = settings.delimiterEnd !== false;\n  var align = (settings.align || []).concat();\n  var alignDelimiters = settings.alignDelimiters !== false;\n  var alignments = [];\n  var stringLength = settings.stringLength || defaultStringLength;\n  var rowIndex = -1;\n  var rowLength = table.length;\n  var cellMatrix = [];\n  var sizeMatrix = [];\n  var row = [];\n  var sizes = [];\n  var longestCellByColumn = [];\n  var mostCellsPerRow = 0;\n  var cells;\n  var columnIndex;\n  var columnLength;\n  var largest;\n  var size;\n  var cell;\n  var lines;\n  var line;\n  var before;\n  var after;\n  var code; // This is a superfluous loop if we don’t align delimiters, but otherwise we’d\n  // do superfluous work when aligning, so optimize for aligning.\n\n  while (++rowIndex < rowLength) {\n    cells = table[rowIndex];\n    columnIndex = -1;\n    columnLength = cells.length;\n    row = [];\n    sizes = [];\n\n    if (columnLength > mostCellsPerRow) {\n      mostCellsPerRow = columnLength;\n    }\n\n    while (++columnIndex < columnLength) {\n      cell = serialize(cells[columnIndex]);\n\n      if (alignDelimiters === true) {\n        size = stringLength(cell);\n        sizes[columnIndex] = size;\n        largest = longestCellByColumn[columnIndex];\n\n        if (largest === undefined || size > largest) {\n          longestCellByColumn[columnIndex] = size;\n        }\n      }\n\n      row.push(cell);\n    }\n\n    cellMatrix[rowIndex] = row;\n    sizeMatrix[rowIndex] = sizes;\n  } // Figure out which alignments to use.\n\n\n  columnIndex = -1;\n  columnLength = mostCellsPerRow;\n\n  if (typeof align === 'object' && 'length' in align) {\n    while (++columnIndex < columnLength) {\n      alignments[columnIndex] = toAlignment(align[columnIndex]);\n    }\n  } else {\n    code = toAlignment(align);\n\n    while (++columnIndex < columnLength) {\n      alignments[columnIndex] = code;\n    }\n  } // Inject the alignment row.\n\n\n  columnIndex = -1;\n  columnLength = mostCellsPerRow;\n  row = [];\n  sizes = [];\n\n  while (++columnIndex < columnLength) {\n    code = alignments[columnIndex];\n    before = '';\n    after = '';\n\n    if (code === l) {\n      before = colon;\n    } else if (code === r) {\n      after = colon;\n    } else if (code === c) {\n      before = colon;\n      after = colon;\n    } // There *must* be at least one hyphen-minus in each alignment cell.\n\n\n    size = alignDelimiters ? Math.max(1, longestCellByColumn[columnIndex] - before.length - after.length) : 1;\n    cell = before + repeat(dash, size) + after;\n\n    if (alignDelimiters === true) {\n      size = before.length + size + after.length;\n\n      if (size > longestCellByColumn[columnIndex]) {\n        longestCellByColumn[columnIndex] = size;\n      }\n\n      sizes[columnIndex] = size;\n    }\n\n    row[columnIndex] = cell;\n  } // Inject the alignment row.\n\n\n  cellMatrix.splice(1, 0, row);\n  sizeMatrix.splice(1, 0, sizes);\n  rowIndex = -1;\n  rowLength = cellMatrix.length;\n  lines = [];\n\n  while (++rowIndex < rowLength) {\n    row = cellMatrix[rowIndex];\n    sizes = sizeMatrix[rowIndex];\n    columnIndex = -1;\n    columnLength = mostCellsPerRow;\n    line = [];\n\n    while (++columnIndex < columnLength) {\n      cell = row[columnIndex] || '';\n      before = '';\n      after = '';\n\n      if (alignDelimiters === true) {\n        size = longestCellByColumn[columnIndex] - (sizes[columnIndex] || 0);\n        code = alignments[columnIndex];\n\n        if (code === r) {\n          before = repeat(space, size);\n        } else if (code === c) {\n          if (size % 2 === 0) {\n            before = repeat(space, size / 2);\n            after = before;\n          } else {\n            before = repeat(space, size / 2 + 0.5);\n            after = repeat(space, size / 2 - 0.5);\n          }\n        } else {\n          after = repeat(space, size);\n        }\n      }\n\n      if (start === true && columnIndex === 0) {\n        line.push(verticalBar);\n      }\n\n      if (padding === true && // Don’t add the opening space if we’re not aligning and the cell is\n      // empty: there will be a closing space.\n      !(alignDelimiters === false && cell === '') && (start === true || columnIndex !== 0)) {\n        line.push(space);\n      }\n\n      if (alignDelimiters === true) {\n        line.push(before);\n      }\n\n      line.push(cell);\n\n      if (alignDelimiters === true) {\n        line.push(after);\n      }\n\n      if (padding === true) {\n        line.push(space);\n      }\n\n      if (end === true || columnIndex !== columnLength - 1) {\n        line.push(verticalBar);\n      }\n    }\n\n    line = line.join('');\n\n    if (end === false) {\n      line = line.replace(trailingWhitespace, '');\n    }\n\n    lines.push(line);\n  }\n\n  return lines.join(lineFeed);\n}\n\nfunction serialize(value) {\n  return value === null || value === undefined ? '' : String(value);\n}\n\nfunction defaultStringLength(value) {\n  return value.length;\n}\n\nfunction toAlignment(value) {\n  var code = typeof value === 'string' ? value.charCodeAt(0) : x;\n  return code === L || code === l ? l : code === R || code === r ? r : code === C || code === c ? c : x;\n}","var visitWithParents = require('unist-util-visit-parents');\n\nfunction addListMetadata() {\n  return function (ast) {\n    visitWithParents(ast, 'list', function (listNode, parents) {\n      var depth = 0,\n          i,\n          n;\n\n      for (i = 0, n = parents.length; i < n; i++) {\n        if (parents[i].type === 'list') depth += 1;\n      }\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\n      listNode.depth = depth;\n    });\n    return ast;\n  };\n}\n\nmodule.exports = addListMetadata;","'use strict';\n/* Expose. */\n\nmodule.exports = visitParents;\n/* Visit. */\n\nfunction visitParents(tree, type, visitor) {\n  var stack = [];\n\n  if (typeof type === 'function') {\n    visitor = type;\n    type = null;\n  }\n\n  one(tree);\n  /* Visit a single node. */\n\n  function one(node) {\n    var result;\n\n    if (!type || node.type === type) {\n      result = visitor(node, stack.concat());\n    }\n\n    if (node.children && result !== false) {\n      return all(node.children, node);\n    }\n\n    return result;\n  }\n  /* Visit children in `parent`. */\n\n\n  function all(children, parent) {\n    var length = children.length;\n    var index = -1;\n    var child;\n    stack.push(parent);\n\n    while (++index < length) {\n      child = children[index];\n\n      if (child && one(child) === false) {\n        return false;\n      }\n    }\n\n    stack.pop();\n    return true;\n  }\n}","'use strict';\n\nmodule.exports = findAndReplace;\n\nvar visit = require('unist-util-visit-parents');\n\nvar convert = require('unist-util-is/convert');\n\nvar escape = require('escape-string-regexp');\n\nvar splice = [].splice;\n\nfunction findAndReplace(tree, find, replace, options) {\n  var settings;\n  var schema;\n\n  if (typeof find === 'string' || find && typeof find.exec === 'function') {\n    schema = [[find, replace]];\n  } else {\n    schema = find;\n    options = replace;\n  }\n\n  settings = options || {};\n  search(tree, settings, handlerFactory(toPairs(schema)));\n  return tree;\n\n  function handlerFactory(pairs) {\n    var pair = pairs[0];\n    return handler;\n\n    function handler(node, parent) {\n      var find = pair[0];\n      var replace = pair[1];\n      var nodes = [];\n      var start = 0;\n      var index = parent.children.indexOf(node);\n      var position;\n      var match;\n      var subhandler;\n      var value;\n      find.lastIndex = 0;\n      match = find.exec(node.value);\n\n      while (match) {\n        position = match.index;\n        value = replace.apply(null, [].concat(match, {\n          index: match.index,\n          input: match.input\n        }));\n\n        if (value !== false) {\n          if (start !== position) {\n            nodes.push({\n              type: 'text',\n              value: node.value.slice(start, position)\n            });\n          }\n\n          if (typeof value === 'string' && value.length > 0) {\n            value = {\n              type: 'text',\n              value: value\n            };\n          }\n\n          if (value) {\n            nodes = [].concat(nodes, value);\n          }\n\n          start = position + match[0].length;\n        }\n\n        if (!find.global) {\n          break;\n        }\n\n        match = find.exec(node.value);\n      }\n\n      if (position === undefined) {\n        nodes = [node];\n        index--;\n      } else {\n        if (start < node.value.length) {\n          nodes.push({\n            type: 'text',\n            value: node.value.slice(start)\n          });\n        }\n\n        nodes.unshift(index, 1);\n        splice.apply(parent.children, nodes);\n      }\n\n      if (pairs.length > 1) {\n        subhandler = handlerFactory(pairs.slice(1));\n        position = -1;\n\n        while (++position < nodes.length) {\n          node = nodes[position];\n\n          if (node.type === 'text') {\n            subhandler(node, parent);\n          } else {\n            search(node, settings, subhandler);\n          }\n        }\n      }\n\n      return index + nodes.length + 1;\n    }\n  }\n}\n\nfunction search(tree, settings, handler) {\n  var ignored = convert(settings.ignore || []);\n  var result = [];\n  visit(tree, 'text', visitor);\n  return result;\n\n  function visitor(node, parents) {\n    var index = -1;\n    var parent;\n    var grandparent;\n\n    while (++index < parents.length) {\n      parent = parents[index];\n\n      if (ignored(parent, grandparent ? grandparent.children.indexOf(parent) : undefined, grandparent)) {\n        return;\n      }\n\n      grandparent = parent;\n    }\n\n    return handler(node, grandparent);\n  }\n}\n\nfunction toPairs(schema) {\n  var result = [];\n  var key;\n  var index;\n\n  if (typeof schema !== 'object') {\n    throw new Error('Expected array or object as schema');\n  }\n\n  if ('length' in schema) {\n    index = -1;\n\n    while (++index < schema.length) {\n      result.push([toExpression(schema[index][0]), toFunction(schema[index][1])]);\n    }\n  } else {\n    for (key in schema) {\n      result.push([toExpression(key), toFunction(schema[key])]);\n    }\n  }\n\n  return result;\n}\n\nfunction toExpression(find) {\n  return typeof find === 'string' ? new RegExp(escape(find), 'g') : find;\n}\n\nfunction toFunction(replace) {\n  return typeof replace === 'function' ? replace : returner;\n\n  function returner() {\n    return replace;\n  }\n}","'use strict';\n\nmodule.exports = function (string) {\n  if (typeof string !== 'string') {\n    throw new TypeError('Expected a string');\n  } // Escape characters with special meaning either inside or outside character sets.\n  // Use a simple backslash escape when it’s always valid, and a \\unnnn escape when the simpler form would be disallowed by Unicode patterns’ stricter grammar.\n\n\n  return string.replace(/[|\\\\{}()[\\]^$+*?.]/g, '\\\\$&').replace(/-/g, '\\\\x2d');\n};","'use strict';\n\nmodule.exports = fromMarkdown; // These three are compiled away in the `dist/`\n\nvar toString = require('mdast-util-to-string');\n\nvar assign = require('micromark/dist/constant/assign');\n\nvar own = require('micromark/dist/constant/has-own-property');\n\nvar normalizeIdentifier = require('micromark/dist/util/normalize-identifier');\n\nvar safeFromInt = require('micromark/dist/util/safe-from-int');\n\nvar parser = require('micromark/dist/parse');\n\nvar preprocessor = require('micromark/dist/preprocess');\n\nvar postprocess = require('micromark/dist/postprocess');\n\nvar decode = require('parse-entities/decode-entity');\n\nvar stringifyPosition = require('unist-util-stringify-position');\n\nfunction fromMarkdown(value, encoding, options) {\n  if (typeof encoding !== 'string') {\n    options = encoding;\n    encoding = undefined;\n  }\n\n  return compiler(options)(postprocess(parser(options).document().write(preprocessor()(value, encoding, true))));\n} // Note this compiler only understand complete buffering, not streaming.\n\n\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\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\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\n    index = -1;\n\n    while (++index < events.length) {\n      handler = config[events[index][0]];\n\n      if (own.call(handler, events[index][1].type)) {\n        handler[events[index][1].type].call(assign({\n          sliceSerialize: events[index][2].sliceSerialize\n        }, context), events[index][1]);\n      }\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    } // Figure out `root` position.\n\n\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\n    while (++index < config.transforms.length) {\n      tree = config.transforms[index](tree) || tree;\n    }\n\n    return tree;\n  }\n\n  function prepareList(events, start, length) {\n    var index = start - 1;\n    var containerBalance = -1;\n    var listSpread = false;\n    var listItem;\n    var tailIndex;\n    var lineIndex;\n    var tailEvent;\n    var event;\n    var firstBlankLineIndex;\n    var atMarker;\n\n    while (++index <= length) {\n      event = events[index];\n\n      if (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\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\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') {// Empty.\n      } else {\n        atMarker = undefined;\n      }\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\n          while (tailIndex--) {\n            tailEvent = events[tailIndex];\n\n            if (tailEvent[1].type === 'lineEnding' || tailEvent[1].type === 'lineEndingBlank') {\n              if (tailEvent[0] === 'exit') continue;\n\n              if (lineIndex) {\n                events[lineIndex][1].type = 'lineEndingBlank';\n                listSpread = true;\n              }\n\n              tailEvent[1].type = 'lineEnding';\n              lineIndex = tailIndex;\n            } else if (tailEvent[1].type === 'linePrefix' || tailEvent[1].type === 'blockQuotePrefix' || tailEvent[1].type === 'blockQuotePrefixWhitespace' || tailEvent[1].type === 'blockQuoteMarker' || tailEvent[1].type === 'listItemIndent') {// Empty\n            } else {\n              break;\n            }\n          }\n\n          if (firstBlankLineIndex && (!lineIndex || firstBlankLineIndex < lineIndex)) {\n            listItem._spread = true;\n          } // Fix position.\n\n\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        } // Create a new list item.\n\n\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\n    events[start][1]._spread = listSpread;\n    return length;\n  }\n\n  function setData(key, value) {\n    data[key] = value;\n  }\n\n  function getData(key) {\n    return data[key];\n  }\n\n  function point(d) {\n    return {\n      line: d.line,\n      column: d.column,\n      offset: d.offset\n    };\n  }\n\n  function opener(create, and) {\n    return open;\n\n    function open(token) {\n      enter.call(this, create(token), token);\n      if (and) and.call(this, token);\n    }\n  }\n\n  function buffer() {\n    this.stack.push({\n      type: 'fragment',\n      children: []\n    });\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\n  function closer(and) {\n    return close;\n\n    function close(token) {\n      if (and) and.call(this, token);\n      exit.call(this, token);\n    }\n  }\n\n  function exit(token) {\n    var node = this.stack.pop();\n    var open = this.tokenStack.pop();\n\n    if (!open) {\n      throw new Error('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\n    node.position.end = point(token.end);\n    return node;\n  }\n\n  function resume() {\n    return toString(this.stack.pop());\n  } //\n  // Handlers.\n  //\n\n\n  function onenterlistordered() {\n    setData('expectingFirstListItemValue', true);\n  }\n\n  function onenterlistitemvalue(token) {\n    if (getData('expectingFirstListItemValue')) {\n      this.stack[this.stack.length - 2].start = parseInt(this.sliceSerialize(token), 10);\n      setData('expectingFirstListItemValue');\n    }\n  }\n\n  function onexitcodefencedfenceinfo() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].lang = data;\n  }\n\n  function onexitcodefencedfencemeta() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].meta = data;\n  }\n\n  function onexitcodefencedfence() {\n    // Exit if this is the closing fence.\n    if (getData('flowCodeInside')) return;\n    this.buffer();\n    setData('flowCodeInside', true);\n  }\n\n  function onexitcodefenced() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].value = data.replace(/^(\\r?\\n|\\r)|(\\r?\\n|\\r)$/g, '');\n    setData('flowCodeInside');\n  }\n\n  function onexitcodeindented() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].value = data;\n  }\n\n  function onexitdefinitionlabelstring(token) {\n    // Discard label, use the source content instead.\n    var label = this.resume();\n    this.stack[this.stack.length - 1].label = label;\n    this.stack[this.stack.length - 1].identifier = normalizeIdentifier(this.sliceSerialize(token)).toLowerCase();\n  }\n\n  function onexitdefinitiontitlestring() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].title = data;\n  }\n\n  function onexitdefinitiondestinationstring() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].url = data;\n  }\n\n  function onexitatxheadingsequence(token) {\n    if (!this.stack[this.stack.length - 1].depth) {\n      this.stack[this.stack.length - 1].depth = this.sliceSerialize(token).length;\n    }\n  }\n\n  function onexitsetextheadingtext() {\n    setData('setextHeadingSlurpLineEnding', true);\n  }\n\n  function onexitsetextheadinglinesequence(token) {\n    this.stack[this.stack.length - 1].depth = this.sliceSerialize(token).charCodeAt(0) === 61 ? 1 : 2;\n  }\n\n  function onexitsetextheading() {\n    setData('setextHeadingSlurpLineEnding');\n  }\n\n  function onenterdata(token) {\n    var siblings = this.stack[this.stack.length - 1].children;\n    var tail = siblings[siblings.length - 1];\n\n    if (!tail || tail.type !== 'text') {\n      // Add a new text node.\n      tail = text();\n      tail.position = {\n        start: point(token.start)\n      };\n      this.stack[this.stack.length - 1].children.push(tail);\n    }\n\n    this.stack.push(tail);\n  }\n\n  function onexitdata(token) {\n    var tail = this.stack.pop();\n    tail.value += this.sliceSerialize(token);\n    tail.position.end = point(token.end);\n  }\n\n  function onexitlineending(token) {\n    var context = this.stack[this.stack.length - 1]; // If we’re at a hard break, include the line ending in there.\n\n    if (getData('atHardBreak')) {\n      context.children[context.children.length - 1].position.end = point(token.end);\n      setData('atHardBreak');\n      return;\n    }\n\n    if (!getData('setextHeadingSlurpLineEnding') && config.canContainEols.indexOf(context.type) > -1) {\n      onenterdata.call(this, token);\n      onexitdata.call(this, token);\n    }\n  }\n\n  function onexithardbreak() {\n    setData('atHardBreak', true);\n  }\n\n  function onexithtmlflow() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].value = data;\n  }\n\n  function onexithtmltext() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].value = data;\n  }\n\n  function onexitcodetext() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].value = data;\n  }\n\n  function onexitlink() {\n    var context = this.stack[this.stack.length - 1]; // To do: clean.\n\n    if (getData('inReference')) {\n      context.type += 'Reference';\n      context.referenceType = getData('referenceType') || 'shortcut';\n      delete context.url;\n      delete context.title;\n    } else {\n      delete context.identifier;\n      delete context.label;\n      delete context.referenceType;\n    }\n\n    setData('referenceType');\n  }\n\n  function onexitimage() {\n    var context = this.stack[this.stack.length - 1]; // To do: clean.\n\n    if (getData('inReference')) {\n      context.type += 'Reference';\n      context.referenceType = getData('referenceType') || 'shortcut';\n      delete context.url;\n      delete context.title;\n    } else {\n      delete context.identifier;\n      delete context.label;\n      delete context.referenceType;\n    }\n\n    setData('referenceType');\n  }\n\n  function onexitlabeltext(token) {\n    this.stack[this.stack.length - 2].identifier = normalizeIdentifier(this.sliceSerialize(token)).toLowerCase();\n  }\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; // Assume a reference.\n\n    setData('inReference', true);\n\n    if (this.stack[this.stack.length - 1].type === 'link') {\n      this.stack[this.stack.length - 1].children = fragment.children;\n    } else {\n      this.stack[this.stack.length - 1].alt = value;\n    }\n  }\n\n  function onexitresourcedestinationstring() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].url = data;\n  }\n\n  function onexitresourcetitlestring() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].title = data;\n  }\n\n  function onexitresource() {\n    setData('inReference');\n  }\n\n  function onenterreference() {\n    setData('referenceType', 'collapsed');\n  }\n\n  function onexitreferencestring(token) {\n    var label = this.resume();\n    this.stack[this.stack.length - 1].label = label;\n    this.stack[this.stack.length - 1].identifier = normalizeIdentifier(this.sliceSerialize(token)).toLowerCase();\n    setData('referenceType', 'full');\n  }\n\n  function onexitcharacterreferencemarker(token) {\n    setData('characterReferenceType', token.type);\n  }\n\n  function onexitcharacterreferencevalue(token) {\n    var data = this.sliceSerialize(token);\n    var type = getData('characterReferenceType');\n    var value;\n    var tail;\n\n    if (type) {\n      value = safeFromInt(data, type === 'characterReferenceMarkerNumeric' ? 10 : 16);\n      setData('characterReferenceType');\n    } else {\n      value = decode(data);\n    }\n\n    tail = this.stack.pop();\n    tail.value += value;\n    tail.position.end = point(token.end);\n  }\n\n  function onexitautolinkprotocol(token) {\n    onexitdata.call(this, token);\n    this.stack[this.stack.length - 1].url = this.sliceSerialize(token);\n  }\n\n  function onexitautolinkemail(token) {\n    onexitdata.call(this, token);\n    this.stack[this.stack.length - 1].url = 'mailto:' + this.sliceSerialize(token);\n  } //\n  // Creaters.\n  //\n\n\n  function blockQuote() {\n    return {\n      type: 'blockquote',\n      children: []\n    };\n  }\n\n  function codeFlow() {\n    return {\n      type: 'code',\n      lang: null,\n      meta: null,\n      value: ''\n    };\n  }\n\n  function codeText() {\n    return {\n      type: 'inlineCode',\n      value: ''\n    };\n  }\n\n  function definition() {\n    return {\n      type: 'definition',\n      identifier: '',\n      label: null,\n      title: null,\n      url: ''\n    };\n  }\n\n  function emphasis() {\n    return {\n      type: 'emphasis',\n      children: []\n    };\n  }\n\n  function heading() {\n    return {\n      type: 'heading',\n      depth: undefined,\n      children: []\n    };\n  }\n\n  function hardBreak() {\n    return {\n      type: 'break'\n    };\n  }\n\n  function html() {\n    return {\n      type: 'html',\n      value: ''\n    };\n  }\n\n  function image() {\n    return {\n      type: 'image',\n      title: null,\n      url: '',\n      alt: null\n    };\n  }\n\n  function link() {\n    return {\n      type: 'link',\n      title: null,\n      url: '',\n      children: []\n    };\n  }\n\n  function list(token) {\n    return {\n      type: 'list',\n      ordered: token.type === 'listOrdered',\n      start: null,\n      spread: token._spread,\n      children: []\n    };\n  }\n\n  function listItem(token) {\n    return {\n      type: 'listItem',\n      spread: token._spread,\n      checked: null,\n      children: []\n    };\n  }\n\n  function paragraph() {\n    return {\n      type: 'paragraph',\n      children: []\n    };\n  }\n\n  function strong() {\n    return {\n      type: 'strong',\n      children: []\n    };\n  }\n\n  function text() {\n    return {\n      type: 'text',\n      value: ''\n    };\n  }\n\n  function thematicBreak() {\n    return {\n      type: 'thematicBreak'\n    };\n  }\n}\n\nfunction configure(config, extensions) {\n  var index = -1;\n\n  while (++index < extensions.length) {\n    extension(config, extensions[index]);\n  }\n\n  return config;\n}\n\nfunction extension(config, extension) {\n  var key;\n  var left;\n\n  for (key in extension) {\n    left = own.call(config, key) ? config[key] : config[key] = {};\n\n    if (key === 'canContainEols' || key === 'transforms') {\n      config[key] = [].concat(left, extension[key]);\n    } else {\n      Object.assign(left, extension[key]);\n    }\n  }\n}","'use strict';\n\nmodule.exports = require('./dist');","var ccount = require('ccount');\n\nvar findAndReplace = require('mdast-util-find-and-replace');\n\nvar unicodePunctuation = require('micromark/dist/character/unicode-punctuation');\n\nvar unicodeWhitespace = require('micromark/dist/character/unicode-whitespace');\n\nexports.transforms = [transformGfmAutolinkLiterals];\nexports.enter = {\n  literalAutolink: enterLiteralAutolink,\n  literalAutolinkEmail: enterLiteralAutolinkValue,\n  literalAutolinkHttp: enterLiteralAutolinkValue,\n  literalAutolinkWww: enterLiteralAutolinkValue\n};\nexports.exit = {\n  literalAutolink: exitLiteralAutolink,\n  literalAutolinkEmail: exitLiteralAutolinkEmail,\n  literalAutolinkHttp: exitLiteralAutolinkHttp,\n  literalAutolinkWww: exitLiteralAutolinkWww\n};\n\nfunction enterLiteralAutolink(token) {\n  this.enter({\n    type: 'link',\n    title: null,\n    url: '',\n    children: []\n  }, token);\n}\n\nfunction enterLiteralAutolinkValue(token) {\n  this.config.enter.autolinkProtocol.call(this, token);\n}\n\nfunction exitLiteralAutolinkHttp(token) {\n  this.config.exit.autolinkProtocol.call(this, token);\n}\n\nfunction exitLiteralAutolinkWww(token) {\n  this.config.exit.data.call(this, token);\n  this.stack[this.stack.length - 1].url = 'http://' + this.sliceSerialize(token);\n}\n\nfunction exitLiteralAutolinkEmail(token) {\n  this.config.exit.autolinkEmail.call(this, token);\n}\n\nfunction exitLiteralAutolink(token) {\n  this.exit(token);\n}\n\nfunction transformGfmAutolinkLiterals(tree) {\n  findAndReplace(tree, [[/(https?:\\/\\/|www(?=\\.))([-.\\w]+)([^ \\t\\r\\n]*)/i, findUrl], [/([-.\\w+]+)@([-\\w]+(?:\\.[-\\w]+)+)/, findEmail]], {\n    ignore: ['link', 'linkReference']\n  });\n}\n\nfunction findUrl($0, protocol, domain, path, match) {\n  var prefix = '';\n  var parts;\n  var result; // Not an expected previous character.\n\n  if (!previous(match)) {\n    return false;\n  } // Treat `www` as part of the domain.\n\n\n  if (/^w/i.test(protocol)) {\n    domain = protocol + domain;\n    protocol = '';\n    prefix = 'http://';\n  }\n\n  if (!isCorrectDomain(domain)) {\n    return false;\n  }\n\n  parts = splitUrl(domain + path);\n  if (!parts[0]) return false;\n  result = {\n    type: 'link',\n    title: null,\n    url: prefix + protocol + parts[0],\n    children: [{\n      type: 'text',\n      value: protocol + parts[0]\n    }]\n  };\n\n  if (parts[1]) {\n    result = [result, {\n      type: 'text',\n      value: parts[1]\n    }];\n  }\n\n  return result;\n}\n\nfunction findEmail($0, atext, label, match) {\n  // Not an expected previous character.\n  if (!previous(match, true) || /[_-]$/.test(label)) {\n    return false;\n  }\n\n  return {\n    type: 'link',\n    title: null,\n    url: 'mailto:' + atext + '@' + label,\n    children: [{\n      type: 'text',\n      value: atext + '@' + label\n    }]\n  };\n}\n\nfunction isCorrectDomain(domain) {\n  var parts = domain.split('.');\n\n  if (parts.length < 2 || parts[parts.length - 1] && (/_/.test(parts[parts.length - 1]) || !/[a-zA-Z\\d]/.test(parts[parts.length - 1])) || parts[parts.length - 2] && (/_/.test(parts[parts.length - 2]) || !/[a-zA-Z\\d]/.test(parts[parts.length - 2]))) {\n    return false;\n  }\n\n  return true;\n}\n\nfunction splitUrl(url) {\n  var trail = /[!\"&'),.:;<>?\\]}]+$/.exec(url);\n  var closingParenIndex;\n  var openingParens;\n  var closingParens;\n\n  if (trail) {\n    url = url.slice(0, trail.index);\n    trail = trail[0];\n    closingParenIndex = trail.indexOf(')');\n    openingParens = ccount(url, '(');\n    closingParens = ccount(url, ')');\n\n    while (closingParenIndex !== -1 && openingParens > closingParens) {\n      url += trail.slice(0, closingParenIndex + 1);\n      trail = trail.slice(closingParenIndex + 1);\n      closingParenIndex = trail.indexOf(')');\n      closingParens++;\n    }\n  }\n\n  return [url, trail];\n}\n\nfunction previous(match, email) {\n  var code = match.input.charCodeAt(match.index - 1);\n  return (code !== code || unicodeWhitespace(code) || unicodePunctuation(code)) && (!email || code !== 47);\n}","var inConstruct = 'phrasing';\nvar notInConstruct = ['autolink', 'link', 'image', 'label'];\nexports.unsafe = [{\n  character: '@',\n  before: '[+\\\\-.\\\\w]',\n  after: '[\\\\-.\\\\w]',\n  inConstruct: inConstruct,\n  notInConstruct: notInConstruct\n}, {\n  character: '.',\n  before: '[Ww]',\n  after: '[\\\\-.\\\\w]',\n  inConstruct: inConstruct,\n  notInConstruct: notInConstruct\n}, {\n  character: ':',\n  before: '[ps]',\n  after: '\\\\/',\n  inConstruct: inConstruct,\n  notInConstruct: notInConstruct\n}];","exports.canContainEols = ['delete'];\nexports.enter = {\n  strikethrough: enterStrikethrough\n};\nexports.exit = {\n  strikethrough: exitStrikethrough\n};\n\nfunction enterStrikethrough(token) {\n  this.enter({\n    type: 'delete',\n    children: []\n  }, token);\n}\n\nfunction exitStrikethrough(token) {\n  this.exit(token);\n}","var phrasing = require('mdast-util-to-markdown/lib/util/container-phrasing');\n\nexports.unsafe = [{\n  character: '~',\n  inConstruct: 'phrasing'\n}];\nexports.handlers = {\n  delete: handleDelete\n};\nhandleDelete.peek = peekDelete;\n\nfunction handleDelete(node, _, context) {\n  var exit = context.enter('emphasis');\n  var value = phrasing(node, context, {\n    before: '~',\n    after: '~'\n  });\n  exit();\n  return '~~' + value + '~~';\n}\n\nfunction peekDelete() {\n  return '~';\n}","exports.enter = {\n  table: enterTable,\n  tableData: enterCell,\n  tableHeader: enterCell,\n  tableRow: enterRow\n};\nexports.exit = {\n  codeText: exitCodeText,\n  table: exitTable,\n  tableData: exit,\n  tableHeader: exit,\n  tableRow: exit\n};\n\nfunction enterTable(token) {\n  this.enter({\n    type: 'table',\n    align: token._align,\n    children: []\n  }, token);\n  this.setData('inTable', true);\n}\n\nfunction exitTable(token) {\n  this.exit(token);\n  this.setData('inTable');\n}\n\nfunction enterRow(token) {\n  this.enter({\n    type: 'tableRow',\n    children: []\n  }, token);\n}\n\nfunction exit(token) {\n  this.exit(token);\n}\n\nfunction enterCell(token) {\n  this.enter({\n    type: 'tableCell',\n    children: []\n  }, token);\n} // Overwrite the default code text data handler to unescape escaped pipes when\n// they are in tables.\n\n\nfunction exitCodeText(token) {\n  var value = this.resume();\n\n  if (this.getData('inTable')) {\n    value = value.replace(/\\\\([\\\\|])/g, replace);\n  }\n\n  this.stack[this.stack.length - 1].value = value;\n  this.exit(token);\n}\n\nfunction replace($0, $1) {\n  // Pipes work, backslashes don’t (but can’t escape pipes).\n  return $1 === '|' ? $1 : $0;\n}","var phrasing = require('mdast-util-to-markdown/lib/util/container-phrasing');\n\nvar defaultInlineCode = require('mdast-util-to-markdown/lib/handle/inline-code');\n\nvar markdownTable = require('markdown-table');\n\nmodule.exports = toMarkdown;\n\nfunction toMarkdown(options) {\n  var settings = options || {};\n  var padding = settings.tableCellPadding;\n  var alignDelimiters = settings.tablePipeAlign;\n  var stringLength = settings.stringLength;\n  var around = padding ? ' ' : '|';\n  return {\n    unsafe: [{\n      character: '\\r',\n      inConstruct: 'tableCell'\n    }, {\n      character: '\\n',\n      inConstruct: 'tableCell'\n    }, // A pipe, when followed by a tab or space (padding), or a dash or colon\n    // (unpadded delimiter row), could result in a table.\n    {\n      atBreak: true,\n      character: '|',\n      after: '[\\t :-]'\n    }, // A pipe in a cell must be encoded.\n    {\n      character: '|',\n      inConstruct: 'tableCell'\n    }, // A colon must be followed by a dash, in which case it could start a\n    // delimiter row.\n    {\n      atBreak: true,\n      character: ':',\n      after: '-'\n    }, // A delimiter row can also start with a dash, when followed by more\n    // dashes, a colon, or a pipe.\n    // This is a stricter version than the built in check for lists, thematic\n    // breaks, and setex heading underlines though:\n    // <https://github.com/syntax-tree/mdast-util-to-markdown/blob/51a2038/lib/unsafe.js#L57>\n    {\n      atBreak: true,\n      character: '-',\n      after: '[:|-]'\n    }],\n    handlers: {\n      table: handleTable,\n      tableRow: handleTableRow,\n      tableCell: handleTableCell,\n      inlineCode: inlineCodeWithTable\n    }\n  };\n\n  function handleTable(node, _, context) {\n    return serializeData(handleTableAsData(node, context), node.align);\n  } // This function isn’t really used normally, because we handle rows at the\n  // table level.\n  // But, if someone passes in a table row, this ensures we make somewhat sense.\n\n\n  function handleTableRow(node, _, context) {\n    var row = handleTableRowAsData(node, context); // `markdown-table` will always add an align row\n\n    var value = serializeData([row]);\n    return value.slice(0, value.indexOf('\\n'));\n  }\n\n  function handleTableCell(node, _, context) {\n    var exit = context.enter('tableCell');\n    var value = phrasing(node, context, {\n      before: around,\n      after: around\n    });\n    exit();\n    return value;\n  }\n\n  function serializeData(matrix, align) {\n    return markdownTable(matrix, {\n      align: align,\n      alignDelimiters: alignDelimiters,\n      padding: padding,\n      stringLength: stringLength\n    });\n  }\n\n  function handleTableAsData(node, context) {\n    var children = node.children;\n    var index = -1;\n    var length = children.length;\n    var result = [];\n    var subexit = context.enter('table');\n\n    while (++index < length) {\n      result[index] = handleTableRowAsData(children[index], context);\n    }\n\n    subexit();\n    return result;\n  }\n\n  function handleTableRowAsData(node, context) {\n    var children = node.children;\n    var index = -1;\n    var length = children.length;\n    var result = [];\n    var subexit = context.enter('tableRow');\n\n    while (++index < length) {\n      result[index] = handleTableCell(children[index], node, context);\n    }\n\n    subexit();\n    return result;\n  }\n\n  function inlineCodeWithTable(node, parent, context) {\n    var value = defaultInlineCode(node, parent, context);\n\n    if (context.stack.indexOf('tableCell') !== -1) {\n      value = value.replace(/\\|/g, '\\\\$&');\n    }\n\n    return value;\n  }\n}","exports.exit = {\n  taskListCheckValueChecked: exitCheck,\n  taskListCheckValueUnchecked: exitCheck,\n  paragraph: exitParagraphWithTaskListItem\n};\n\nfunction exitCheck(token) {\n  // We’re always in a paragraph, in a list item.\n  this.stack[this.stack.length - 2].checked = token.type === 'taskListCheckValueChecked';\n}\n\nfunction exitParagraphWithTaskListItem(token) {\n  var parent = this.stack[this.stack.length - 2];\n  var node = this.stack[this.stack.length - 1];\n  var siblings = parent.children;\n  var head = node.children[0];\n  var index = -1;\n  var firstParaghraph;\n\n  if (parent && parent.type === 'listItem' && typeof parent.checked === 'boolean' && head && head.type === 'text') {\n    while (++index < siblings.length) {\n      if (siblings[index].type === 'paragraph') {\n        firstParaghraph = siblings[index];\n        break;\n      }\n    }\n\n    if (firstParaghraph === node) {\n      // Must start with a space or a tab.\n      head.value = head.value.slice(1);\n\n      if (head.value.length === 0) {\n        node.children.shift();\n      } else {\n        head.position.start.column++;\n        head.position.start.offset++;\n        node.position.start = Object.assign({}, head.position.start);\n      }\n    }\n  }\n\n  this.exit(token);\n}","var defaultListItem = require('mdast-util-to-markdown/lib/handle/list-item');\n\nexports.unsafe = [{\n  atBreak: true,\n  character: '-',\n  after: '[:|-]'\n}];\nexports.handlers = {\n  listItem: listItemWithTaskListItem\n};\n\nfunction listItemWithTaskListItem(node, parent, context) {\n  var value = defaultListItem(node, parent, context);\n  var head = node.children[0];\n\n  if (typeof node.checked === 'boolean' && head && head.type === 'paragraph') {\n    value = value.replace(/^(?:[*+-]|\\d+\\.)([\\r\\n]| {1,3})/, check);\n  }\n\n  return value;\n\n  function check($0) {\n    return $0 + '[' + (node.checked ? 'x' : ' ') + '] ';\n  }\n}","var autolinkLiteral = require('mdast-util-gfm-autolink-literal/from-markdown');\n\nvar strikethrough = require('mdast-util-gfm-strikethrough/from-markdown');\n\nvar table = require('mdast-util-gfm-table/from-markdown');\n\nvar taskListItem = require('mdast-util-gfm-task-list-item/from-markdown');\n\nvar own = {}.hasOwnProperty;\nmodule.exports = configure([autolinkLiteral, strikethrough, table, taskListItem]);\n\nfunction configure(extensions) {\n  var config = {\n    transforms: [],\n    canContainEols: []\n  };\n  var length = extensions.length;\n  var index = -1;\n\n  while (++index < length) {\n    extension(config, extensions[index]);\n  }\n\n  return config;\n}\n\nfunction extension(config, extension) {\n  var key;\n  var left;\n  var right;\n\n  for (key in extension) {\n    left = own.call(config, key) ? config[key] : config[key] = {};\n    right = extension[key];\n\n    if (key === 'canContainEols' || key === 'transforms') {\n      config[key] = [].concat(left, right);\n    } else {\n      Object.assign(left, right);\n    }\n  }\n}","var autolinkLiteral = require('mdast-util-gfm-autolink-literal/to-markdown');\n\nvar strikethrough = require('mdast-util-gfm-strikethrough/to-markdown');\n\nvar table = require('mdast-util-gfm-table/to-markdown');\n\nvar taskListItem = require('mdast-util-gfm-task-list-item/to-markdown');\n\nvar configure = require('mdast-util-to-markdown/lib/configure');\n\nmodule.exports = toMarkdown;\n\nfunction toMarkdown(options) {\n  var config = configure({\n    handlers: {},\n    join: [],\n    unsafe: [],\n    options: {}\n  }, {\n    extensions: [autolinkLiteral, strikethrough, table(options), taskListItem]\n  });\n  return Object.assign(config.options, {\n    handlers: config.handlers,\n    join: config.join,\n    unsafe: config.unsafe\n  });\n}","module.exports = configure;\n\nfunction configure(base, extension) {\n  var index = -1;\n  var key; // First do subextensions.\n\n  if (extension.extensions) {\n    while (++index < extension.extensions.length) {\n      configure(base, extension.extensions[index]);\n    }\n  }\n\n  for (key in extension) {\n    if (key === 'extensions') {// Empty.\n    } else if (key === 'unsafe' || key === 'join') {\n      base[key] = base[key].concat(extension[key] || []);\n    } else if (key === 'handlers') {\n      base[key] = Object.assign(base[key], extension[key] || {});\n    } else {\n      base.options[key] = extension[key];\n    }\n  }\n\n  return base;\n}","module.exports = inlineCode;\ninlineCode.peek = inlineCodePeek;\n\nvar patternCompile = require('../util/pattern-compile');\n\nfunction inlineCode(node, parent, context) {\n  var value = node.value || '';\n  var sequence = '`';\n  var index = -1;\n  var pattern;\n  var expression;\n  var match;\n  var position; // If there is a single grave accent on its own in the code, use a fence of\n  // two.\n  // If there are two in a row, use one.\n\n  while (new RegExp('(^|[^`])' + sequence + '([^`]|$)').test(value)) {\n    sequence += '`';\n  } // If this is not just spaces or eols (tabs don’t count), and either the\n  // first or last character are a space, eol, or tick, then pad with spaces.\n\n\n  if (/[^ \\r\\n]/.test(value) && (/[ \\r\\n`]/.test(value.charAt(0)) || /[ \\r\\n`]/.test(value.charAt(value.length - 1)))) {\n    value = ' ' + value + ' ';\n  } // We have a potential problem: certain characters after eols could result in\n  // blocks being seen.\n  // For example, if someone injected the string `'\\n# b'`, then that would\n  // result in an ATX heading.\n  // We can’t escape characters in `inlineCode`, but because eols are\n  // transformed to spaces when going from markdown to HTML anyway, we can swap\n  // them out.\n\n\n  while (++index < context.unsafe.length) {\n    pattern = context.unsafe[index]; // Only look for `atBreak`s.\n    // Btw: note that `atBreak` patterns will always start the regex at LF or\n    // CR.\n\n    if (!pattern.atBreak) continue;\n    expression = patternCompile(pattern);\n\n    while (match = expression.exec(value)) {\n      position = match.index; // Support CRLF (patterns only look for one of the characters).\n\n      if (value.charCodeAt(position) === 10\n      /* `\\n` */\n      && value.charCodeAt(position - 1) === 13\n      /* `\\r` */\n      ) {\n        position--;\n      }\n\n      value = value.slice(0, position) + ' ' + value.slice(match.index + 1);\n    }\n  }\n\n  return sequence + value + sequence;\n}\n\nfunction inlineCodePeek() {\n  return '`';\n}","module.exports = listItem;\n\nvar repeat = require('repeat-string');\n\nvar checkBullet = require('../util/check-bullet');\n\nvar checkListItemIndent = require('../util/check-list-item-indent');\n\nvar flow = require('../util/container-flow');\n\nvar indentLines = require('../util/indent-lines');\n\nfunction listItem(node, parent, context) {\n  var bullet = checkBullet(context);\n  var listItemIndent = checkListItemIndent(context);\n  var size;\n  var value;\n  var exit;\n\n  if (parent && parent.ordered) {\n    bullet = (parent.start > -1 ? parent.start : 1) + (context.options.incrementListMarker === false ? 0 : parent.children.indexOf(node)) + '.';\n  }\n\n  size = bullet.length + 1;\n\n  if (listItemIndent === 'tab' || listItemIndent === 'mixed' && (parent && parent.spread || node.spread)) {\n    size = Math.ceil(size / 4) * 4;\n  }\n\n  exit = context.enter('listItem');\n  value = indentLines(flow(node, context), map);\n  exit();\n  return value;\n\n  function map(line, index, blank) {\n    if (index) {\n      return (blank ? '' : repeat(' ', size)) + line;\n    }\n\n    return (blank ? bullet : bullet + repeat(' ', size - bullet.length)) + line;\n  }\n}","module.exports = checkBullet;\n\nfunction checkBullet(context) {\n  var marker = context.options.bullet || '*';\n\n  if (marker !== '*' && marker !== '+' && marker !== '-') {\n    throw new Error('Cannot serialize items with `' + marker + '` for `options.bullet`, expected `*`, `+`, or `-`');\n  }\n\n  return marker;\n}","module.exports = checkListItemIndent;\n\nfunction checkListItemIndent(context) {\n  var style = context.options.listItemIndent || 'tab';\n\n  if (style === 1 || style === '1') {\n    return 'one';\n  }\n\n  if (style !== 'tab' && style !== 'one' && style !== 'mixed') {\n    throw new Error('Cannot serialize items with `' + style + '` for `options.listItemIndent`, expected `tab`, `one`, or `mixed`');\n  }\n\n  return style;\n}","module.exports = flow;\n\nvar repeat = require('repeat-string');\n\nfunction flow(parent, context) {\n  var children = parent.children || [];\n  var results = [];\n  var index = -1;\n  var child;\n\n  while (++index < children.length) {\n    child = children[index];\n    results.push(context.handle(child, parent, context, {\n      before: '\\n',\n      after: '\\n'\n    }));\n\n    if (index + 1 < children.length) {\n      results.push(between(child, children[index + 1]));\n    }\n  }\n\n  return results.join('');\n\n  function between(left, right) {\n    var index = -1;\n    var result;\n\n    while (++index < context.join.length) {\n      result = context.join[index](left, right, parent, context);\n\n      if (result === true || result === 1) {\n        break;\n      }\n\n      if (typeof result === 'number') {\n        return repeat('\\n', 1 + Number(result));\n      }\n\n      if (result === false) {\n        return '\\n\\n<!---->\\n\\n';\n      }\n    }\n\n    return '\\n\\n';\n  }\n}","module.exports = phrasing;\n\nfunction phrasing(parent, context, safeOptions) {\n  var children = parent.children || [];\n  var results = [];\n  var index = -1;\n  var before = safeOptions.before;\n  var after;\n  var handle;\n  var child;\n\n  while (++index < children.length) {\n    child = children[index];\n\n    if (index + 1 < children.length) {\n      handle = context.handle.handlers[children[index + 1].type];\n      if (handle && handle.peek) handle = handle.peek;\n      after = handle ? handle(children[index + 1], parent, context, {\n        before: '',\n        after: ''\n      }).charAt(0) : '';\n    } else {\n      after = safeOptions.after;\n    } // In some cases, html (text) can be found in phrasing right after an eol.\n    // When we’d serialize that, in most cases that would be seen as html\n    // (flow).\n    // As we can’t escape or so to prevent it from happening, we take a somewhat\n    // reasonable approach: replace that eol with a space.\n    // See: <https://github.com/syntax-tree/mdast-util-to-markdown/issues/15>\n\n\n    if (results.length > 0 && (before === '\\r' || before === '\\n') && child.type === 'html') {\n      results[results.length - 1] = results[results.length - 1].replace(/(\\r?\\n|\\r)$/, ' ');\n      before = ' ';\n    }\n\n    results.push(context.handle(child, parent, context, {\n      before: before,\n      after: after\n    }));\n    before = results[results.length - 1].slice(-1);\n  }\n\n  return results.join('');\n}","module.exports = indentLines;\nvar eol = /\\r?\\n|\\r/g;\n\nfunction indentLines(value, map) {\n  var result = [];\n  var start = 0;\n  var line = 0;\n  var match;\n\n  while (match = eol.exec(value)) {\n    one(value.slice(start, match.index));\n    result.push(match[0]);\n    start = match.index + match[0].length;\n    line++;\n  }\n\n  one(value.slice(start));\n  return result.join('');\n\n  function one(value) {\n    result.push(map(value, line, !value));\n  }\n}","module.exports = patternCompile;\n\nfunction patternCompile(pattern) {\n  var before;\n  var after;\n\n  if (!pattern._compiled) {\n    before = pattern.before ? '(?:' + pattern.before + ')' : '';\n    after = pattern.after ? '(?:' + pattern.after + ')' : '';\n\n    if (pattern.atBreak) {\n      before = '[\\\\r\\\\n][\\\\t ]*' + before;\n    }\n\n    pattern._compiled = new RegExp((before ? '(' + before + ')' : '') + (/[|\\\\{}()[\\]^$+*?.-]/.test(pattern.character) ? '\\\\' : '') + pattern.character + (after || ''), 'g');\n  }\n\n  return pattern._compiled;\n}","'use strict';\n\nmodule.exports = toString; // 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.\n\nfunction toString(node) {\n  return node && (node.value || node.alt || node.title || 'children' in node && all(node.children) || 'length' in node && all(node)) || '';\n}\n\nfunction all(values) {\n  var result = [];\n  var index = -1;\n\n  while (++index < values.length) {\n    result[index] = toString(values[index]);\n  }\n\n  return result.join('');\n}","module.exports = require('./syntax');","var asciiAlpha = require('micromark/dist/character/ascii-alpha');\n\nvar asciiAlphanumeric = require('micromark/dist/character/ascii-alphanumeric');\n\nvar asciiControl = require('micromark/dist/character/ascii-control');\n\nvar markdownLineEnding = require('micromark/dist/character/markdown-line-ending');\n\nvar unicodePunctuation = require('micromark/dist/character/unicode-punctuation');\n\nvar unicodeWhitespace = require('micromark/dist/character/unicode-whitespace');\n\nvar www = {\n  tokenize: tokenizeWww,\n  partial: true\n};\nvar domain = {\n  tokenize: tokenizeDomain,\n  partial: true\n};\nvar path = {\n  tokenize: tokenizePath,\n  partial: true\n};\nvar punctuation = {\n  tokenize: tokenizePunctuation,\n  partial: true\n};\nvar paren = {\n  tokenize: tokenizeParen,\n  partial: true\n};\nvar namedCharacterReference = {\n  tokenize: tokenizeNamedCharacterReference,\n  partial: true\n};\nvar wwwAutolink = {\n  tokenize: tokenizeWwwAutolink,\n  previous: previousWww\n};\nvar httpAutolink = {\n  tokenize: tokenizeHttpAutolink,\n  previous: previousHttp\n};\nvar emailAutolink = {\n  tokenize: tokenizeEmailAutolink,\n  previous: previousEmail\n};\nvar text = {}; // Export hooked constructs.\n\nexports.text = text; // `0`\n\nvar code = 48; // While the code is smaller than `{`.\n\nwhile (code < 123) {\n  text[code] = emailAutolink;\n  code++; // Jump from `:` -> `A`\n\n  if (code === 58) code = 65; // Jump from `[` -> `a`\n  else if (code === 91) code = 97;\n} // `+`\n\n\ntext[43] = emailAutolink; // `-`\n\ntext[45] = emailAutolink; // `.`\n\ntext[46] = emailAutolink; // `_`\n\ntext[95] = emailAutolink; // `h`.\n\ntext[72] = [emailAutolink, httpAutolink];\ntext[104] = [emailAutolink, httpAutolink]; // `w`.\n\ntext[87] = [emailAutolink, wwwAutolink];\ntext[119] = [emailAutolink, wwwAutolink];\n\nfunction tokenizeEmailAutolink(effects, ok, nok) {\n  var self = this;\n  var hasDot;\n  return start;\n\n  function start(code) {\n    /* istanbul ignore next - hooks. */\n    if (!gfmAtext(code) || !previousEmail(self.previous) || previous(self.events)) {\n      return nok(code);\n    }\n\n    effects.enter('literalAutolink');\n    effects.enter('literalAutolinkEmail');\n    return atext(code);\n  }\n\n  function atext(code) {\n    if (gfmAtext(code)) {\n      effects.consume(code);\n      return atext;\n    } // `@`\n\n\n    if (code === 64) {\n      effects.consume(code);\n      return label;\n    }\n\n    return nok(code);\n  }\n\n  function label(code) {\n    // `.`\n    if (code === 46) {\n      return effects.check(punctuation, done, dotContinuation)(code);\n    }\n\n    if ( // `-`\n    code === 45 || // `_`\n    code === 95) {\n      return effects.check(punctuation, nok, dashOrUnderscoreContinuation)(code);\n    }\n\n    if (asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return label;\n    }\n\n    return done(code);\n  }\n\n  function dotContinuation(code) {\n    effects.consume(code);\n    hasDot = true;\n    return label;\n  }\n\n  function dashOrUnderscoreContinuation(code) {\n    effects.consume(code);\n    return afterDashOrUnderscore;\n  }\n\n  function afterDashOrUnderscore(code) {\n    // `.`\n    if (code === 46) {\n      return effects.check(punctuation, nok, dotContinuation)(code);\n    }\n\n    return label(code);\n  }\n\n  function done(code) {\n    if (hasDot) {\n      effects.exit('literalAutolinkEmail');\n      effects.exit('literalAutolink');\n      return ok(code);\n    }\n\n    return nok(code);\n  }\n}\n\nfunction tokenizeWwwAutolink(effects, ok, nok) {\n  var self = this;\n  return start;\n\n  function start(code) {\n    /* istanbul ignore next - hooks. */\n    if (code !== 87 && code - 32 !== 87 || !previousWww(self.previous) || previous(self.events)) {\n      return nok(code);\n    }\n\n    effects.enter('literalAutolink');\n    effects.enter('literalAutolinkWww'); // For `www.` we check instead of attempt, because when it matches, GH\n    // treats it as part of a domain (yes, it says a valid domain must come\n    // after `www.`, but that’s not how it’s implemented by them).\n\n    return effects.check(www, effects.attempt(domain, effects.attempt(path, done), nok), nok)(code);\n  }\n\n  function done(code) {\n    effects.exit('literalAutolinkWww');\n    effects.exit('literalAutolink');\n    return ok(code);\n  }\n}\n\nfunction tokenizeHttpAutolink(effects, ok, nok) {\n  var self = this;\n  return start;\n\n  function start(code) {\n    /* istanbul ignore next - hooks. */\n    if (code !== 72 && code - 32 !== 72 || !previousHttp(self.previous) || previous(self.events)) {\n      return nok(code);\n    }\n\n    effects.enter('literalAutolink');\n    effects.enter('literalAutolinkHttp');\n    effects.consume(code);\n    return t1;\n  }\n\n  function t1(code) {\n    // `t`\n    if (code === 84 || code - 32 === 84) {\n      effects.consume(code);\n      return t2;\n    }\n\n    return nok(code);\n  }\n\n  function t2(code) {\n    // `t`\n    if (code === 84 || code - 32 === 84) {\n      effects.consume(code);\n      return p;\n    }\n\n    return nok(code);\n  }\n\n  function p(code) {\n    // `p`\n    if (code === 80 || code - 32 === 80) {\n      effects.consume(code);\n      return s;\n    }\n\n    return nok(code);\n  }\n\n  function s(code) {\n    // `s`\n    if (code === 83 || code - 32 === 83) {\n      effects.consume(code);\n      return colon;\n    }\n\n    return colon(code);\n  }\n\n  function colon(code) {\n    // `:`\n    if (code === 58) {\n      effects.consume(code);\n      return slash1;\n    }\n\n    return nok(code);\n  }\n\n  function slash1(code) {\n    // `/`\n    if (code === 47) {\n      effects.consume(code);\n      return slash2;\n    }\n\n    return nok(code);\n  }\n\n  function slash2(code) {\n    // `/`\n    if (code === 47) {\n      effects.consume(code);\n      return after;\n    }\n\n    return nok(code);\n  }\n\n  function after(code) {\n    return asciiControl(code) || unicodeWhitespace(code) || unicodePunctuation(code) ? nok(code) : effects.attempt(domain, effects.attempt(path, done), nok)(code);\n  }\n\n  function done(code) {\n    effects.exit('literalAutolinkHttp');\n    effects.exit('literalAutolink');\n    return ok(code);\n  }\n}\n\nfunction tokenizeWww(effects, ok, nok) {\n  return start;\n\n  function start(code) {\n    // Assume a `w`.\n    effects.consume(code);\n    return w2;\n  }\n\n  function w2(code) {\n    // `w`\n    if (code === 87 || code - 32 === 87) {\n      effects.consume(code);\n      return w3;\n    }\n\n    return nok(code);\n  }\n\n  function w3(code) {\n    // `w`\n    if (code === 87 || code - 32 === 87) {\n      effects.consume(code);\n      return dot;\n    }\n\n    return nok(code);\n  }\n\n  function dot(code) {\n    // `.`\n    if (code === 46) {\n      effects.consume(code);\n      return after;\n    }\n\n    return nok(code);\n  }\n\n  function after(code) {\n    return code === null || markdownLineEnding(code) ? nok(code) : ok(code);\n  }\n}\n\nfunction tokenizeDomain(effects, ok, nok) {\n  var hasUnderscoreInLastSegment;\n  var hasUnderscoreInLastLastSegment;\n  return domain;\n\n  function domain(code) {\n    // `&`\n    if (code === 38) {\n      return effects.check(namedCharacterReference, done, punctuationContinuation)(code);\n    }\n\n    if (code === 46\n    /* `.` */\n    || code === 95\n    /* `_` */\n    ) {\n      return effects.check(punctuation, done, punctuationContinuation)(code);\n    } // GH documents that only alphanumerics (other than `-`, `.`, and `_`) can\n    // occur, which sounds like ASCII only, but they also support `www.點看.com`,\n    // so that’s Unicode.\n    // Instead of some new production for Unicode alphanumerics, markdown\n    // already has that for Unicode punctuation and whitespace, so use those.\n\n\n    if (asciiControl(code) || unicodeWhitespace(code) || code !== 45\n    /* `-` */\n    && unicodePunctuation(code)) {\n      return done(code);\n    }\n\n    effects.consume(code);\n    return domain;\n  }\n\n  function punctuationContinuation(code) {\n    // `.`\n    if (code === 46) {\n      hasUnderscoreInLastLastSegment = hasUnderscoreInLastSegment;\n      hasUnderscoreInLastSegment = undefined;\n      effects.consume(code);\n      return domain;\n    } // `_`\n\n\n    if (code === 95) hasUnderscoreInLastSegment = true;\n    effects.consume(code);\n    return domain;\n  }\n\n  function done(code) {\n    if (!hasUnderscoreInLastLastSegment && !hasUnderscoreInLastSegment) {\n      return ok(code);\n    }\n\n    return nok(code);\n  }\n}\n\nfunction tokenizePath(effects, ok) {\n  var balance = 0;\n  return inPath;\n\n  function inPath(code) {\n    // `&`\n    if (code === 38) {\n      return effects.check(namedCharacterReference, ok, continuedPunctuation)(code);\n    } // `(`\n\n\n    if (code === 40) {\n      balance++;\n    } // `)`\n\n\n    if (code === 41) {\n      return effects.check(paren, parenAtPathEnd, continuedPunctuation)(code);\n    }\n\n    if (pathEnd(code)) {\n      return ok(code);\n    }\n\n    if (trailingPunctuation(code)) {\n      return effects.check(punctuation, ok, continuedPunctuation)(code);\n    }\n\n    effects.consume(code);\n    return inPath;\n  }\n\n  function continuedPunctuation(code) {\n    effects.consume(code);\n    return inPath;\n  }\n\n  function parenAtPathEnd(code) {\n    balance--;\n    return balance < 0 ? ok(code) : continuedPunctuation(code);\n  }\n}\n\nfunction tokenizeNamedCharacterReference(effects, ok, nok) {\n  return start;\n\n  function start(code) {\n    // Assume an ampersand.\n    effects.consume(code);\n    return inside;\n  }\n\n  function inside(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return inside;\n    } // `;`\n\n\n    if (code === 59) {\n      effects.consume(code);\n      return after;\n    }\n\n    return nok(code);\n  }\n\n  function after(code) {\n    // If the named character reference is followed by the end of the path, it’s\n    // not continued punctuation.\n    return pathEnd(code) ? ok(code) : nok(code);\n  }\n}\n\nfunction tokenizeParen(effects, ok, nok) {\n  return start;\n\n  function start(code) {\n    // Assume a right paren.\n    effects.consume(code);\n    return after;\n  }\n\n  function after(code) {\n    // If the punctuation marker is followed by the end of the path, it’s not\n    // continued punctuation.\n    return pathEnd(code) || // `)`\n    code === 41 ? ok(code) : nok(code);\n  }\n}\n\nfunction tokenizePunctuation(effects, ok, nok) {\n  return start;\n\n  function start(code) {\n    // Always a valid trailing punctuation marker.\n    effects.consume(code);\n    return after;\n  }\n\n  function after(code) {\n    // Check the next.\n    if (trailingPunctuation(code)) {\n      effects.consume(code);\n      return after;\n    } // If the punctuation marker is followed by the end of the path, it’s not\n    // continued punctuation.\n\n\n    return pathEnd(code) ? ok(code) : nok(code);\n  }\n}\n\nfunction trailingPunctuation(code) {\n  return (// `!`\n    code === 33 || // `\"`\n    code === 34 || // `'`\n    code === 39 || // `)`\n    code === 41 || // `*`\n    code === 42 || // `,`\n    code === 44 || // `.`\n    code === 46 || // `:`\n    code === 58 || // `;`\n    code === 59 || // `<`\n    code === 60 || // `?`\n    code === 63 || // `_`.\n    code === 95 || // `~`\n    code === 126\n  );\n}\n\nfunction pathEnd(code) {\n  return (// EOF.\n    code === null || // CR, LF, CRLF, HT, VS.\n    code < 0 || // Space.\n    code === 32 || // `<`\n    code === 60\n  );\n}\n\nfunction gfmAtext(code) {\n  return code === 43\n  /* `+` */\n  || code === 45\n  /* `-` */\n  || code === 46\n  /* `.` */\n  || code === 95\n  /* `_` */\n  || asciiAlphanumeric(code);\n}\n\nfunction previousWww(code) {\n  return code === null || code < 0 || code === 32\n  /* ` ` */\n  || code === 40\n  /* `(` */\n  || code === 42\n  /* `*` */\n  || code === 95\n  /* `_` */\n  || code === 126\n  /* `~` */\n  ;\n}\n\nfunction previousHttp(code) {\n  return code === null || !asciiAlpha(code);\n}\n\nfunction previousEmail(code) {\n  return code !== 47\n  /* `/` */\n  && previousHttp(code);\n}\n\nfunction previous(events) {\n  var index = events.length;\n\n  while (index--) {\n    if ((events[index][1].type === 'labelLink' || events[index][1].type === 'labelImage') && !events[index][1]._balanced) {\n      return true;\n    }\n  }\n}","module.exports = create;\n\nvar classifyCharacter = require('micromark/dist/util/classify-character');\n\nvar chunkedSplice = require('micromark/dist/util/chunked-splice');\n\nvar resolveAll = require('micromark/dist/util/resolve-all');\n\nvar shallow = require('micromark/dist/util/shallow');\n\nfunction create(options) {\n  var settings = options || {};\n  var single = settings.singleTilde;\n  var tokenizer = {\n    tokenize: tokenizeStrikethrough,\n    resolveAll: resolveAllStrikethrough\n  };\n\n  if (single === null || single === undefined) {\n    single = true;\n  }\n\n  return {\n    text: {\n      126: tokenizer\n    },\n    insideSpan: {\n      null: tokenizer\n    }\n  }; // Take events and resolve strikethrough.\n\n  function resolveAllStrikethrough(events, context) {\n    var index = -1;\n    var strikethrough;\n    var text;\n    var open;\n    var nextEvents; // Walk through all events.\n\n    while (++index < events.length) {\n      // Find a token that can close.\n      if (events[index][0] === 'enter' && events[index][1].type === 'strikethroughSequenceTemporary' && 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 === 'strikethroughSequenceTemporary' && events[open][1]._open && // If the sizes are the same:\n          events[index][1].end.offset - events[index][1].start.offset === events[open][1].end.offset - events[open][1].start.offset) {\n            events[index][1].type = 'strikethroughSequence';\n            events[open][1].type = 'strikethroughSequence';\n            strikethrough = {\n              type: 'strikethrough',\n              start: shallow(events[open][1].start),\n              end: shallow(events[index][1].end)\n            };\n            text = {\n              type: 'strikethroughText',\n              start: shallow(events[open][1].end),\n              end: shallow(events[index][1].start)\n            }; // Opening.\n\n            nextEvents = [['enter', strikethrough, context], ['enter', events[open][1], context], ['exit', events[open][1], context], ['enter', text, context]]; // Between.\n\n            chunkedSplice(nextEvents, nextEvents.length, 0, resolveAll(context.parser.constructs.insideSpan.null, events.slice(open + 1, index), context)); // Closing.\n\n            chunkedSplice(nextEvents, nextEvents.length, 0, [['exit', text, context], ['enter', events[index][1], context], ['exit', events[index][1], context], ['exit', strikethrough, context]]);\n            chunkedSplice(events, open - 1, index - open + 3, nextEvents);\n            index = open + nextEvents.length - 2;\n            break;\n          }\n        }\n      }\n    }\n\n    return removeRemainingSequences(events);\n  }\n\n  function removeRemainingSequences(events) {\n    var index = -1;\n    var length = events.length;\n\n    while (++index < length) {\n      if (events[index][1].type === 'strikethroughSequenceTemporary') {\n        events[index][1].type = 'data';\n      }\n    }\n\n    return events;\n  }\n\n  function tokenizeStrikethrough(effects, ok, nok) {\n    var previous = this.previous;\n    var events = this.events;\n    var size = 0;\n    return start;\n\n    function start(code) {\n      if (code !== 126 || previous === 126 && events[events.length - 1][1].type !== 'characterEscape') {\n        return nok(code);\n      }\n\n      effects.enter('strikethroughSequenceTemporary');\n      return more(code);\n    }\n\n    function more(code) {\n      var before = classifyCharacter(previous);\n      var token;\n      var after;\n\n      if (code === 126) {\n        // If this is the third marker, exit.\n        if (size > 1) return nok(code);\n        effects.consume(code);\n        size++;\n        return more;\n      }\n\n      if (size < 2 && !single) return nok(code);\n      token = effects.exit('strikethroughSequenceTemporary');\n      after = classifyCharacter(code);\n      token._open = !after || after === 2 && before;\n      token._close = !before || before === 2 && after;\n      return ok(code);\n    }\n  }\n}","module.exports = require('./syntax');","exports.flow = {\n  null: {\n    tokenize: tokenizeTable,\n    resolve: resolveTable,\n    interruptible: true\n  }\n};\n\nvar createSpace = require('micromark/dist/tokenize/factory-space');\n\nvar setextUnderlineMini = {\n  tokenize: tokenizeSetextUnderlineMini,\n  partial: true\n};\nvar nextPrefixedOrBlank = {\n  tokenize: tokenizeNextPrefixedOrBlank,\n  partial: true\n};\n\nfunction resolveTable(events, context) {\n  var length = events.length;\n  var index = -1;\n  var token;\n  var inHead;\n  var inDelimiterRow;\n  var inRow;\n  var cell;\n  var content;\n  var text;\n  var contentStart;\n  var contentEnd;\n  var cellStart;\n\n  while (++index < length) {\n    token = events[index][1];\n\n    if (inRow) {\n      if (token.type === 'temporaryTableCellContent') {\n        contentStart = contentStart || index;\n        contentEnd = index;\n      }\n\n      if ( // Combine separate content parts into one.\n      (token.type === 'tableCellDivider' || token.type === 'tableRow') && contentEnd) {\n        content = {\n          type: 'tableContent',\n          start: events[contentStart][1].start,\n          end: events[contentEnd][1].end\n        };\n        text = {\n          type: 'chunkText',\n          start: content.start,\n          end: content.end,\n          contentType: 'text'\n        };\n        events.splice(contentStart, contentEnd - contentStart + 1, ['enter', content, context], ['enter', text, context], ['exit', text, context], ['exit', content, context]);\n        index -= contentEnd - contentStart - 3;\n        length = events.length;\n        contentStart = undefined;\n        contentEnd = undefined;\n      }\n    }\n\n    if (events[index][0] === 'exit' && cellStart && cellStart + 1 < index && (token.type === 'tableCellDivider' || token.type === 'tableRow' && (cellStart + 3 < index || events[cellStart][1].type !== 'whitespace'))) {\n      cell = {\n        type: inDelimiterRow ? 'tableDelimiter' : inHead ? 'tableHeader' : 'tableData',\n        start: events[cellStart][1].start,\n        end: events[index][1].end\n      };\n      events.splice(index + (token.type === 'tableCellDivider' ? 1 : 0), 0, ['exit', cell, context]);\n      events.splice(cellStart, 0, ['enter', cell, context]);\n      index += 2;\n      length = events.length;\n      cellStart = index + 1;\n    }\n\n    if (token.type === 'tableRow') {\n      inRow = events[index][0] === 'enter';\n\n      if (inRow) {\n        cellStart = index + 1;\n      }\n    }\n\n    if (token.type === 'tableDelimiterRow') {\n      inDelimiterRow = events[index][0] === 'enter';\n\n      if (inDelimiterRow) {\n        cellStart = index + 1;\n      }\n    }\n\n    if (token.type === 'tableHead') {\n      inHead = events[index][0] === 'enter';\n    }\n  }\n\n  return events;\n}\n\nfunction tokenizeTable(effects, ok, nok) {\n  var align = [];\n  var tableHeaderCount = 0;\n  var seenDelimiter;\n  var hasDash;\n  return start;\n\n  function start(code) {\n    /* istanbul ignore if - used to be passed in beta micromark versions. */\n    if (code === null || code === -5 || code === -4 || code === -3) {\n      return nok(code);\n    }\n\n    effects.enter('table')._align = align;\n    effects.enter('tableHead');\n    effects.enter('tableRow'); // If we start with a pipe, we open a cell marker.\n\n    if (code === 124) {\n      return cellDividerHead(code);\n    }\n\n    tableHeaderCount++;\n    effects.enter('temporaryTableCellContent'); // Can’t be space or eols at the start of a construct, so we’re in a cell.\n\n    return inCellContentHead(code);\n  }\n\n  function cellDividerHead(code) {\n    // Always a pipe.\n    effects.enter('tableCellDivider');\n    effects.consume(code);\n    effects.exit('tableCellDivider');\n    seenDelimiter = true;\n    return cellBreakHead;\n  }\n\n  function cellBreakHead(code) {\n    // EOF, CR, LF, CRLF.\n    if (code === null || code === -5 || code === -4 || code === -3) {\n      return atRowEndHead(code);\n    } // HT, VS, SP.\n\n\n    if (code === -2 || code === -1 || code === 32) {\n      effects.enter('whitespace');\n      effects.consume(code);\n      return inWhitespaceHead;\n    }\n\n    if (seenDelimiter) {\n      seenDelimiter = undefined;\n      tableHeaderCount++;\n    } // `|`\n\n\n    if (code === 124) {\n      return cellDividerHead(code);\n    } // Anything else is cell content.\n\n\n    effects.enter('temporaryTableCellContent');\n    return inCellContentHead(code);\n  }\n\n  function inWhitespaceHead(code) {\n    // HT, VS, SP.\n    if (code === -2 || code === -1 || code === 32) {\n      effects.consume(code);\n      return inWhitespaceHead;\n    }\n\n    effects.exit('whitespace');\n    return cellBreakHead(code);\n  }\n\n  function inCellContentHead(code) {\n    // EOF, whitespace, pipe\n    if (code === null || code < 0 || code === 32 || code === 124) {\n      effects.exit('temporaryTableCellContent');\n      return cellBreakHead(code);\n    }\n\n    effects.consume(code); // `\\`\n\n    return code === 92 ? inCellContentEscapeHead : inCellContentHead;\n  }\n\n  function inCellContentEscapeHead(code) {\n    // `\\` or `|`\n    if (code === 92 || code === 124) {\n      effects.consume(code);\n      return inCellContentHead;\n    } // Anything else.\n\n\n    return inCellContentHead(code);\n  }\n\n  function atRowEndHead(code) {\n    if (code === null) {\n      return nok(code);\n    }\n\n    effects.exit('tableRow');\n    effects.exit('tableHead'); // Always a line ending.\n\n    effects.enter('lineEnding');\n    effects.consume(code);\n    effects.exit('lineEnding'); // If a setext heading, exit.\n\n    return effects.check(setextUnderlineMini, nok, // Support an indent before the delimiter row.\n    createSpace(effects, rowStartDelimiter, 'linePrefix', 4));\n  }\n\n  function rowStartDelimiter(code) {\n    // If there’s another space, or we’re at the EOL/EOF, exit.\n    if (code === null || code < 0 || code === 32) {\n      return nok(code);\n    }\n\n    effects.enter('tableDelimiterRow');\n    return atDelimiterRowBreak(code);\n  }\n\n  function atDelimiterRowBreak(code) {\n    // EOF, CR, LF, CRLF.\n    if (code === null || code === -5 || code === -4 || code === -3) {\n      return rowEndDelimiter(code);\n    } // HT, VS, SP.\n\n\n    if (code === -2 || code === -1 || code === 32) {\n      effects.enter('whitespace');\n      effects.consume(code);\n      return inWhitespaceDelimiter;\n    } // `-`\n\n\n    if (code === 45) {\n      effects.enter('tableDelimiterFiller');\n      effects.consume(code);\n      hasDash = true;\n      align.push(null);\n      return inFillerDelimiter;\n    } // `:`\n\n\n    if (code === 58) {\n      effects.enter('tableDelimiterAlignment');\n      effects.consume(code);\n      effects.exit('tableDelimiterAlignment');\n      align.push('left');\n      return afterLeftAlignment;\n    } // If we start with a pipe, we open a cell marker.\n\n\n    if (code === 124) {\n      effects.enter('tableCellDivider');\n      effects.consume(code);\n      effects.exit('tableCellDivider');\n      return atDelimiterRowBreak;\n    }\n\n    return nok(code);\n  }\n\n  function inWhitespaceDelimiter(code) {\n    // HT, VS, SP.\n    if (code === -2 || code === -1 || code === 32) {\n      effects.consume(code);\n      return inWhitespaceDelimiter;\n    }\n\n    effects.exit('whitespace');\n    return atDelimiterRowBreak(code);\n  }\n\n  function inFillerDelimiter(code) {\n    // `-`\n    if (code === 45) {\n      effects.consume(code);\n      return inFillerDelimiter;\n    }\n\n    effects.exit('tableDelimiterFiller'); // `:`\n\n    if (code === 58) {\n      effects.enter('tableDelimiterAlignment');\n      effects.consume(code);\n      effects.exit('tableDelimiterAlignment');\n      align[align.length - 1] = align[align.length - 1] === 'left' ? 'center' : 'right';\n      return afterRightAlignment;\n    }\n\n    return atDelimiterRowBreak(code);\n  }\n\n  function afterLeftAlignment(code) {\n    // `-`\n    if (code === 45) {\n      effects.enter('tableDelimiterFiller');\n      effects.consume(code);\n      hasDash = true;\n      return inFillerDelimiter;\n    } // Anything else is not ok.\n\n\n    return nok(code);\n  }\n\n  function afterRightAlignment(code) {\n    // EOF, CR, LF, CRLF.\n    if (code === null || code === -5 || code === -4 || code === -3) {\n      return rowEndDelimiter(code);\n    } // HT, VS, SP.\n\n\n    if (code === -2 || code === -1 || code === 32) {\n      effects.enter('whitespace');\n      effects.consume(code);\n      return inWhitespaceDelimiter;\n    } // `|`\n\n\n    if (code === 124) {\n      effects.enter('tableCellDivider');\n      effects.consume(code);\n      effects.exit('tableCellDivider');\n      return atDelimiterRowBreak;\n    }\n\n    return nok(code);\n  }\n\n  function rowEndDelimiter(code) {\n    effects.exit('tableDelimiterRow'); // Exit if there was no dash at all, or if the header cell count is not the\n    // delimiter cell count.\n\n    if (!hasDash || tableHeaderCount !== align.length) {\n      return nok(code);\n    }\n\n    if (code === null) {\n      return tableClose(code);\n    }\n\n    return effects.check(nextPrefixedOrBlank, tableClose, tableContinue)(code);\n  }\n\n  function tableClose(code) {\n    effects.exit('table');\n    return ok(code);\n  }\n\n  function tableContinue(code) {\n    // Always a line ending.\n    effects.enter('lineEnding');\n    effects.consume(code);\n    effects.exit('lineEnding'); // We checked that it’s not a prefixed or blank line, so we’re certain a\n    // body is coming, though it may be indented.\n\n    return createSpace(effects, bodyStart, 'linePrefix', 4);\n  }\n\n  function bodyStart(code) {\n    effects.enter('tableBody');\n    return rowStartBody(code);\n  }\n\n  function rowStartBody(code) {\n    effects.enter('tableRow'); // If we start with a pipe, we open a cell marker.\n\n    if (code === 124) {\n      return cellDividerBody(code);\n    }\n\n    effects.enter('temporaryTableCellContent'); // Can’t be space or eols at the start of a construct, so we’re in a cell.\n\n    return inCellContentBody(code);\n  }\n\n  function cellDividerBody(code) {\n    // Always a pipe.\n    effects.enter('tableCellDivider');\n    effects.consume(code);\n    effects.exit('tableCellDivider');\n    return cellBreakBody;\n  }\n\n  function cellBreakBody(code) {\n    // EOF, CR, LF, CRLF.\n    if (code === null || code === -5 || code === -4 || code === -3) {\n      return atRowEndBody(code);\n    } // HT, VS, SP.\n\n\n    if (code === -2 || code === -1 || code === 32) {\n      effects.enter('whitespace');\n      effects.consume(code);\n      return inWhitespaceBody;\n    } // `|`\n\n\n    if (code === 124) {\n      return cellDividerBody(code);\n    } // Anything else is cell content.\n\n\n    effects.enter('temporaryTableCellContent');\n    return inCellContentBody(code);\n  }\n\n  function inWhitespaceBody(code) {\n    // HT, VS, SP.\n    if (code === -2 || code === -1 || code === 32) {\n      effects.consume(code);\n      return inWhitespaceBody;\n    }\n\n    effects.exit('whitespace');\n    return cellBreakBody(code);\n  }\n\n  function inCellContentBody(code) {\n    // EOF, whitespace, pipe\n    if (code === null || code < 0 || code === 32 || code === 124) {\n      effects.exit('temporaryTableCellContent');\n      return cellBreakBody(code);\n    }\n\n    effects.consume(code); // `\\`\n\n    return code === 92 ? inCellContentEscapeBody : inCellContentBody;\n  }\n\n  function inCellContentEscapeBody(code) {\n    // `\\` or `|`\n    if (code === 92 || code === 124) {\n      effects.consume(code);\n      return inCellContentBody;\n    } // Anything else.\n\n\n    return inCellContentBody(code);\n  }\n\n  function atRowEndBody(code) {\n    effects.exit('tableRow');\n\n    if (code === null) {\n      return tableBodyClose(code);\n    }\n\n    return effects.check(nextPrefixedOrBlank, tableBodyClose, tableBodyContinue)(code);\n  }\n\n  function tableBodyClose(code) {\n    effects.exit('tableBody');\n    return tableClose(code);\n  }\n\n  function tableBodyContinue(code) {\n    // Always a line ending.\n    effects.enter('lineEnding');\n    effects.consume(code);\n    effects.exit('lineEnding'); // Support an optional prefix, then start a body row.\n\n    return createSpace(effects, rowStartBody, 'linePrefix', 4);\n  }\n} // Based on micromark, but that won’t work as we’re in a table, and that expects\n// content.\n// <https://github.com/micromark/micromark/blob/main/lib/tokenize/setext-underline.js>\n\n\nfunction tokenizeSetextUnderlineMini(effects, ok, nok) {\n  return start;\n\n  function start(code) {\n    // `-`\n    if (code !== 45) {\n      return nok(code);\n    }\n\n    effects.enter('setextUnderline');\n    return sequence(code);\n  }\n\n  function sequence(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return sequence;\n    }\n\n    return whitespace(code);\n  }\n\n  function whitespace(code) {\n    if (code === -2 || code === -1 || code === 32) {\n      effects.consume(code);\n      return whitespace;\n    }\n\n    if (code === null || code === -5 || code === -4 || code === -3) {\n      return ok(code);\n    }\n\n    return nok(code);\n  }\n}\n\nfunction tokenizeNextPrefixedOrBlank(effects, ok, nok) {\n  var size = 0;\n  return start;\n\n  function start(code) {\n    // This is a check, so we don’t care about tokens, but we open a bogus one\n    // so we’re valid.\n    effects.enter('check'); // EOL.\n\n    effects.consume(code);\n    return whitespace;\n  }\n\n  function whitespace(code) {\n    // VS or SP.\n    if (code === -1 || code === 32) {\n      effects.consume(code);\n      size++;\n      return size === 4 ? ok : whitespace;\n    } // EOF or whitespace\n\n\n    if (code === null || code < 0) {\n      return ok(code);\n    } // Anything else.\n\n\n    return nok(code);\n  }\n}","module.exports = require('./syntax');","var markdownLineEndingOrSpace = require('micromark/dist/character/markdown-line-ending-or-space');\n\nvar spaceFactory = require('micromark/dist/tokenize/factory-space');\n\nvar prefixSize = require('micromark/dist/util/prefix-size');\n\nvar tasklistCheck = {\n  tokenize: tokenizeTasklistCheck\n};\nexports.text = {\n  91: tasklistCheck\n};\n\nfunction tokenizeTasklistCheck(effects, ok, nok) {\n  var self = this;\n  return open;\n\n  function open(code) {\n    if ( // Exit if not `[`.\n    code !== 91 || // Exit if there’s stuff before.\n    self.previous !== null || // Exit if not in the first content that is the first child of a list\n    // item.\n    !self._gfmTasklistFirstContentOfListItem) {\n      return nok(code);\n    }\n\n    effects.enter('taskListCheck');\n    effects.enter('taskListCheckMarker');\n    effects.consume(code);\n    effects.exit('taskListCheckMarker');\n    return inside;\n  }\n\n  function inside(code) {\n    // Tab or space.\n    if (code === -2 || code === 32) {\n      effects.enter('taskListCheckValueUnchecked');\n      effects.consume(code);\n      effects.exit('taskListCheckValueUnchecked');\n      return close;\n    } // Upper- and lower `x`.\n\n\n    if (code === 88 || code === 120) {\n      effects.enter('taskListCheckValueChecked');\n      effects.consume(code);\n      effects.exit('taskListCheckValueChecked');\n      return close;\n    }\n\n    return nok(code);\n  }\n\n  function close(code) {\n    // `]`\n    if (code === 93) {\n      effects.enter('taskListCheckMarker');\n      effects.consume(code);\n      effects.exit('taskListCheckMarker');\n      effects.exit('taskListCheck');\n      return effects.check({\n        tokenize: spaceThenNonSpace\n      }, ok, nok);\n    }\n\n    return nok(code);\n  }\n}\n\nfunction spaceThenNonSpace(effects, ok, nok) {\n  var self = this;\n  return spaceFactory(effects, after, 'whitespace');\n\n  function after(code) {\n    return prefixSize(self.events, 'whitespace') && code !== null && !markdownLineEndingOrSpace(code) ? ok(code) : nok(code);\n  }\n}","module.exports = require('./syntax');","var combine = require('micromark/dist/util/combine-extensions');\n\nvar autolink = require('micromark-extension-gfm-autolink-literal');\n\nvar strikethrough = require('micromark-extension-gfm-strikethrough');\n\nvar table = require('micromark-extension-gfm-table');\n\nvar tasklist = require('micromark-extension-gfm-task-list-item');\n\nmodule.exports = create;\n\nfunction create(options) {\n  return combine([autolink, strikethrough(options), table, tasklist]);\n}","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\n\nvar asciiAlpha = regexCheck(/[A-Za-z]/);\nmodule.exports = asciiAlpha;","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\n\nvar asciiAlphanumeric = regexCheck(/[\\dA-Za-z]/);\nmodule.exports = asciiAlphanumeric;","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\n\nvar asciiAtext = regexCheck(/[#-'*+\\--9=?A-Z^-~]/);\nmodule.exports = asciiAtext;","'use strict'; // Note: EOF is seen as ASCII control here, because `null < 32 == true`.\n\nfunction asciiControl(code) {\n  return (// Special whitespace codes (which have negative values), C0 and Control\n    // character DEL\n    code < 32 || code === 127\n  );\n}\n\nmodule.exports = asciiControl;","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\n\nvar asciiDigit = regexCheck(/\\d/);\nmodule.exports = asciiDigit;","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\n\nvar asciiHexDigit = regexCheck(/[\\dA-Fa-f]/);\nmodule.exports = asciiHexDigit;","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\n\nvar asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/);\nmodule.exports = asciiPunctuation;","'use strict';\n\nfunction markdownLineEndingOrSpace(code) {\n  return code < 0 || code === 32;\n}\n\nmodule.exports = markdownLineEndingOrSpace;","'use strict';\n\nfunction markdownLineEnding(code) {\n  return code < -2;\n}\n\nmodule.exports = markdownLineEnding;","'use strict';\n\nfunction markdownSpace(code) {\n  return code === -2 || code === -1 || code === 32;\n}\n\nmodule.exports = markdownSpace;","'use strict';\n\nvar unicodePunctuationRegex = require('../constant/unicode-punctuation-regex.js');\n\nvar regexCheck = require('../util/regex-check.js'); // In fact adds to the bundle size.\n\n\nvar unicodePunctuation = regexCheck(unicodePunctuationRegex);\nmodule.exports = unicodePunctuation;","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\n\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'; // This module is copied from <https://spec.commonmark.org/0.29/#html-blocks>.\n\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'; // This module is copied from <https://spec.commonmark.org/0.29/#html-blocks>.\n\nvar raws = ['pre', 'script', 'style', 'textarea'];\nmodule.exports = raws;","'use strict';\n\nvar splice = [].splice;\nmodule.exports = splice;","'use strict'; // 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.\n\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});\n\nvar text$1 = require('./initialize/text.js');\n\nvar attention = require('./tokenize/attention.js');\n\nvar autolink = require('./tokenize/autolink.js');\n\nvar blockQuote = require('./tokenize/block-quote.js');\n\nvar characterEscape = require('./tokenize/character-escape.js');\n\nvar characterReference = require('./tokenize/character-reference.js');\n\nvar codeFenced = require('./tokenize/code-fenced.js');\n\nvar codeIndented = require('./tokenize/code-indented.js');\n\nvar codeText = require('./tokenize/code-text.js');\n\nvar definition = require('./tokenize/definition.js');\n\nvar hardBreakEscape = require('./tokenize/hard-break-escape.js');\n\nvar headingAtx = require('./tokenize/heading-atx.js');\n\nvar htmlFlow = require('./tokenize/html-flow.js');\n\nvar htmlText = require('./tokenize/html-text.js');\n\nvar labelEnd = require('./tokenize/label-end.js');\n\nvar labelStartImage = require('./tokenize/label-start-image.js');\n\nvar labelStartLink = require('./tokenize/label-start-link.js');\n\nvar lineEnding = require('./tokenize/line-ending.js');\n\nvar list = require('./tokenize/list.js');\n\nvar setextUnderline = require('./tokenize/setext-underline.js');\n\nvar thematicBreak = require('./tokenize/thematic-break.js');\n\nvar document = {\n  42: list,\n  // Asterisk\n  43: list,\n  // Plus sign\n  45: list,\n  // Dash\n  48: list,\n  // 0\n  49: list,\n  // 1\n  50: list,\n  // 2\n  51: list,\n  // 3\n  52: list,\n  // 4\n  53: list,\n  // 5\n  54: list,\n  // 6\n  55: list,\n  // 7\n  56: list,\n  // 8\n  57: list,\n  // 9\n  62: blockQuote // Greater than\n\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});\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar factorySpace = require('../tokenize/factory-space.js');\n\nvar tokenize = initializeContent;\n\nfunction initializeContent(effects) {\n  var contentStart = effects.attempt(this.parser.constructs.contentInitial, afterContentStartConstruct, paragraphInitial);\n  var previous;\n  return contentStart;\n\n  function afterContentStartConstruct(code) {\n    if (code === null) {\n      effects.consume(code);\n      return;\n    }\n\n    effects.enter('lineEnding');\n    effects.consume(code);\n    effects.exit('lineEnding');\n    return factorySpace(effects, contentStart, 'linePrefix');\n  }\n\n  function paragraphInitial(code) {\n    effects.enter('paragraph');\n    return lineStart(code);\n  }\n\n  function lineStart(code) {\n    var token = effects.enter('chunkText', {\n      contentType: 'text',\n      previous: previous\n    });\n\n    if (previous) {\n      previous.next = token;\n    }\n\n    previous = token;\n    return data(code);\n  }\n\n  function data(code) {\n    if (code === null) {\n      effects.exit('chunkText');\n      effects.exit('paragraph');\n      effects.consume(code);\n      return;\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.consume(code);\n      effects.exit('chunkText');\n      return lineStart;\n    } // Data.\n\n\n    effects.consume(code);\n    return data;\n  }\n}\n\nexports.tokenize = tokenize;","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar factorySpace = require('../tokenize/factory-space.js');\n\nvar partialBlankLine = require('../tokenize/partial-blank-line.js');\n\nvar tokenize = initializeDocument;\nvar containerConstruct = {\n  tokenize: tokenizeContainer\n};\nvar lazyFlowConstruct = {\n  tokenize: tokenizeLazyFlow\n};\n\nfunction initializeDocument(effects) {\n  var self = this;\n  var stack = [];\n  var continued = 0;\n  var inspectConstruct = {\n    tokenize: tokenizeInspect,\n    partial: true\n  };\n  var inspectResult;\n  var childFlow;\n  var childToken;\n  return start;\n\n  function start(code) {\n    if (continued < stack.length) {\n      self.containerState = stack[continued][1];\n      return effects.attempt(stack[continued][0].continuation, documentContinue, documentContinued)(code);\n    }\n\n    return documentContinued(code);\n  }\n\n  function documentContinue(code) {\n    continued++;\n    return start(code);\n  }\n\n  function documentContinued(code) {\n    // If we’re in a concrete construct (such as when expecting another line of\n    // HTML, or we resulted in lazy content), we can immediately start flow.\n    if (inspectResult && inspectResult.flowContinue) {\n      return flowStart(code);\n    }\n\n    self.interrupt = childFlow && childFlow.currentConstruct && childFlow.currentConstruct.interruptible;\n    self.containerState = {};\n    return effects.attempt(containerConstruct, containerContinue, flowStart)(code);\n  }\n\n  function containerContinue(code) {\n    stack.push([self.currentConstruct, self.containerState]);\n    self.containerState = undefined;\n    return documentContinued(code);\n  }\n\n  function flowStart(code) {\n    if (code === null) {\n      exitContainers(0, true);\n      effects.consume(code);\n      return;\n    }\n\n    childFlow = childFlow || self.parser.flow(self.now());\n    effects.enter('chunkFlow', {\n      contentType: 'flow',\n      previous: childToken,\n      _tokenizer: childFlow\n    });\n    return flowContinue(code);\n  }\n\n  function flowContinue(code) {\n    if (code === null) {\n      continueFlow(effects.exit('chunkFlow'));\n      return flowStart(code);\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.consume(code);\n      continueFlow(effects.exit('chunkFlow'));\n      return effects.check(inspectConstruct, documentAfterPeek);\n    }\n\n    effects.consume(code);\n    return flowContinue;\n  }\n\n  function documentAfterPeek(code) {\n    exitContainers(inspectResult.continued, inspectResult && inspectResult.flowEnd);\n    continued = 0;\n    return start(code);\n  }\n\n  function continueFlow(token) {\n    if (childToken) childToken.next = token;\n    childToken = token;\n    childFlow.lazy = inspectResult && inspectResult.lazy;\n    childFlow.defineSkip(token.start);\n    childFlow.write(self.sliceStream(token));\n  }\n\n  function exitContainers(size, end) {\n    var index = stack.length; // Close the flow.\n\n    if (childFlow && end) {\n      childFlow.write([null]);\n      childToken = childFlow = undefined;\n    } // Exit open containers.\n\n\n    while (index-- > size) {\n      self.containerState = stack[index][1];\n      stack[index][0].exit.call(self, effects);\n    }\n\n    stack.length = size;\n  }\n\n  function tokenizeInspect(effects, ok) {\n    var subcontinued = 0;\n    inspectResult = {};\n    return inspectStart;\n\n    function inspectStart(code) {\n      if (subcontinued < stack.length) {\n        self.containerState = stack[subcontinued][1];\n        return effects.attempt(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\n      if (childFlow.currentConstruct && childFlow.currentConstruct.concrete) {\n        inspectResult.flowContinue = true;\n        return inspectDone(code);\n      }\n\n      self.interrupt = childFlow.currentConstruct && childFlow.currentConstruct.interruptible;\n      self.containerState = {};\n      return effects.attempt(containerConstruct, inspectFlowEnd, inspectDone)(code);\n    }\n\n    function inspectContinue(code) {\n      subcontinued++;\n      return self.containerState._closeFlow ? inspectFlowEnd(code) : inspectStart(code);\n    }\n\n    function inspectLess(code) {\n      if (childFlow.currentConstruct && childFlow.currentConstruct.lazy) {\n        // Maybe another container?\n        self.containerState = {};\n        return effects.attempt(containerConstruct, inspectFlowEnd, // Maybe flow, or a blank line?\n        effects.attempt(lazyFlowConstruct, inspectFlowEnd, effects.check(partialBlankLine, inspectFlowEnd, inspectLazy)))(code);\n      } // Otherwise we’re interrupting.\n\n\n      return inspectFlowEnd(code);\n    }\n\n    function inspectLazy(code) {\n      // Act as if all containers are continued.\n      subcontinued = stack.length;\n      inspectResult.lazy = true;\n      inspectResult.flowContinue = true;\n      return inspectDone(code);\n    } // We’re done with flow if we have more containers, or an interruption.\n\n\n    function inspectFlowEnd(code) {\n      inspectResult.flowEnd = true;\n      return inspectDone(code);\n    }\n\n    function inspectDone(code) {\n      inspectResult.continued = subcontinued;\n      self.interrupt = self.containerState = undefined;\n      return ok(code);\n    }\n  }\n}\n\nfunction tokenizeContainer(effects, ok, nok) {\n  return factorySpace(effects, effects.attempt(this.parser.constructs.document, ok, nok), 'linePrefix', this.parser.constructs.disable.null.indexOf('codeIndented') > -1 ? undefined : 4);\n}\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}\n\nexports.tokenize = tokenize;","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nvar content = require('../tokenize/content.js');\n\nvar factorySpace = require('../tokenize/factory-space.js');\n\nvar partialBlankLine = require('../tokenize/partial-blank-line.js');\n\nvar tokenize = initializeFlow;\n\nfunction initializeFlow(effects) {\n  var self = this;\n  var initial = effects.attempt( // Try to parse a blank line.\n  partialBlankLine, atBlankEnding, // 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\n  function atBlankEnding(code) {\n    if (code === null) {\n      effects.consume(code);\n      return;\n    }\n\n    effects.enter('lineEndingBlank');\n    effects.consume(code);\n    effects.exit('lineEndingBlank');\n    self.currentConstruct = undefined;\n    return initial;\n  }\n\n  function afterConstruct(code) {\n    if (code === null) {\n      effects.consume(code);\n      return;\n    }\n\n    effects.enter('lineEnding');\n    effects.consume(code);\n    effects.exit('lineEnding');\n    self.currentConstruct = undefined;\n    return initial;\n  }\n}\n\nexports.tokenize = tokenize;","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nvar assign = require('../constant/assign.js');\n\nvar shallow = require('../util/shallow.js');\n\nvar text = initializeFactory('text');\nvar string = initializeFactory('string');\nvar resolver = {\n  resolveAll: createResolver()\n};\n\nfunction initializeFactory(field) {\n  return {\n    tokenize: initializeText,\n    resolveAll: createResolver(field === 'text' ? resolveAllLineSuffixes : undefined)\n  };\n\n  function initializeText(effects) {\n    var self = this;\n    var constructs = this.parser.constructs[field];\n    var text = effects.attempt(constructs, start, notText);\n    return start;\n\n    function start(code) {\n      return atBreak(code) ? text(code) : notText(code);\n    }\n\n    function notText(code) {\n      if (code === null) {\n        effects.consume(code);\n        return;\n      }\n\n      effects.enter('data');\n      effects.consume(code);\n      return data;\n    }\n\n    function data(code) {\n      if (atBreak(code)) {\n        effects.exit('data');\n        return text(code);\n      } // Data.\n\n\n      effects.consume(code);\n      return data;\n    }\n\n    function atBreak(code) {\n      var list = constructs[code];\n      var index = -1;\n\n      if (code === null) {\n        return true;\n      }\n\n      if (list) {\n        while (++index < list.length) {\n          if (!list[index].previous || list[index].previous.call(self, self.previous)) {\n            return true;\n          }\n        }\n      }\n    }\n  }\n}\n\nfunction createResolver(extraResolver) {\n  return resolveAllText;\n\n  function resolveAllText(events, context) {\n    var index = -1;\n    var enter; // A rather boring computation (to merge adjacent `data` events) which\n    // improves mm performance by 29%.\n\n    while (++index <= events.length) {\n      if (enter === undefined) {\n        if (events[index] && events[index][1].type === 'data') {\n          enter = index;\n          index++;\n        }\n      } else if (!events[index] || events[index][1].type !== 'data') {\n        // Don’t do anything if there is one data token.\n        if (index !== enter + 2) {\n          events[enter][1].end = events[index - 1][1].end;\n          events.splice(enter + 2, index - enter - 2);\n          index = enter + 2;\n        }\n\n        enter = undefined;\n      }\n    }\n\n    return extraResolver ? extraResolver(events, context) : events;\n  }\n} // A rather ugly set of instructions which again looks at chunks in the input\n// stream.\n// The reason to do this here is that it is *much* faster to parse in reverse.\n// And that we can’t hook into `null` to split the line suffix before an EOF.\n// To do: figure out if we can make this into a clean utility, or even in core.\n// As it will be useful for GFMs literal autolink extension (and maybe even\n// tables?)\n\n\nfunction resolveAllLineSuffixes(events, context) {\n  var eventIndex = -1;\n  var chunks;\n  var data;\n  var chunk;\n  var index;\n  var bufferIndex;\n  var size;\n  var tabs;\n  var token;\n\n  while (++eventIndex <= events.length) {\n    if ((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\n      while (index--) {\n        chunk = chunks[index];\n\n        if (typeof chunk === 'string') {\n          bufferIndex = chunk.length;\n\n          while (chunk.charCodeAt(bufferIndex - 1) === 32) {\n            size++;\n            bufferIndex--;\n          }\n\n          if (bufferIndex) break;\n          bufferIndex = -1;\n        } // Number\n        else if (chunk === -2) {\n          tabs = true;\n          size++;\n        } else if (chunk === -1) ;else {\n          // Replacement character, exit.\n          index++;\n          break;\n        }\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\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\n      eventIndex++;\n    }\n  }\n\n  return events;\n}\n\nexports.resolver = resolver;\nexports.string = string;\nexports.text = text;","'use strict';\n\nvar content = require('./initialize/content.js');\n\nvar document = require('./initialize/document.js');\n\nvar flow = require('./initialize/flow.js');\n\nvar text = require('./initialize/text.js');\n\nvar combineExtensions = require('./util/combine-extensions.js');\n\nvar createTokenizer = require('./util/create-tokenizer.js');\n\nvar miniflat = require('./util/miniflat.js');\n\nvar constructs = require('./constructs.js');\n\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\n  function create(initializer) {\n    return creator;\n\n    function creator(from) {\n      return createTokenizer(parser, initializer, from);\n    }\n  }\n}\n\nmodule.exports = parse;","'use strict';\n\nvar subtokenize = require('./util/subtokenize.js');\n\nfunction postprocess(events) {\n  while (!subtokenize(events)) {// Empty\n  }\n\n  return events;\n}\n\nmodule.exports = postprocess;","'use strict';\n\nvar search = /[\\0\\t\\n\\r]/g;\n\nfunction preprocess() {\n  var start = true;\n  var column = 1;\n  var buffer = '';\n  var atCarriageReturn;\n  return preprocessor;\n\n  function preprocessor(value, encoding, end) {\n    var chunks = [];\n    var match;\n    var next;\n    var startPosition;\n    var endPosition;\n    var code;\n    value = buffer + value.toString(encoding);\n    startPosition = 0;\n    buffer = '';\n\n    if (start) {\n      if (value.charCodeAt(0) === 65279) {\n        startPosition++;\n      }\n\n      start = undefined;\n    }\n\n    while (startPosition < value.length) {\n      search.lastIndex = startPosition;\n      match = search.exec(value);\n      endPosition = match ? match.index : value.length;\n      code = value.charCodeAt(endPosition);\n\n      if (!match) {\n        buffer = value.slice(startPosition);\n        break;\n      }\n\n      if (code === 10 && startPosition === endPosition && atCarriageReturn) {\n        chunks.push(-3);\n        atCarriageReturn = undefined;\n      } else {\n        if (atCarriageReturn) {\n          chunks.push(-5);\n          atCarriageReturn = undefined;\n        }\n\n        if (startPosition < endPosition) {\n          chunks.push(value.slice(startPosition, endPosition));\n          column += endPosition - startPosition;\n        }\n\n        if (code === 0) {\n          chunks.push(65533);\n          column++;\n        } else if (code === 9) {\n          next = Math.ceil(column / 4) * 4;\n          chunks.push(-2);\n\n          while (column++ < next) {\n            chunks.push(-1);\n          }\n        } else if (code === 10) {\n          chunks.push(-4);\n          column = 1;\n        } // Must be carriage return.\n        else {\n          atCarriageReturn = true;\n          column = 1;\n        }\n      }\n\n      startPosition = endPosition + 1;\n    }\n\n    if (end) {\n      if (atCarriageReturn) chunks.push(-5);\n      if (buffer) chunks.push(buffer);\n      chunks.push(null);\n    }\n\n    return chunks;\n  }\n}\n\nmodule.exports = preprocess;","'use strict';\n\nvar chunkedPush = require('../util/chunked-push.js');\n\nvar chunkedSplice = require('../util/chunked-splice.js');\n\nvar classifyCharacter = require('../util/classify-character.js');\n\nvar movePoint = require('../util/move-point.js');\n\nvar resolveAll = require('../util/resolve-all.js');\n\nvar shallow = require('../util/shallow.js');\n\nvar attention = {\n  name: 'attention',\n  tokenize: tokenizeAttention,\n  resolveAll: resolveAllAttention\n};\n\nfunction resolveAllAttention(events, context) {\n  var index = -1;\n  var open;\n  var group;\n  var text;\n  var openingSequence;\n  var closingSequence;\n  var use;\n  var nextEvents;\n  var offset; // Walk through all events.\n  //\n  // Note: performance of this is fine on an mb of normal markdown, but it’s\n  // a bottleneck for malicious stuff.\n\n  while (++index < events.length) {\n    // Find a token that can close.\n    if (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 && // 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\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\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\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\n  index = -1;\n\n  while (++index < events.length) {\n    if (events[index][1].type === 'attentionSequence') {\n      events[index][1].type = 'data';\n    }\n  }\n\n  return events;\n}\n\nfunction tokenizeAttention(effects, ok) {\n  var before = classifyCharacter(this.previous);\n  var marker;\n  return start;\n\n  function start(code) {\n    effects.enter('attentionSequence');\n    marker = code;\n    return sequence(code);\n  }\n\n  function sequence(code) {\n    var token;\n    var after;\n    var open;\n    var close;\n\n    if (code === marker) {\n      effects.consume(code);\n      return sequence;\n    }\n\n    token = effects.exit('attentionSequence');\n    after = classifyCharacter(code);\n    open = !after || after === 2 && before;\n    close = !before || before === 2 && after;\n    token._open = marker === 42 ? open : open && (before || !close);\n    token._close = marker === 42 ? close : close && (after || !open);\n    return ok(code);\n  }\n}\n\nmodule.exports = attention;","'use strict';\n\nvar asciiAlpha = require('../character/ascii-alpha.js');\n\nvar asciiAlphanumeric = require('../character/ascii-alphanumeric.js');\n\nvar asciiAtext = require('../character/ascii-atext.js');\n\nvar asciiControl = require('../character/ascii-control.js');\n\nvar autolink = {\n  name: 'autolink',\n  tokenize: tokenizeAutolink\n};\n\nfunction tokenizeAutolink(effects, ok, nok) {\n  var size = 1;\n  return start;\n\n  function start(code) {\n    effects.enter('autolink');\n    effects.enter('autolinkMarker');\n    effects.consume(code);\n    effects.exit('autolinkMarker');\n    effects.enter('autolinkProtocol');\n    return open;\n  }\n\n  function open(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return schemeOrEmailAtext;\n    }\n\n    return asciiAtext(code) ? emailAtext(code) : nok(code);\n  }\n\n  function schemeOrEmailAtext(code) {\n    return code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code) ? schemeInsideOrEmailAtext(code) : emailAtext(code);\n  }\n\n  function schemeInsideOrEmailAtext(code) {\n    if (code === 58) {\n      effects.consume(code);\n      return urlInside;\n    }\n\n    if ((code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) && size++ < 32) {\n      effects.consume(code);\n      return schemeInsideOrEmailAtext;\n    }\n\n    return emailAtext(code);\n  }\n\n  function urlInside(code) {\n    if (code === 62) {\n      effects.exit('autolinkProtocol');\n      return end(code);\n    }\n\n    if (code === 32 || code === 60 || asciiControl(code)) {\n      return nok(code);\n    }\n\n    effects.consume(code);\n    return urlInside;\n  }\n\n  function emailAtext(code) {\n    if (code === 64) {\n      effects.consume(code);\n      size = 0;\n      return emailAtSignOrDot;\n    }\n\n    if (asciiAtext(code)) {\n      effects.consume(code);\n      return emailAtext;\n    }\n\n    return nok(code);\n  }\n\n  function emailAtSignOrDot(code) {\n    return asciiAlphanumeric(code) ? emailLabel(code) : nok(code);\n  }\n\n  function emailLabel(code) {\n    if (code === 46) {\n      effects.consume(code);\n      size = 0;\n      return emailAtSignOrDot;\n    }\n\n    if (code === 62) {\n      // Exit, then change the type.\n      effects.exit('autolinkProtocol').type = 'autolinkEmail';\n      return end(code);\n    }\n\n    return emailValue(code);\n  }\n\n  function emailValue(code) {\n    if ((code === 45 || asciiAlphanumeric(code)) && size++ < 63) {\n      effects.consume(code);\n      return code === 45 ? emailValue : emailLabel;\n    }\n\n    return nok(code);\n  }\n\n  function end(code) {\n    effects.enter('autolinkMarker');\n    effects.consume(code);\n    effects.exit('autolinkMarker');\n    effects.exit('autolink');\n    return ok;\n  }\n}\n\nmodule.exports = autolink;","'use strict';\n\nvar markdownSpace = require('../character/markdown-space.js');\n\nvar factorySpace = require('./factory-space.js');\n\nvar blockQuote = {\n  name: 'blockQuote',\n  tokenize: tokenizeBlockQuoteStart,\n  continuation: {\n    tokenize: tokenizeBlockQuoteContinuation\n  },\n  exit: exit\n};\n\nfunction tokenizeBlockQuoteStart(effects, ok, nok) {\n  var self = this;\n  return start;\n\n  function start(code) {\n    if (code === 62) {\n      if (!self.containerState.open) {\n        effects.enter('blockQuote', {\n          _container: true\n        });\n        self.containerState.open = true;\n      }\n\n      effects.enter('blockQuotePrefix');\n      effects.enter('blockQuoteMarker');\n      effects.consume(code);\n      effects.exit('blockQuoteMarker');\n      return after;\n    }\n\n    return nok(code);\n  }\n\n  function after(code) {\n    if (markdownSpace(code)) {\n      effects.enter('blockQuotePrefixWhitespace');\n      effects.consume(code);\n      effects.exit('blockQuotePrefixWhitespace');\n      effects.exit('blockQuotePrefix');\n      return ok;\n    }\n\n    effects.exit('blockQuotePrefix');\n    return ok(code);\n  }\n}\n\nfunction tokenizeBlockQuoteContinuation(effects, ok, nok) {\n  return factorySpace(effects, effects.attempt(blockQuote, ok, nok), 'linePrefix', this.parser.constructs.disable.null.indexOf('codeIndented') > -1 ? undefined : 4);\n}\n\nfunction exit(effects) {\n  effects.exit('blockQuote');\n}\n\nmodule.exports = blockQuote;","'use strict';\n\nvar asciiPunctuation = require('../character/ascii-punctuation.js');\n\nvar characterEscape = {\n  name: 'characterEscape',\n  tokenize: tokenizeCharacterEscape\n};\n\nfunction tokenizeCharacterEscape(effects, ok, nok) {\n  return start;\n\n  function start(code) {\n    effects.enter('characterEscape');\n    effects.enter('escapeMarker');\n    effects.consume(code);\n    effects.exit('escapeMarker');\n    return open;\n  }\n\n  function open(code) {\n    if (asciiPunctuation(code)) {\n      effects.enter('characterEscapeValue');\n      effects.consume(code);\n      effects.exit('characterEscapeValue');\n      effects.exit('characterEscape');\n      return ok;\n    }\n\n    return nok(code);\n  }\n}\n\nmodule.exports = characterEscape;","'use strict';\n\nvar decodeEntity = require('parse-entities/decode-entity.js');\n\nvar asciiAlphanumeric = require('../character/ascii-alphanumeric.js');\n\nvar asciiDigit = require('../character/ascii-digit.js');\n\nvar asciiHexDigit = require('../character/ascii-hex-digit.js');\n\nfunction _interopDefaultLegacy(e) {\n  return e && typeof e === 'object' && 'default' in e ? e : {\n    default: e\n  };\n}\n\nvar decodeEntity__default = /*#__PURE__*/_interopDefaultLegacy(decodeEntity);\n\nvar characterReference = {\n  name: 'characterReference',\n  tokenize: tokenizeCharacterReference\n};\n\nfunction tokenizeCharacterReference(effects, ok, nok) {\n  var self = this;\n  var size = 0;\n  var max;\n  var test;\n  return start;\n\n  function start(code) {\n    effects.enter('characterReference');\n    effects.enter('characterReferenceMarker');\n    effects.consume(code);\n    effects.exit('characterReferenceMarker');\n    return open;\n  }\n\n  function open(code) {\n    if (code === 35) {\n      effects.enter('characterReferenceMarkerNumeric');\n      effects.consume(code);\n      effects.exit('characterReferenceMarkerNumeric');\n      return numeric;\n    }\n\n    effects.enter('characterReferenceValue');\n    max = 31;\n    test = asciiAlphanumeric;\n    return value(code);\n  }\n\n  function numeric(code) {\n    if (code === 88 || code === 120) {\n      effects.enter('characterReferenceMarkerHexadecimal');\n      effects.consume(code);\n      effects.exit('characterReferenceMarkerHexadecimal');\n      effects.enter('characterReferenceValue');\n      max = 6;\n      test = asciiHexDigit;\n      return value;\n    }\n\n    effects.enter('characterReferenceValue');\n    max = 7;\n    test = asciiDigit;\n    return value(code);\n  }\n\n  function value(code) {\n    var token;\n\n    if (code === 59 && size) {\n      token = effects.exit('characterReferenceValue');\n\n      if (test === asciiAlphanumeric && !decodeEntity__default['default'](self.sliceSerialize(token))) {\n        return nok(code);\n      }\n\n      effects.enter('characterReferenceMarker');\n      effects.consume(code);\n      effects.exit('characterReferenceMarker');\n      effects.exit('characterReference');\n      return ok;\n    }\n\n    if (test(code) && size++ < max) {\n      effects.consume(code);\n      return value;\n    }\n\n    return nok(code);\n  }\n}\n\nmodule.exports = characterReference;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js');\n\nvar prefixSize = require('../util/prefix-size.js');\n\nvar factorySpace = require('./factory-space.js');\n\nvar codeFenced = {\n  name: 'codeFenced',\n  tokenize: tokenizeCodeFenced,\n  concrete: true\n};\n\nfunction tokenizeCodeFenced(effects, ok, nok) {\n  var self = this;\n  var closingFenceConstruct = {\n    tokenize: tokenizeClosingFence,\n    partial: true\n  };\n  var initialPrefix = prefixSize(this.events, 'linePrefix');\n  var sizeOpen = 0;\n  var marker;\n  return start;\n\n  function start(code) {\n    effects.enter('codeFenced');\n    effects.enter('codeFencedFence');\n    effects.enter('codeFencedFenceSequence');\n    marker = code;\n    return sequenceOpen(code);\n  }\n\n  function sequenceOpen(code) {\n    if (code === marker) {\n      effects.consume(code);\n      sizeOpen++;\n      return sequenceOpen;\n    }\n\n    effects.exit('codeFencedFenceSequence');\n    return sizeOpen < 3 ? nok(code) : factorySpace(effects, infoOpen, 'whitespace')(code);\n  }\n\n  function infoOpen(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return openAfter(code);\n    }\n\n    effects.enter('codeFencedFenceInfo');\n    effects.enter('chunkString', {\n      contentType: 'string'\n    });\n    return info(code);\n  }\n\n  function info(code) {\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      effects.exit('chunkString');\n      effects.exit('codeFencedFenceInfo');\n      return factorySpace(effects, infoAfter, 'whitespace')(code);\n    }\n\n    if (code === 96 && code === marker) return nok(code);\n    effects.consume(code);\n    return info;\n  }\n\n  function infoAfter(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return openAfter(code);\n    }\n\n    effects.enter('codeFencedFenceMeta');\n    effects.enter('chunkString', {\n      contentType: 'string'\n    });\n    return meta(code);\n  }\n\n  function meta(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('chunkString');\n      effects.exit('codeFencedFenceMeta');\n      return openAfter(code);\n    }\n\n    if (code === 96 && code === marker) return nok(code);\n    effects.consume(code);\n    return meta;\n  }\n\n  function openAfter(code) {\n    effects.exit('codeFencedFence');\n    return self.interrupt ? ok(code) : content(code);\n  }\n\n  function content(code) {\n    if (code === null) {\n      return after(code);\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding');\n      effects.consume(code);\n      effects.exit('lineEnding');\n      return effects.attempt(closingFenceConstruct, after, initialPrefix ? factorySpace(effects, content, 'linePrefix', initialPrefix + 1) : content);\n    }\n\n    effects.enter('codeFlowValue');\n    return contentContinue(code);\n  }\n\n  function contentContinue(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('codeFlowValue');\n      return content(code);\n    }\n\n    effects.consume(code);\n    return contentContinue;\n  }\n\n  function after(code) {\n    effects.exit('codeFenced');\n    return ok(code);\n  }\n\n  function tokenizeClosingFence(effects, ok, nok) {\n    var size = 0;\n    return factorySpace(effects, closingSequenceStart, 'linePrefix', this.parser.constructs.disable.null.indexOf('codeIndented') > -1 ? undefined : 4);\n\n    function closingSequenceStart(code) {\n      effects.enter('codeFencedFence');\n      effects.enter('codeFencedFenceSequence');\n      return closingSequence(code);\n    }\n\n    function closingSequence(code) {\n      if (code === marker) {\n        effects.consume(code);\n        size++;\n        return closingSequence;\n      }\n\n      if (size < sizeOpen) return nok(code);\n      effects.exit('codeFencedFenceSequence');\n      return factorySpace(effects, closingSequenceEnd, 'whitespace')(code);\n    }\n\n    function closingSequenceEnd(code) {\n      if (code === null || markdownLineEnding(code)) {\n        effects.exit('codeFencedFence');\n        return ok(code);\n      }\n\n      return nok(code);\n    }\n  }\n}\n\nmodule.exports = codeFenced;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar chunkedSplice = require('../util/chunked-splice.js');\n\nvar prefixSize = require('../util/prefix-size.js');\n\nvar factorySpace = require('./factory-space.js');\n\nvar codeIndented = {\n  name: 'codeIndented',\n  tokenize: tokenizeCodeIndented,\n  resolve: resolveCodeIndented\n};\nvar indentedContentConstruct = {\n  tokenize: tokenizeIndentedContent,\n  partial: true\n};\n\nfunction resolveCodeIndented(events, context) {\n  var code = {\n    type: 'codeIndented',\n    start: events[0][1].start,\n    end: events[events.length - 1][1].end\n  };\n  chunkedSplice(events, 0, 0, [['enter', code, context]]);\n  chunkedSplice(events, events.length, 0, [['exit', code, context]]);\n  return events;\n}\n\nfunction tokenizeCodeIndented(effects, ok, nok) {\n  return effects.attempt(indentedContentConstruct, afterPrefix, nok);\n\n  function afterPrefix(code) {\n    if (code === null) {\n      return ok(code);\n    }\n\n    if (markdownLineEnding(code)) {\n      return effects.attempt(indentedContentConstruct, afterPrefix, ok)(code);\n    }\n\n    effects.enter('codeFlowValue');\n    return content(code);\n  }\n\n  function content(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('codeFlowValue');\n      return afterPrefix(code);\n    }\n\n    effects.consume(code);\n    return content;\n  }\n}\n\nfunction tokenizeIndentedContent(effects, ok, nok) {\n  var self = this;\n  return factorySpace(effects, afterPrefix, 'linePrefix', 4 + 1);\n\n  function afterPrefix(code) {\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding');\n      effects.consume(code);\n      effects.exit('lineEnding');\n      return factorySpace(effects, afterPrefix, 'linePrefix', 4 + 1);\n    }\n\n    return prefixSize(self.events, 'linePrefix') < 4 ? nok(code) : ok(code);\n  }\n}\n\nmodule.exports = codeIndented;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar codeText = {\n  name: 'codeText',\n  tokenize: tokenizeCodeText,\n  resolve: resolveCodeText,\n  previous: previous\n};\n\nfunction resolveCodeText(events) {\n  var tailExitIndex = events.length - 4;\n  var headEnterIndex = 3;\n  var index;\n  var enter; // If we start and end with an EOL or a space.\n\n  if ((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\n  index = headEnterIndex - 1;\n  tailExitIndex++;\n\n  while (++index <= tailExitIndex) {\n    if (enter === undefined) {\n      if (index !== tailExitIndex && events[index][1].type !== 'lineEnding') {\n        enter = index;\n      }\n    } else if (index === tailExitIndex || events[index][1].type === 'lineEnding') {\n      events[enter][1].type = 'codeTextData';\n\n      if (index !== enter + 2) {\n        events[enter][1].end = events[index - 1][1].end;\n        events.splice(enter + 2, index - enter - 2);\n        tailExitIndex -= index - enter - 2;\n        index = enter + 2;\n      }\n\n      enter = undefined;\n    }\n  }\n\n  return events;\n}\n\nfunction previous(code) {\n  // If there is a previous code, there will always be a tail.\n  return code !== 96 || this.events[this.events.length - 1][1].type === 'characterEscape';\n}\n\nfunction tokenizeCodeText(effects, ok, nok) {\n  var sizeOpen = 0;\n  var size;\n  var token;\n  return start;\n\n  function start(code) {\n    effects.enter('codeText');\n    effects.enter('codeTextSequence');\n    return openingSequence(code);\n  }\n\n  function openingSequence(code) {\n    if (code === 96) {\n      effects.consume(code);\n      sizeOpen++;\n      return openingSequence;\n    }\n\n    effects.exit('codeTextSequence');\n    return gap(code);\n  }\n\n  function gap(code) {\n    // EOF.\n    if (code === null) {\n      return nok(code);\n    } // Closing fence?\n    // Could also be data.\n\n\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\n    if (code === 32) {\n      effects.enter('space');\n      effects.consume(code);\n      effects.exit('space');\n      return gap;\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding');\n      effects.consume(code);\n      effects.exit('lineEnding');\n      return gap;\n    } // Data.\n\n\n    effects.enter('codeTextData');\n    return data(code);\n  } // In code.\n\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\n    effects.consume(code);\n    return data;\n  } // Closing fence.\n\n\n  function closingSequence(code) {\n    // More.\n    if (code === 96) {\n      effects.consume(code);\n      size++;\n      return closingSequence;\n    } // Done!\n\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\n    token.type = 'codeTextData';\n    return data(code);\n  }\n}\n\nmodule.exports = codeText;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar prefixSize = require('../util/prefix-size.js');\n\nvar subtokenize = require('../util/subtokenize.js');\n\nvar factorySpace = require('./factory-space.js'); // No name because it must not be turned off.\n\n\nvar content = {\n  tokenize: tokenizeContent,\n  resolve: resolveContent,\n  interruptible: true,\n  lazy: true\n};\nvar continuationConstruct = {\n  tokenize: tokenizeContinuation,\n  partial: true\n}; // Content is transparent: it’s parsed right now. That way, definitions are also\n// parsed right now: before text in paragraphs (specifically, media) are parsed.\n\nfunction resolveContent(events) {\n  subtokenize(events);\n  return events;\n}\n\nfunction tokenizeContent(effects, ok) {\n  var previous;\n  return start;\n\n  function start(code) {\n    effects.enter('content');\n    previous = effects.enter('chunkContent', {\n      contentType: 'content'\n    });\n    return data(code);\n  }\n\n  function data(code) {\n    if (code === null) {\n      return contentEnd(code);\n    }\n\n    if (markdownLineEnding(code)) {\n      return effects.check(continuationConstruct, contentContinue, contentEnd)(code);\n    } // Data.\n\n\n    effects.consume(code);\n    return data;\n  }\n\n  function contentEnd(code) {\n    effects.exit('chunkContent');\n    effects.exit('content');\n    return ok(code);\n  }\n\n  function contentContinue(code) {\n    effects.consume(code);\n    effects.exit('chunkContent');\n    previous = previous.next = effects.enter('chunkContent', {\n      contentType: 'content',\n      previous: previous\n    });\n    return data;\n  }\n}\n\nfunction tokenizeContinuation(effects, ok, nok) {\n  var self = this;\n  return startLookahead;\n\n  function startLookahead(code) {\n    effects.enter('lineEnding');\n    effects.consume(code);\n    effects.exit('lineEnding');\n    return factorySpace(effects, prefixed, 'linePrefix');\n  }\n\n  function prefixed(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code);\n    }\n\n    if (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\n    return ok(code);\n  }\n}\n\nmodule.exports = content;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js');\n\nvar normalizeIdentifier = require('../util/normalize-identifier.js');\n\nvar factoryDestination = require('./factory-destination.js');\n\nvar factoryLabel = require('./factory-label.js');\n\nvar factorySpace = require('./factory-space.js');\n\nvar factoryWhitespace = require('./factory-whitespace.js');\n\nvar factoryTitle = require('./factory-title.js');\n\nvar definition = {\n  name: 'definition',\n  tokenize: tokenizeDefinition\n};\nvar titleConstruct = {\n  tokenize: tokenizeTitle,\n  partial: true\n};\n\nfunction tokenizeDefinition(effects, ok, nok) {\n  var self = this;\n  var identifier;\n  return start;\n\n  function start(code) {\n    effects.enter('definition');\n    return factoryLabel.call(self, effects, labelAfter, nok, 'definitionLabel', 'definitionLabelMarker', 'definitionLabelString')(code);\n  }\n\n  function labelAfter(code) {\n    identifier = normalizeIdentifier(self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1));\n\n    if (code === 58) {\n      effects.enter('definitionMarker');\n      effects.consume(code);\n      effects.exit('definitionMarker'); // Note: blank lines can’t exist in content.\n\n      return factoryWhitespace(effects, factoryDestination(effects, effects.attempt(titleConstruct, factorySpace(effects, after, 'whitespace'), factorySpace(effects, after, 'whitespace')), nok, 'definitionDestination', 'definitionDestinationLiteral', 'definitionDestinationLiteralMarker', 'definitionDestinationRaw', 'definitionDestinationString'));\n    }\n\n    return nok(code);\n  }\n\n  function after(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('definition');\n\n      if (self.parser.defined.indexOf(identifier) < 0) {\n        self.parser.defined.push(identifier);\n      }\n\n      return ok(code);\n    }\n\n    return nok(code);\n  }\n}\n\nfunction tokenizeTitle(effects, ok, nok) {\n  return start;\n\n  function start(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, before)(code) : nok(code);\n  }\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\n    return nok(code);\n  }\n\n  function after(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code);\n  }\n}\n\nmodule.exports = definition;","'use strict';\n\nvar asciiControl = require('../character/ascii-control.js');\n\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js');\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js'); // eslint-disable-next-line max-params\n\n\nfunction destinationFactory(effects, ok, nok, type, literalType, literalMarkerType, rawType, stringType, max) {\n  var limit = max || Infinity;\n  var balance = 0;\n  return start;\n\n  function start(code) {\n    if (code === 60) {\n      effects.enter(type);\n      effects.enter(literalType);\n      effects.enter(literalMarkerType);\n      effects.consume(code);\n      effects.exit(literalMarkerType);\n      return destinationEnclosedBefore;\n    }\n\n    if (asciiControl(code) || code === 41) {\n      return nok(code);\n    }\n\n    effects.enter(type);\n    effects.enter(rawType);\n    effects.enter(stringType);\n    effects.enter('chunkString', {\n      contentType: 'string'\n    });\n    return destinationRaw(code);\n  }\n\n  function destinationEnclosedBefore(code) {\n    if (code === 62) {\n      effects.enter(literalMarkerType);\n      effects.consume(code);\n      effects.exit(literalMarkerType);\n      effects.exit(literalType);\n      effects.exit(type);\n      return ok;\n    }\n\n    effects.enter(stringType);\n    effects.enter('chunkString', {\n      contentType: 'string'\n    });\n    return destinationEnclosed(code);\n  }\n\n  function destinationEnclosed(code) {\n    if (code === 62) {\n      effects.exit('chunkString');\n      effects.exit(stringType);\n      return destinationEnclosedBefore(code);\n    }\n\n    if (code === null || code === 60 || markdownLineEnding(code)) {\n      return nok(code);\n    }\n\n    effects.consume(code);\n    return code === 92 ? destinationEnclosedEscape : destinationEnclosed;\n  }\n\n  function destinationEnclosedEscape(code) {\n    if (code === 60 || code === 62 || code === 92) {\n      effects.consume(code);\n      return destinationEnclosed;\n    }\n\n    return destinationEnclosed(code);\n  }\n\n  function destinationRaw(code) {\n    if (code === 40) {\n      if (++balance > limit) return nok(code);\n      effects.consume(code);\n      return destinationRaw;\n    }\n\n    if (code === 41) {\n      if (!balance--) {\n        effects.exit('chunkString');\n        effects.exit(stringType);\n        effects.exit(rawType);\n        effects.exit(type);\n        return ok(code);\n      }\n\n      effects.consume(code);\n      return destinationRaw;\n    }\n\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      if (balance) return nok(code);\n      effects.exit('chunkString');\n      effects.exit(stringType);\n      effects.exit(rawType);\n      effects.exit(type);\n      return ok(code);\n    }\n\n    if (asciiControl(code)) return nok(code);\n    effects.consume(code);\n    return code === 92 ? destinationRawEscape : destinationRaw;\n  }\n\n  function destinationRawEscape(code) {\n    if (code === 40 || code === 41 || code === 92) {\n      effects.consume(code);\n      return destinationRaw;\n    }\n\n    return destinationRaw(code);\n  }\n}\n\nmodule.exports = destinationFactory;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar markdownSpace = require('../character/markdown-space.js'); // eslint-disable-next-line max-params\n\n\nfunction labelFactory(effects, ok, nok, type, markerType, stringType) {\n  var self = this;\n  var size = 0;\n  var data;\n  return start;\n\n  function start(code) {\n    effects.enter(type);\n    effects.enter(markerType);\n    effects.consume(code);\n    effects.exit(markerType);\n    effects.enter(stringType);\n    return atBreak;\n  }\n\n  function atBreak(code) {\n    if (code === null || code === 91 || code === 93 && !data || code === 94 &&\n    /* c8 ignore next */\n    !size &&\n    /* c8 ignore next */\n    '_hiddenFootnoteSupport' in self.parser.constructs || size > 999) {\n      return nok(code);\n    }\n\n    if (code === 93) {\n      effects.exit(stringType);\n      effects.enter(markerType);\n      effects.consume(code);\n      effects.exit(markerType);\n      effects.exit(type);\n      return ok;\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding');\n      effects.consume(code);\n      effects.exit('lineEnding');\n      return atBreak;\n    }\n\n    effects.enter('chunkString', {\n      contentType: 'string'\n    });\n    return label(code);\n  }\n\n  function label(code) {\n    if (code === null || code === 91 || code === 93 || markdownLineEnding(code) || size++ > 999) {\n      effects.exit('chunkString');\n      return atBreak(code);\n    }\n\n    effects.consume(code);\n    data = data || !markdownSpace(code);\n    return code === 92 ? labelEscape : label;\n  }\n\n  function labelEscape(code) {\n    if (code === 91 || code === 92 || code === 93) {\n      effects.consume(code);\n      size++;\n      return label;\n    }\n\n    return label(code);\n  }\n}\n\nmodule.exports = labelFactory;","'use strict';\n\nvar markdownSpace = require('../character/markdown-space.js');\n\nfunction spaceFactory(effects, ok, type, max) {\n  var limit = max ? max - 1 : Infinity;\n  var size = 0;\n  return start;\n\n  function start(code) {\n    if (markdownSpace(code)) {\n      effects.enter(type);\n      return prefix(code);\n    }\n\n    return ok(code);\n  }\n\n  function prefix(code) {\n    if (markdownSpace(code) && size++ < limit) {\n      effects.consume(code);\n      return prefix;\n    }\n\n    effects.exit(type);\n    return ok(code);\n  }\n}\n\nmodule.exports = spaceFactory;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar factorySpace = require('./factory-space.js');\n\nfunction titleFactory(effects, ok, nok, type, markerType, stringType) {\n  var marker;\n  return start;\n\n  function start(code) {\n    effects.enter(type);\n    effects.enter(markerType);\n    effects.consume(code);\n    effects.exit(markerType);\n    marker = code === 40 ? 41 : code;\n    return atFirstTitleBreak;\n  }\n\n  function atFirstTitleBreak(code) {\n    if (code === marker) {\n      effects.enter(markerType);\n      effects.consume(code);\n      effects.exit(markerType);\n      effects.exit(type);\n      return ok;\n    }\n\n    effects.enter(stringType);\n    return atTitleBreak(code);\n  }\n\n  function atTitleBreak(code) {\n    if (code === marker) {\n      effects.exit(stringType);\n      return atFirstTitleBreak(marker);\n    }\n\n    if (code === null) {\n      return nok(code);\n    } // Note: blank lines can’t exist in content.\n\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding');\n      effects.consume(code);\n      effects.exit('lineEnding');\n      return factorySpace(effects, atTitleBreak, 'linePrefix');\n    }\n\n    effects.enter('chunkString', {\n      contentType: 'string'\n    });\n    return title(code);\n  }\n\n  function title(code) {\n    if (code === marker || code === null || markdownLineEnding(code)) {\n      effects.exit('chunkString');\n      return atTitleBreak(code);\n    }\n\n    effects.consume(code);\n    return code === 92 ? titleEscape : title;\n  }\n\n  function titleEscape(code) {\n    if (code === marker || code === 92) {\n      effects.consume(code);\n      return title;\n    }\n\n    return title(code);\n  }\n}\n\nmodule.exports = titleFactory;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar markdownSpace = require('../character/markdown-space.js');\n\nvar factorySpace = require('./factory-space.js');\n\nfunction whitespaceFactory(effects, ok) {\n  var seen;\n  return start;\n\n  function start(code) {\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding');\n      effects.consume(code);\n      effects.exit('lineEnding');\n      seen = true;\n      return start;\n    }\n\n    if (markdownSpace(code)) {\n      return factorySpace(effects, start, seen ? 'linePrefix' : 'lineSuffix')(code);\n    }\n\n    return ok(code);\n  }\n}\n\nmodule.exports = whitespaceFactory;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar hardBreakEscape = {\n  name: 'hardBreakEscape',\n  tokenize: tokenizeHardBreakEscape\n};\n\nfunction tokenizeHardBreakEscape(effects, ok, nok) {\n  return start;\n\n  function start(code) {\n    effects.enter('hardBreakEscape');\n    effects.enter('escapeMarker');\n    effects.consume(code);\n    return open;\n  }\n\n  function open(code) {\n    if (markdownLineEnding(code)) {\n      effects.exit('escapeMarker');\n      effects.exit('hardBreakEscape');\n      return ok(code);\n    }\n\n    return nok(code);\n  }\n}\n\nmodule.exports = hardBreakEscape;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js');\n\nvar markdownSpace = require('../character/markdown-space.js');\n\nvar chunkedSplice = require('../util/chunked-splice.js');\n\nvar factorySpace = require('./factory-space.js');\n\nvar headingAtx = {\n  name: 'headingAtx',\n  tokenize: tokenizeHeadingAtx,\n  resolve: resolveHeadingAtx\n};\n\nfunction resolveHeadingAtx(events, context) {\n  var contentEnd = events.length - 2;\n  var contentStart = 3;\n  var content;\n  var text; // Prefix whitespace, part of the opening.\n\n  if (events[contentStart][1].type === 'whitespace') {\n    contentStart += 2;\n  } // Suffix whitespace, part of the closing.\n\n\n  if (contentEnd - 2 > contentStart && events[contentEnd][1].type === 'whitespace') {\n    contentEnd -= 2;\n  }\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\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\n  return events;\n}\n\nfunction tokenizeHeadingAtx(effects, ok, nok) {\n  var self = this;\n  var size = 0;\n  return start;\n\n  function start(code) {\n    effects.enter('atxHeading');\n    effects.enter('atxHeadingSequence');\n    return fenceOpenInside(code);\n  }\n\n  function fenceOpenInside(code) {\n    if (code === 35 && size++ < 6) {\n      effects.consume(code);\n      return fenceOpenInside;\n    }\n\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      effects.exit('atxHeadingSequence');\n      return self.interrupt ? ok(code) : headingBreak(code);\n    }\n\n    return nok(code);\n  }\n\n  function headingBreak(code) {\n    if (code === 35) {\n      effects.enter('atxHeadingSequence');\n      return sequence(code);\n    }\n\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('atxHeading');\n      return ok(code);\n    }\n\n    if (markdownSpace(code)) {\n      return factorySpace(effects, headingBreak, 'whitespace')(code);\n    }\n\n    effects.enter('atxHeadingText');\n    return data(code);\n  }\n\n  function sequence(code) {\n    if (code === 35) {\n      effects.consume(code);\n      return sequence;\n    }\n\n    effects.exit('atxHeadingSequence');\n    return headingBreak(code);\n  }\n\n  function data(code) {\n    if (code === null || code === 35 || markdownLineEndingOrSpace(code)) {\n      effects.exit('atxHeadingText');\n      return headingBreak(code);\n    }\n\n    effects.consume(code);\n    return data;\n  }\n}\n\nmodule.exports = headingAtx;","'use strict';\n\nvar asciiAlpha = require('../character/ascii-alpha.js');\n\nvar asciiAlphanumeric = require('../character/ascii-alphanumeric.js');\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js');\n\nvar markdownSpace = require('../character/markdown-space.js');\n\nvar fromCharCode = require('../constant/from-char-code.js');\n\nvar htmlBlockNames = require('../constant/html-block-names.js');\n\nvar htmlRawNames = require('../constant/html-raw-names.js');\n\nvar partialBlankLine = require('./partial-blank-line.js');\n\nvar htmlFlow = {\n  name: 'htmlFlow',\n  tokenize: tokenizeHtmlFlow,\n  resolveTo: resolveToHtmlFlow,\n  concrete: true\n};\nvar nextBlankConstruct = {\n  tokenize: tokenizeNextBlank,\n  partial: true\n};\n\nfunction resolveToHtmlFlow(events) {\n  var index = events.length;\n\n  while (index--) {\n    if (events[index][0] === 'enter' && events[index][1].type === 'htmlFlow') {\n      break;\n    }\n  }\n\n  if (index > 1 && events[index - 2][1].type === 'linePrefix') {\n    // Add the prefix start to the HTML token.\n    events[index][1].start = events[index - 2][1].start; // Add the prefix start to the HTML line token.\n\n    events[index + 1][1].start = events[index - 2][1].start; // Remove the line prefix.\n\n    events.splice(index - 2, 2);\n  }\n\n  return events;\n}\n\nfunction tokenizeHtmlFlow(effects, ok, nok) {\n  var self = this;\n  var kind;\n  var startTag;\n  var buffer;\n  var index;\n  var marker;\n  return start;\n\n  function start(code) {\n    effects.enter('htmlFlow');\n    effects.enter('htmlFlowData');\n    effects.consume(code);\n    return open;\n  }\n\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code);\n      return declarationStart;\n    }\n\n    if (code === 47) {\n      effects.consume(code);\n      return tagCloseStart;\n    }\n\n    if (code === 63) {\n      effects.consume(code);\n      kind = 3; // While we’re in an instruction instead of a declaration, we’re on a `?`\n      // right now, so we do need to search for `>`, similar to declarations.\n\n      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      buffer = fromCharCode(code);\n      startTag = true;\n      return tagName;\n    }\n\n    return nok(code);\n  }\n\n  function declarationStart(code) {\n    if (code === 45) {\n      effects.consume(code);\n      kind = 2;\n      return commentOpenInside;\n    }\n\n    if (code === 91) {\n      effects.consume(code);\n      kind = 5;\n      buffer = 'CDATA[';\n      index = 0;\n      return cdataOpenInside;\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      kind = 4;\n      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n\n    return nok(code);\n  }\n\n  function commentOpenInside(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n\n    return nok(code);\n  }\n\n  function cdataOpenInside(code) {\n    if (code === buffer.charCodeAt(index++)) {\n      effects.consume(code);\n      return index === buffer.length ? self.interrupt ? ok : continuation : cdataOpenInside;\n    }\n\n    return nok(code);\n  }\n\n  function tagCloseStart(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      buffer = fromCharCode(code);\n      return tagName;\n    }\n\n    return nok(code);\n  }\n\n  function tagName(code) {\n    if (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\n      if (htmlBlockNames.indexOf(buffer.toLowerCase()) > -1) {\n        kind = 6;\n\n        if (code === 47) {\n          effects.consume(code);\n          return basicSelfClosing;\n        }\n\n        return self.interrupt ? ok(code) : continuation(code);\n      }\n\n      kind = 7; // Do not support complete HTML when interrupting.\n\n      return self.interrupt ? nok(code) : startTag ? completeAttributeNameBefore(code) : completeClosingTagAfter(code);\n    }\n\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      buffer += fromCharCode(code);\n      return tagName;\n    }\n\n    return nok(code);\n  }\n\n  function basicSelfClosing(code) {\n    if (code === 62) {\n      effects.consume(code);\n      return self.interrupt ? ok : continuation;\n    }\n\n    return nok(code);\n  }\n\n  function completeClosingTagAfter(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeClosingTagAfter;\n    }\n\n    return completeEnd(code);\n  }\n\n  function completeAttributeNameBefore(code) {\n    if (code === 47) {\n      effects.consume(code);\n      return completeEnd;\n    }\n\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code);\n      return completeAttributeName;\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeNameBefore;\n    }\n\n    return completeEnd(code);\n  }\n\n  function completeAttributeName(code) {\n    if (code === 45 || code === 46 || code === 58 || code === 95 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return completeAttributeName;\n    }\n\n    return completeAttributeNameAfter(code);\n  }\n\n  function completeAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code);\n      return completeAttributeValueBefore;\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeNameAfter;\n    }\n\n    return completeAttributeNameBefore(code);\n  }\n\n  function completeAttributeValueBefore(code) {\n    if (code === null || code === 60 || code === 61 || code === 62 || code === 96) {\n      return nok(code);\n    }\n\n    if (code === 34 || code === 39) {\n      effects.consume(code);\n      marker = code;\n      return completeAttributeValueQuoted;\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeValueBefore;\n    }\n\n    marker = undefined;\n    return completeAttributeValueUnquoted(code);\n  }\n\n  function completeAttributeValueQuoted(code) {\n    if (code === marker) {\n      effects.consume(code);\n      return completeAttributeValueQuotedAfter;\n    }\n\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code);\n    }\n\n    effects.consume(code);\n    return completeAttributeValueQuoted;\n  }\n\n  function completeAttributeValueUnquoted(code) {\n    if (code === null || code === 34 || code === 39 || code === 60 || code === 61 || code === 62 || code === 96 || markdownLineEndingOrSpace(code)) {\n      return completeAttributeNameAfter(code);\n    }\n\n    effects.consume(code);\n    return completeAttributeValueUnquoted;\n  }\n\n  function completeAttributeValueQuotedAfter(code) {\n    if (code === 47 || code === 62 || markdownSpace(code)) {\n      return completeAttributeNameBefore(code);\n    }\n\n    return nok(code);\n  }\n\n  function completeEnd(code) {\n    if (code === 62) {\n      effects.consume(code);\n      return completeAfter;\n    }\n\n    return nok(code);\n  }\n\n  function completeAfter(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAfter;\n    }\n\n    return code === null || markdownLineEnding(code) ? continuation(code) : nok(code);\n  }\n\n  function continuation(code) {\n    if (code === 45 && kind === 2) {\n      effects.consume(code);\n      return continuationCommentInside;\n    }\n\n    if (code === 60 && kind === 1) {\n      effects.consume(code);\n      return continuationRawTagOpen;\n    }\n\n    if (code === 62 && kind === 4) {\n      effects.consume(code);\n      return continuationClose;\n    }\n\n    if (code === 63 && kind === 3) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n\n    if (code === 93 && kind === 5) {\n      effects.consume(code);\n      return continuationCharacterDataInside;\n    }\n\n    if (markdownLineEnding(code) && (kind === 6 || kind === 7)) {\n      return effects.check(nextBlankConstruct, continuationClose, continuationAtLineEnding)(code);\n    }\n\n    if (code === null || markdownLineEnding(code)) {\n      return continuationAtLineEnding(code);\n    }\n\n    effects.consume(code);\n    return continuation;\n  }\n\n  function continuationAtLineEnding(code) {\n    effects.exit('htmlFlowData');\n    return htmlContinueStart(code);\n  }\n\n  function htmlContinueStart(code) {\n    if (code === null) {\n      return done(code);\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding');\n      effects.consume(code);\n      effects.exit('lineEnding');\n      return htmlContinueStart;\n    }\n\n    effects.enter('htmlFlowData');\n    return continuation(code);\n  }\n\n  function continuationCommentInside(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n\n    return continuation(code);\n  }\n\n  function continuationRawTagOpen(code) {\n    if (code === 47) {\n      effects.consume(code);\n      buffer = '';\n      return continuationRawEndTag;\n    }\n\n    return continuation(code);\n  }\n\n  function continuationRawEndTag(code) {\n    if (code === 62 && htmlRawNames.indexOf(buffer.toLowerCase()) > -1) {\n      effects.consume(code);\n      return continuationClose;\n    }\n\n    if (asciiAlpha(code) && buffer.length < 8) {\n      effects.consume(code);\n      buffer += fromCharCode(code);\n      return continuationRawEndTag;\n    }\n\n    return continuation(code);\n  }\n\n  function continuationCharacterDataInside(code) {\n    if (code === 93) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n\n    return continuation(code);\n  }\n\n  function continuationDeclarationInside(code) {\n    if (code === 62) {\n      effects.consume(code);\n      return continuationClose;\n    }\n\n    return continuation(code);\n  }\n\n  function continuationClose(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('htmlFlowData');\n      return done(code);\n    }\n\n    effects.consume(code);\n    return continuationClose;\n  }\n\n  function done(code) {\n    effects.exit('htmlFlow');\n    return ok(code);\n  }\n}\n\nfunction tokenizeNextBlank(effects, ok, nok) {\n  return start;\n\n  function start(code) {\n    effects.exit('htmlFlowData');\n    effects.enter('lineEndingBlank');\n    effects.consume(code);\n    effects.exit('lineEndingBlank');\n    return effects.attempt(partialBlankLine, ok, nok);\n  }\n}\n\nmodule.exports = htmlFlow;","'use strict';\n\nvar asciiAlpha = require('../character/ascii-alpha.js');\n\nvar asciiAlphanumeric = require('../character/ascii-alphanumeric.js');\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js');\n\nvar markdownSpace = require('../character/markdown-space.js');\n\nvar factorySpace = require('./factory-space.js');\n\nvar htmlText = {\n  name: 'htmlText',\n  tokenize: tokenizeHtmlText\n};\n\nfunction tokenizeHtmlText(effects, ok, nok) {\n  var self = this;\n  var marker;\n  var buffer;\n  var index;\n  var returnState;\n  return start;\n\n  function start(code) {\n    effects.enter('htmlText');\n    effects.enter('htmlTextData');\n    effects.consume(code);\n    return open;\n  }\n\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code);\n      return declarationOpen;\n    }\n\n    if (code === 47) {\n      effects.consume(code);\n      return tagCloseStart;\n    }\n\n    if (code === 63) {\n      effects.consume(code);\n      return instruction;\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return tagOpen;\n    }\n\n    return nok(code);\n  }\n\n  function declarationOpen(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return commentOpen;\n    }\n\n    if (code === 91) {\n      effects.consume(code);\n      buffer = 'CDATA[';\n      index = 0;\n      return cdataOpen;\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return declaration;\n    }\n\n    return nok(code);\n  }\n\n  function commentOpen(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return commentStart;\n    }\n\n    return nok(code);\n  }\n\n  function commentStart(code) {\n    if (code === null || code === 62) {\n      return nok(code);\n    }\n\n    if (code === 45) {\n      effects.consume(code);\n      return commentStartDash;\n    }\n\n    return comment(code);\n  }\n\n  function commentStartDash(code) {\n    if (code === null || code === 62) {\n      return nok(code);\n    }\n\n    return comment(code);\n  }\n\n  function comment(code) {\n    if (code === null) {\n      return nok(code);\n    }\n\n    if (code === 45) {\n      effects.consume(code);\n      return commentClose;\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = comment;\n      return atLineEnding(code);\n    }\n\n    effects.consume(code);\n    return comment;\n  }\n\n  function commentClose(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return end;\n    }\n\n    return comment(code);\n  }\n\n  function cdataOpen(code) {\n    if (code === buffer.charCodeAt(index++)) {\n      effects.consume(code);\n      return index === buffer.length ? cdata : cdataOpen;\n    }\n\n    return nok(code);\n  }\n\n  function cdata(code) {\n    if (code === null) {\n      return nok(code);\n    }\n\n    if (code === 93) {\n      effects.consume(code);\n      return cdataClose;\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = cdata;\n      return atLineEnding(code);\n    }\n\n    effects.consume(code);\n    return cdata;\n  }\n\n  function cdataClose(code) {\n    if (code === 93) {\n      effects.consume(code);\n      return cdataEnd;\n    }\n\n    return cdata(code);\n  }\n\n  function cdataEnd(code) {\n    if (code === 62) {\n      return end(code);\n    }\n\n    if (code === 93) {\n      effects.consume(code);\n      return cdataEnd;\n    }\n\n    return cdata(code);\n  }\n\n  function declaration(code) {\n    if (code === null || code === 62) {\n      return end(code);\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = declaration;\n      return atLineEnding(code);\n    }\n\n    effects.consume(code);\n    return declaration;\n  }\n\n  function instruction(code) {\n    if (code === null) {\n      return nok(code);\n    }\n\n    if (code === 63) {\n      effects.consume(code);\n      return instructionClose;\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = instruction;\n      return atLineEnding(code);\n    }\n\n    effects.consume(code);\n    return instruction;\n  }\n\n  function instructionClose(code) {\n    return code === 62 ? end(code) : instruction(code);\n  }\n\n  function tagCloseStart(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return tagClose;\n    }\n\n    return nok(code);\n  }\n\n  function tagClose(code) {\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagClose;\n    }\n\n    return tagCloseBetween(code);\n  }\n\n  function tagCloseBetween(code) {\n    if (markdownLineEnding(code)) {\n      returnState = tagCloseBetween;\n      return atLineEnding(code);\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagCloseBetween;\n    }\n\n    return end(code);\n  }\n\n  function tagOpen(code) {\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagOpen;\n    }\n\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n\n    return nok(code);\n  }\n\n  function tagOpenBetween(code) {\n    if (code === 47) {\n      effects.consume(code);\n      return end;\n    }\n\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code);\n      return tagOpenAttributeName;\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenBetween;\n      return atLineEnding(code);\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenBetween;\n    }\n\n    return end(code);\n  }\n\n  function tagOpenAttributeName(code) {\n    if (code === 45 || code === 46 || code === 58 || code === 95 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagOpenAttributeName;\n    }\n\n    return tagOpenAttributeNameAfter(code);\n  }\n\n  function tagOpenAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code);\n      return tagOpenAttributeValueBefore;\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeNameAfter;\n      return atLineEnding(code);\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenAttributeNameAfter;\n    }\n\n    return tagOpenBetween(code);\n  }\n\n  function tagOpenAttributeValueBefore(code) {\n    if (code === null || code === 60 || code === 61 || code === 62 || code === 96) {\n      return nok(code);\n    }\n\n    if (code === 34 || code === 39) {\n      effects.consume(code);\n      marker = code;\n      return tagOpenAttributeValueQuoted;\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueBefore;\n      return atLineEnding(code);\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenAttributeValueBefore;\n    }\n\n    effects.consume(code);\n    marker = undefined;\n    return tagOpenAttributeValueUnquoted;\n  }\n\n  function tagOpenAttributeValueQuoted(code) {\n    if (code === marker) {\n      effects.consume(code);\n      return tagOpenAttributeValueQuotedAfter;\n    }\n\n    if (code === null) {\n      return nok(code);\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueQuoted;\n      return atLineEnding(code);\n    }\n\n    effects.consume(code);\n    return tagOpenAttributeValueQuoted;\n  }\n\n  function tagOpenAttributeValueQuotedAfter(code) {\n    if (code === 62 || code === 47 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n\n    return nok(code);\n  }\n\n  function tagOpenAttributeValueUnquoted(code) {\n    if (code === null || code === 34 || code === 39 || code === 60 || code === 61 || code === 96) {\n      return nok(code);\n    }\n\n    if (code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n\n    effects.consume(code);\n    return tagOpenAttributeValueUnquoted;\n  } // We can’t have blank lines in content, so no need to worry about empty\n  // tokens.\n\n\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\n  function afterPrefix(code) {\n    effects.enter('htmlTextData');\n    return returnState(code);\n  }\n\n  function end(code) {\n    if (code === 62) {\n      effects.consume(code);\n      effects.exit('htmlTextData');\n      effects.exit('htmlText');\n      return ok;\n    }\n\n    return nok(code);\n  }\n}\n\nmodule.exports = htmlText;","'use strict';\n\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js');\n\nvar chunkedPush = require('../util/chunked-push.js');\n\nvar chunkedSplice = require('../util/chunked-splice.js');\n\nvar normalizeIdentifier = require('../util/normalize-identifier.js');\n\nvar resolveAll = require('../util/resolve-all.js');\n\nvar shallow = require('../util/shallow.js');\n\nvar factoryDestination = require('./factory-destination.js');\n\nvar factoryLabel = require('./factory-label.js');\n\nvar factoryTitle = require('./factory-title.js');\n\nvar factoryWhitespace = require('./factory-whitespace.js');\n\nvar labelEnd = {\n  name: 'labelEnd',\n  tokenize: tokenizeLabelEnd,\n  resolveTo: resolveToLabelEnd,\n  resolveAll: resolveAllLabelEnd\n};\nvar resourceConstruct = {\n  tokenize: tokenizeResource\n};\nvar fullReferenceConstruct = {\n  tokenize: tokenizeFullReference\n};\nvar collapsedReferenceConstruct = {\n  tokenize: tokenizeCollapsedReference\n};\n\nfunction resolveAllLabelEnd(events) {\n  var index = -1;\n  var token;\n\n  while (++index < events.length) {\n    token = events[index][1];\n\n    if (!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\n  return events;\n}\n\nfunction resolveToLabelEnd(events, context) {\n  var index = events.length;\n  var offset = 0;\n  var group;\n  var label;\n  var text;\n  var token;\n  var open;\n  var close;\n  var media; // Find an opening.\n\n  while (index--) {\n    token = events[index][1];\n\n    if (open) {\n      // If we see another link, or inactive link label, we’ve been here before.\n      if (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\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\n        if (token.type !== 'labelLink') {\n          offset = 2;\n          break;\n        }\n      }\n    } else if (token.type === 'labelEnd') {\n      close = index;\n    }\n  }\n\n  group = {\n    type: events[open][1].type === 'labelLink' ? 'link' : 'image',\n    start: shallow(events[open][1].start),\n    end: shallow(events[events.length - 1][1].end)\n  };\n  label = {\n    type: 'label',\n    start: shallow(events[open][1].start),\n    end: shallow(events[close][1].end)\n  };\n  text = {\n    type: 'labelText',\n    start: shallow(events[open + offset + 2][1].end),\n    end: shallow(events[close - 2][1].start)\n  };\n  media = [['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}\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\n  return start;\n\n  function start(code) {\n    if (!labelStart) {\n      return nok(code);\n    } // It’s a balanced bracket, but contains a link.\n\n\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\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\n    if (code === 91) {\n      return effects.attempt(fullReferenceConstruct, ok, defined ? effects.attempt(collapsedReferenceConstruct, ok, balanced) : balanced)(code);\n    } // Shortcut reference: `[asd]`?\n\n\n    return defined ? ok(code) : balanced(code);\n  }\n\n  function balanced(code) {\n    labelStart._balanced = true;\n    return nok(code);\n  }\n}\n\nfunction tokenizeResource(effects, ok, nok) {\n  return start;\n\n  function start(code) {\n    effects.enter('resource');\n    effects.enter('resourceMarker');\n    effects.consume(code);\n    effects.exit('resourceMarker');\n    return factoryWhitespace(effects, open);\n  }\n\n  function open(code) {\n    if (code === 41) {\n      return end(code);\n    }\n\n    return factoryDestination(effects, destinationAfter, nok, 'resourceDestination', 'resourceDestinationLiteral', 'resourceDestinationLiteralMarker', 'resourceDestinationRaw', 'resourceDestinationString', 3)(code);\n  }\n\n  function destinationAfter(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, between)(code) : end(code);\n  }\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\n    return end(code);\n  }\n\n  function end(code) {\n    if (code === 41) {\n      effects.enter('resourceMarker');\n      effects.consume(code);\n      effects.exit('resourceMarker');\n      effects.exit('resource');\n      return ok;\n    }\n\n    return nok(code);\n  }\n}\n\nfunction tokenizeFullReference(effects, ok, nok) {\n  var self = this;\n  return start;\n\n  function start(code) {\n    return factoryLabel.call(self, effects, afterLabel, nok, 'reference', 'referenceMarker', 'referenceString')(code);\n  }\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}\n\nfunction tokenizeCollapsedReference(effects, ok, nok) {\n  return start;\n\n  function start(code) {\n    effects.enter('reference');\n    effects.enter('referenceMarker');\n    effects.consume(code);\n    effects.exit('referenceMarker');\n    return open;\n  }\n\n  function open(code) {\n    if (code === 93) {\n      effects.enter('referenceMarker');\n      effects.consume(code);\n      effects.exit('referenceMarker');\n      effects.exit('reference');\n      return ok;\n    }\n\n    return nok(code);\n  }\n}\n\nmodule.exports = labelEnd;","'use strict';\n\nvar labelEnd = require('./label-end.js');\n\nvar labelStartImage = {\n  name: 'labelStartImage',\n  tokenize: tokenizeLabelStartImage,\n  resolveAll: labelEnd.resolveAll\n};\n\nfunction tokenizeLabelStartImage(effects, ok, nok) {\n  var self = this;\n  return start;\n\n  function start(code) {\n    effects.enter('labelImage');\n    effects.enter('labelImageMarker');\n    effects.consume(code);\n    effects.exit('labelImageMarker');\n    return open;\n  }\n\n  function open(code) {\n    if (code === 91) {\n      effects.enter('labelMarker');\n      effects.consume(code);\n      effects.exit('labelMarker');\n      effects.exit('labelImage');\n      return after;\n    }\n\n    return nok(code);\n  }\n\n  function after(code) {\n    /* c8 ignore next */\n    return code === 94 &&\n    /* c8 ignore next */\n    '_hiddenFootnoteSupport' in self.parser.constructs ?\n    /* c8 ignore next */\n    nok(code) : ok(code);\n  }\n}\n\nmodule.exports = labelStartImage;","'use strict';\n\nvar labelEnd = require('./label-end.js');\n\nvar labelStartLink = {\n  name: 'labelStartLink',\n  tokenize: tokenizeLabelStartLink,\n  resolveAll: labelEnd.resolveAll\n};\n\nfunction tokenizeLabelStartLink(effects, ok, nok) {\n  var self = this;\n  return start;\n\n  function start(code) {\n    effects.enter('labelLink');\n    effects.enter('labelMarker');\n    effects.consume(code);\n    effects.exit('labelMarker');\n    effects.exit('labelLink');\n    return after;\n  }\n\n  function after(code) {\n    /* c8 ignore next */\n    return code === 94 &&\n    /* c8 ignore next */\n    '_hiddenFootnoteSupport' in self.parser.constructs ?\n    /* c8 ignore next */\n    nok(code) : ok(code);\n  }\n}\n\nmodule.exports = labelStartLink;","'use strict';\n\nvar factorySpace = require('./factory-space.js');\n\nvar lineEnding = {\n  name: 'lineEnding',\n  tokenize: tokenizeLineEnding\n};\n\nfunction tokenizeLineEnding(effects, ok) {\n  return start;\n\n  function start(code) {\n    effects.enter('lineEnding');\n    effects.consume(code);\n    effects.exit('lineEnding');\n    return factorySpace(effects, ok, 'linePrefix');\n  }\n}\n\nmodule.exports = lineEnding;","'use strict';\n\nvar asciiDigit = require('../character/ascii-digit.js');\n\nvar markdownSpace = require('../character/markdown-space.js');\n\nvar prefixSize = require('../util/prefix-size.js');\n\nvar sizeChunks = require('../util/size-chunks.js');\n\nvar factorySpace = require('./factory-space.js');\n\nvar partialBlankLine = require('./partial-blank-line.js');\n\nvar thematicBreak = require('./thematic-break.js');\n\nvar list = {\n  name: 'list',\n  tokenize: tokenizeListStart,\n  continuation: {\n    tokenize: tokenizeListContinuation\n  },\n  exit: tokenizeListEnd\n};\nvar listItemPrefixWhitespaceConstruct = {\n  tokenize: tokenizeListItemPrefixWhitespace,\n  partial: true\n};\nvar indentConstruct = {\n  tokenize: tokenizeIndent,\n  partial: true\n};\n\nfunction tokenizeListStart(effects, ok, nok) {\n  var self = this;\n  var initialSize = prefixSize(self.events, 'linePrefix');\n  var size = 0;\n  return start;\n\n  function start(code) {\n    var kind = self.containerState.type || (code === 42 || code === 43 || code === 45 ? 'listUnordered' : 'listOrdered');\n\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\n      if (kind === 'listUnordered') {\n        effects.enter('listItemPrefix');\n        return code === 42 || code === 45 ? effects.check(thematicBreak, nok, atMarker)(code) : atMarker(code);\n      }\n\n      if (!self.interrupt || code === 49) {\n        effects.enter('listItemPrefix');\n        effects.enter('listItemValue');\n        return inside(code);\n      }\n    }\n\n    return nok(code);\n  }\n\n  function inside(code) {\n    if (asciiDigit(code) && ++size < 10) {\n      effects.consume(code);\n      return inside;\n    }\n\n    if ((!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\n    return nok(code);\n  }\n\n  function atMarker(code) {\n    effects.enter('listItemMarker');\n    effects.consume(code);\n    effects.exit('listItemMarker');\n    self.containerState.marker = self.containerState.marker || code;\n    return effects.check(partialBlankLine, // Can’t be empty when interrupting.\n    self.interrupt ? nok : onBlank, effects.attempt(listItemPrefixWhitespaceConstruct, endOfPrefix, otherPrefix));\n  }\n\n  function onBlank(code) {\n    self.containerState.initialBlankLine = true;\n    initialSize++;\n    return endOfPrefix(code);\n  }\n\n  function otherPrefix(code) {\n    if (markdownSpace(code)) {\n      effects.enter('listItemPrefixWhitespace');\n      effects.consume(code);\n      effects.exit('listItemPrefixWhitespace');\n      return endOfPrefix;\n    }\n\n    return nok(code);\n  }\n\n  function endOfPrefix(code) {\n    self.containerState.size = initialSize + sizeChunks(self.sliceStream(effects.exit('listItemPrefix')));\n    return ok(code);\n  }\n}\n\nfunction tokenizeListContinuation(effects, ok, nok) {\n  var self = this;\n  self.containerState._closeFlow = undefined;\n  return effects.check(partialBlankLine, onBlank, notBlank);\n\n  function onBlank(code) {\n    self.containerState.furtherBlankLines = 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\n  function notBlank(code) {\n    if (self.containerState.furtherBlankLines || !markdownSpace(code)) {\n      self.containerState.furtherBlankLines = self.containerState.initialBlankLine = undefined;\n      return notInCurrentItem(code);\n    }\n\n    self.containerState.furtherBlankLines = self.containerState.initialBlankLine = undefined;\n    return effects.attempt(indentConstruct, ok, notInCurrentItem)(code);\n  }\n\n  function notInCurrentItem(code) {\n    // While we do continue, we signal that the flow should be closed.\n    self.containerState._closeFlow = true; // As we’re closing flow, we’re no longer interrupting.\n\n    self.interrupt = undefined;\n    return factorySpace(effects, effects.attempt(list, ok, nok), 'linePrefix', self.parser.constructs.disable.null.indexOf('codeIndented') > -1 ? undefined : 4)(code);\n  }\n}\n\nfunction tokenizeIndent(effects, ok, nok) {\n  var self = this;\n  return factorySpace(effects, afterPrefix, 'listItemIndent', self.containerState.size + 1);\n\n  function afterPrefix(code) {\n    return prefixSize(self.events, 'listItemIndent') === self.containerState.size ? ok(code) : nok(code);\n  }\n}\n\nfunction tokenizeListEnd(effects) {\n  effects.exit(this.containerState.type);\n}\n\nfunction tokenizeListItemPrefixWhitespace(effects, ok, nok) {\n  var self = this;\n  return factorySpace(effects, afterPrefix, 'listItemPrefixWhitespace', self.parser.constructs.disable.null.indexOf('codeIndented') > -1 ? undefined : 4 + 1);\n\n  function afterPrefix(code) {\n    return markdownSpace(code) || !prefixSize(self.events, 'listItemPrefixWhitespace') ? nok(code) : ok(code);\n  }\n}\n\nmodule.exports = list;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar factorySpace = require('./factory-space.js');\n\nvar partialBlankLine = {\n  tokenize: tokenizePartialBlankLine,\n  partial: true\n};\n\nfunction tokenizePartialBlankLine(effects, ok, nok) {\n  return factorySpace(effects, afterWhitespace, 'linePrefix');\n\n  function afterWhitespace(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code);\n  }\n}\n\nmodule.exports = partialBlankLine;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar shallow = require('../util/shallow.js');\n\nvar factorySpace = require('./factory-space.js');\n\nvar setextUnderline = {\n  name: 'setextUnderline',\n  tokenize: tokenizeSetextUnderline,\n  resolveTo: resolveToSetextUnderline\n};\n\nfunction resolveToSetextUnderline(events, context) {\n  var index = events.length;\n  var content;\n  var text;\n  var definition;\n  var heading; // Find the opening of the content.\n  // It’ll always exist: we don’t tokenize if it isn’t there.\n\n  while (index--) {\n    if (events[index][0] === 'enter') {\n      if (events[index][1].type === 'content') {\n        content = index;\n        break;\n      }\n\n      if (events[index][1].type === 'paragraph') {\n        text = index;\n      }\n    } // Exit\n    else {\n      if (events[index][1].type === 'content') {\n        // Remove the content end (if needed we’ll add it later)\n        events.splice(index, 1);\n      }\n\n      if (!definition && events[index][1].type === 'definition') {\n        definition = index;\n      }\n    }\n  }\n\n  heading = {\n    type: 'setextHeading',\n    start: shallow(events[text][1].start),\n    end: shallow(events[events.length - 1][1].end)\n  }; // Change the paragraph to setext heading text.\n\n  events[text][1].type = 'setextHeadingText'; // If we have definitions in the content, we’ll keep on having content,\n  // but we need move it.\n\n  if (definition) {\n    events.splice(text, 0, ['enter', heading, context]);\n    events.splice(definition + 1, 0, ['exit', events[content][1], context]);\n    events[content][1].end = shallow(events[definition][1].end);\n  } else {\n    events[content][1] = heading;\n  } // Add the heading exit at the end.\n\n\n  events.push(['exit', heading, context]);\n  return events;\n}\n\nfunction tokenizeSetextUnderline(effects, ok, nok) {\n  var self = this;\n  var index = self.events.length;\n  var marker;\n  var paragraph; // Find an opening.\n\n  while (index--) {\n    // Skip enter/exit of line ending, line prefix, and content.\n    // We can now either have a definition or a paragraph.\n    if (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\n  return start;\n\n  function start(code) {\n    if (!self.lazy && (self.interrupt || paragraph)) {\n      effects.enter('setextHeadingLine');\n      effects.enter('setextHeadingLineSequence');\n      marker = code;\n      return closingSequence(code);\n    }\n\n    return nok(code);\n  }\n\n  function closingSequence(code) {\n    if (code === marker) {\n      effects.consume(code);\n      return closingSequence;\n    }\n\n    effects.exit('setextHeadingLineSequence');\n    return factorySpace(effects, closingSequenceEnd, 'lineSuffix')(code);\n  }\n\n  function closingSequenceEnd(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('setextHeadingLine');\n      return ok(code);\n    }\n\n    return nok(code);\n  }\n}\n\nmodule.exports = setextUnderline;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar markdownSpace = require('../character/markdown-space.js');\n\nvar factorySpace = require('./factory-space.js');\n\nvar thematicBreak = {\n  name: 'thematicBreak',\n  tokenize: tokenizeThematicBreak\n};\n\nfunction tokenizeThematicBreak(effects, ok, nok) {\n  var size = 0;\n  var marker;\n  return start;\n\n  function start(code) {\n    effects.enter('thematicBreak');\n    marker = code;\n    return atBreak(code);\n  }\n\n  function atBreak(code) {\n    if (code === marker) {\n      effects.enter('thematicBreakSequence');\n      return sequence(code);\n    }\n\n    if (markdownSpace(code)) {\n      return factorySpace(effects, atBreak, 'whitespace')(code);\n    }\n\n    if (size < 3 || code !== null && !markdownLineEnding(code)) {\n      return nok(code);\n    }\n\n    effects.exit('thematicBreak');\n    return ok(code);\n  }\n\n  function sequence(code) {\n    if (code === marker) {\n      effects.consume(code);\n      size++;\n      return sequence;\n    }\n\n    effects.exit('thematicBreakSequence');\n    return atBreak(code);\n  }\n}\n\nmodule.exports = thematicBreak;","'use strict';\n\nvar chunkedSplice = require('./chunked-splice.js');\n\nfunction chunkedPush(list, items) {\n  if (list.length) {\n    chunkedSplice(list, list.length, 0, items);\n    return list;\n  }\n\n  return items;\n}\n\nmodule.exports = chunkedPush;","'use strict';\n\nvar splice = require('../constant/splice.js'); // causes a stack overflow in V8 when trying to insert 100k items for instance.\n\n\nfunction chunkedSplice(list, start, remove, items) {\n  var end = list.length;\n  var chunkStart = 0;\n  var parameters; // Make start between zero and `end` (included).\n\n  if (start < 0) {\n    start = -start > end ? 0 : end + start;\n  } else {\n    start = start > end ? end : start;\n  }\n\n  remove = remove > 0 ? remove : 0; // No need to chunk the items if there’s only a couple (10k) items.\n\n  if (items.length < 10000) {\n    parameters = Array.from(items);\n    parameters.unshift(start, remove);\n    splice.apply(list, parameters);\n  } else {\n    // Delete `remove` items starting from `start`\n    if (remove) splice.apply(list, [start, remove]); // Insert the items in chunks to not cause stack overflows.\n\n    while (chunkStart < items.length) {\n      parameters = items.slice(chunkStart, chunkStart + 10000);\n      parameters.unshift(start, 0);\n      splice.apply(list, parameters);\n      chunkStart += 10000;\n      start += 10000;\n    }\n  }\n}\n\nmodule.exports = chunkedSplice;","'use strict';\n\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js');\n\nvar unicodePunctuation = require('../character/unicode-punctuation.js');\n\nvar unicodeWhitespace = require('../character/unicode-whitespace.js'); // 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.\n\n\nfunction classifyCharacter(code) {\n  if (code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) {\n    return 1;\n  }\n\n  if (unicodePunctuation(code)) {\n    return 2;\n  }\n}\n\nmodule.exports = classifyCharacter;","'use strict';\n\nvar hasOwnProperty = require('../constant/has-own-property.js');\n\nvar chunkedSplice = require('./chunked-splice.js');\n\nvar miniflat = require('./miniflat.js');\n\nfunction combineExtensions(extensions) {\n  var all = {};\n  var index = -1;\n\n  while (++index < extensions.length) {\n    extension(all, extensions[index]);\n  }\n\n  return all;\n}\n\nfunction extension(all, extension) {\n  var hook;\n  var left;\n  var right;\n  var code;\n\n  for (hook in extension) {\n    left = hasOwnProperty.call(all, hook) ? all[hook] : all[hook] = {};\n    right = extension[hook];\n\n    for (code in right) {\n      left[code] = constructs(miniflat(right[code]), hasOwnProperty.call(left, code) ? left[code] : []);\n    }\n  }\n}\n\nfunction constructs(list, existing) {\n  var index = -1;\n  var before = [];\n\n  while (++index < list.length) {\n    ;\n    (list[index].add === 'after' ? existing : before).push(list[index]);\n  }\n\n  chunkedSplice(existing, 0, 0, before);\n  return existing;\n}\n\nmodule.exports = combineExtensions;","'use strict';\n\nvar assign = require('../constant/assign.js');\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar chunkedPush = require('./chunked-push.js');\n\nvar chunkedSplice = require('./chunked-splice.js');\n\nvar miniflat = require('./miniflat.js');\n\nvar resolveAll = require('./resolve-all.js');\n\nvar serializeChunks = require('./serialize-chunks.js');\n\nvar shallow = require('./shallow.js');\n\nvar sliceChunks = require('./slice-chunks.js'); // 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`.\n\n\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\n  point._index = 0;\n  point._bufferIndex = -1;\n  return context;\n\n  function write(slice) {\n    chunks = chunkedPush(chunks, slice);\n    main(); // Exit if we’re not done, resolve might change stuff.\n\n    if (chunks[chunks.length - 1] !== null) {\n      return [];\n    }\n\n    addResult(initialize, 0); // Otherwise, resolve, and exit.\n\n    context.events = resolveAll(resolveAllConstructs, context.events, context);\n    return context.events;\n  } //\n  // Tools.\n  //\n\n\n  function sliceSerialize(token) {\n    return serializeChunks(sliceStream(token));\n  }\n\n  function sliceStream(token) {\n    return sliceChunks(chunks, token);\n  }\n\n  function now() {\n    return shallow(point);\n  }\n\n  function skip(value) {\n    columnStart[value.line] = value.column;\n    accountForPotentialSkip();\n  } //\n  // State management.\n  //\n  // Main loop (note that `_index` and `_bufferIndex` in `point` are modified by\n  // `consume`).\n  // Here is where we walk through the chunks, which either include strings of\n  // several characters, or numerical character codes.\n  // The reason to do this in a loop instead of a call is so the stack can\n  // drain.\n\n\n  function main() {\n    var chunkIndex;\n    var chunk;\n\n    while (point._index < chunks.length) {\n      chunk = chunks[point._index]; // If we’re in a buffer chunk, loop through it.\n\n      if (typeof chunk === 'string') {\n        chunkIndex = point._index;\n\n        if (point._bufferIndex < 0) {\n          point._bufferIndex = 0;\n        }\n\n        while (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\n  function go(code) {\n    state = state(code);\n  } // Move a character forward.\n\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\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\n    context.previous = code; // Mark as consumed.\n  } // Start a token.\n\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\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\n  function onsuccessfulconstruct(construct, info) {\n    addResult(construct, info.from);\n  } // Discard results.\n\n\n  function onsuccessfulcheck(construct, info) {\n    info.restore();\n  } // Factory to attempt/check/interrupt.\n\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\n      function handleMapOfConstructs(code) {\n        if (code in constructs || null in constructs) {\n          return handleListOfConstructs(constructs.null ?\n          /* c8 ignore next */\n          miniflat(constructs[code]).concat(miniflat(constructs.null)) : constructs[code])(code);\n        }\n\n        return bogusState(code);\n      }\n\n      function handleListOfConstructs(list) {\n        listOfConstructs = list;\n        constructIndex = 0;\n        return handleConstruct(list[constructIndex]);\n      }\n\n      function handleConstruct(construct) {\n        return start;\n\n        function start(code) {\n          // To do: not nede to store if there is no bogus state, probably?\n          // Currently doesn’t work because `inspect` in document does a check\n          // w/o a bogus, which doesn’t make sense. But it does seem to help perf\n          // by not storing.\n          info = store();\n          currentConstruct = construct;\n\n          if (!construct.partial) {\n            context.currentConstruct = construct;\n          }\n\n          if (construct.name && context.parser.constructs.disable.null.indexOf(construct.name) > -1) {\n            return nok();\n          }\n\n          return construct.tokenize.call(fields ? assign({}, context, fields) : context, effects, ok, nok)(code);\n        }\n      }\n\n      function ok(code) {\n        onreturn(currentConstruct, info);\n        return returnState;\n      }\n\n      function nok(code) {\n        info.restore();\n\n        if (++constructIndex < listOfConstructs.length) {\n          return handleConstruct(listOfConstructs[constructIndex]);\n        }\n\n        return bogusState;\n      }\n    }\n  }\n\n  function addResult(construct, from) {\n    if (construct.resolveAll && resolveAllConstructs.indexOf(construct) < 0) {\n      resolveAllConstructs.push(construct);\n    }\n\n    if (construct.resolve) {\n      chunkedSplice(context.events, from, context.events.length - from, construct.resolve(context.events.slice(from), context));\n    }\n\n    if (construct.resolveTo) {\n      context.events = construct.resolveTo(context.events, context);\n    }\n  }\n\n  function store() {\n    var startPoint = now();\n    var startPrevious = context.previous;\n    var startCurrentConstruct = context.currentConstruct;\n    var startEventsIndex = context.events.length;\n    var startStack = Array.from(stack);\n    return {\n      restore: restore,\n      from: startEventsIndex\n    };\n\n    function restore() {\n      point = startPoint;\n      context.previous = startPrevious;\n      context.currentConstruct = startCurrentConstruct;\n      context.events.length = startEventsIndex;\n      stack = startStack;\n      accountForPotentialSkip();\n    }\n  }\n\n  function accountForPotentialSkip() {\n    if (point.line in columnStart && point.column < 2) {\n      point.column = columnStart[point.line];\n      point.offset += columnStart[point.line] - 1;\n    }\n  }\n}\n\nmodule.exports = createTokenizer;","'use strict';\n\nfunction miniflat(value) {\n  return value === null || value === undefined ? [] : 'length' in value ? value : [value];\n}\n\nmodule.exports = miniflat;","'use strict'; // chunks (replacement characters, tabs, or line endings).\n\nfunction movePoint(point, offset) {\n  point.column += offset;\n  point.offset += offset;\n  point._bufferIndex += offset;\n  return point;\n}\n\nmodule.exports = movePoint;","'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}\n\nmodule.exports = normalizeIdentifier;","'use strict';\n\nvar sizeChunks = require('./size-chunks.js');\n\nfunction prefixSize(events, type) {\n  var tail = events[events.length - 1];\n  if (!tail || tail[1].type !== type) return 0;\n  return sizeChunks(tail[2].sliceStream(tail[1]));\n}\n\nmodule.exports = prefixSize;","'use strict';\n\nvar fromCharCode = require('../constant/from-char-code.js');\n\nfunction regexCheck(regex) {\n  return check;\n\n  function check(code) {\n    return regex.test(fromCharCode(code));\n  }\n}\n\nmodule.exports = regexCheck;","'use strict';\n\nfunction resolveAll(constructs, events, context) {\n  var called = [];\n  var index = -1;\n  var resolve;\n\n  while (++index < constructs.length) {\n    resolve = constructs[index].resolveAll;\n\n    if (resolve && called.indexOf(resolve) < 0) {\n      events = resolve(events, context);\n      called.push(resolve);\n    }\n  }\n\n  return events;\n}\n\nmodule.exports = resolveAll;","'use strict';\n\nvar fromCharCode = require('../constant/from-char-code.js');\n\nfunction safeFromInt(value, base) {\n  var code = parseInt(value, base);\n\n  if ( // C0 except for HT, LF, FF, CR, space\n  code < 9 || code === 11 || code > 13 && code < 32 || code > 126 && code < 160 || code > 55295 && code < 57344 || code > 64975 && code < 65008 || (code & 65535) === 65535 || (code & 65535) === 65534 || // Out of range\n  code > 1114111) {\n    return \"\\uFFFD\";\n  }\n\n  return fromCharCode(code);\n}\n\nmodule.exports = safeFromInt;","'use strict';\n\nvar fromCharCode = require('../constant/from-char-code.js');\n\nfunction serializeChunks(chunks) {\n  var index = -1;\n  var result = [];\n  var chunk;\n  var value;\n  var atTab;\n\n  while (++index < chunks.length) {\n    chunk = chunks[index];\n\n    if (typeof chunk === 'string') {\n      value = chunk;\n    } else if (chunk === -5) {\n      value = '\\r';\n    } else if (chunk === -4) {\n      value = '\\n';\n    } else if (chunk === -3) {\n      value = '\\r' + '\\n';\n    } else if (chunk === -2) {\n      value = '\\t';\n    } else if (chunk === -1) {\n      if (atTab) continue;\n      value = ' ';\n    } else {\n      // Currently only replacement character.\n      value = fromCharCode(chunk);\n    }\n\n    atTab = chunk === -2;\n    result.push(value);\n  }\n\n  return result.join('');\n}\n\nmodule.exports = serializeChunks;","'use strict';\n\nvar assign = require('../constant/assign.js');\n\nfunction shallow(object) {\n  return assign({}, object);\n}\n\nmodule.exports = shallow;","'use strict'; // Counts tabs based on their expanded size, and CR+LF as one character.\n\nfunction sizeChunks(chunks) {\n  var index = -1;\n  var size = 0;\n\n  while (++index < chunks.length) {\n    size += typeof chunks[index] === 'string' ? chunks[index].length : 1;\n  }\n\n  return size;\n}\n\nmodule.exports = sizeChunks;","'use strict';\n\nfunction sliceChunks(chunks, token) {\n  var startIndex = token.start._index;\n  var startBufferIndex = token.start._bufferIndex;\n  var endIndex = token.end._index;\n  var endBufferIndex = token.end._bufferIndex;\n  var view;\n\n  if (startIndex === endIndex) {\n    view = [chunks[startIndex].slice(startBufferIndex, endBufferIndex)];\n  } else {\n    view = chunks.slice(startIndex, endIndex);\n\n    if (startBufferIndex > -1) {\n      view[0] = view[0].slice(startBufferIndex);\n    }\n\n    if (endBufferIndex > 0) {\n      view.push(chunks[endIndex].slice(0, endBufferIndex));\n    }\n  }\n\n  return view;\n}\n\nmodule.exports = sliceChunks;","'use strict';\n\nvar assign = require('../constant/assign.js');\n\nvar chunkedSplice = require('./chunked-splice.js');\n\nvar shallow = require('./shallow.js');\n\nfunction subtokenize(events) {\n  var jumps = {};\n  var index = -1;\n  var event;\n  var lineIndex;\n  var otherIndex;\n  var otherEvent;\n  var parameters;\n  var subevents;\n  var more;\n\n  while (++index < events.length) {\n    while (index in jumps) {\n      index = jumps[index];\n    }\n\n    event = events[index]; // Add a hook for the GFM tasklist extension, which needs to know if text\n    // is in the first content of a list item.\n\n    if (index && event[1].type === 'chunkFlow' && events[index - 1][1].type === 'listItemPrefix') {\n      subevents = event[1]._tokenizer.events;\n      otherIndex = 0;\n\n      if (otherIndex < subevents.length && subevents[otherIndex][1].type === 'lineEndingBlank') {\n        otherIndex += 2;\n      }\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\n          if (subevents[otherIndex][1].type === 'chunkText') {\n            subevents[otherIndex][1].isInFirstContentOfListItem = true;\n            otherIndex++;\n          }\n        }\n      }\n    } // Enter.\n\n\n    if (event[0] === 'enter') {\n      if (event[1].contentType) {\n        assign(jumps, subcontent(events, index));\n        index = jumps[index];\n        more = true;\n      }\n    } // Exit.\n    else if (event[1]._container || event[1]._movePreviousLineEndings) {\n      otherIndex = index;\n      lineIndex = undefined;\n\n      while (otherIndex--) {\n        otherEvent = events[otherIndex];\n\n        if (otherEvent[1].type === 'lineEnding' || otherEvent[1].type === 'lineEndingBlank') {\n          if (otherEvent[0] === 'enter') {\n            if (lineIndex) {\n              events[lineIndex][1].type = 'lineEndingBlank';\n            }\n\n            otherEvent[1].type = 'lineEnding';\n            lineIndex = otherIndex;\n          }\n        } else {\n          break;\n        }\n      }\n\n      if (lineIndex) {\n        // Fix position.\n        event[1].end = shallow(events[lineIndex][1].start); // Switch container exit w/ line endings.\n\n        parameters = events.slice(lineIndex, index);\n        parameters.unshift(event);\n        chunkedSplice(events, lineIndex, index - lineIndex + 1, parameters);\n      }\n    }\n  }\n\n  return !more;\n}\n\nfunction subcontent(events, eventIndex) {\n  var token = events[eventIndex][1];\n  var context = events[eventIndex][2];\n  var startPosition = eventIndex - 1;\n  var startPositions = [];\n  var tokenizer = 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) {// Empty.\n    }\n\n    startPositions.push(startPosition);\n\n    if (!token._tokenizer) {\n      stream = context.sliceStream(token);\n\n      if (!token.next) {\n        stream.push(null);\n      }\n\n      if (previous) {\n        tokenizer.defineSkip(token.start);\n      }\n\n      if (token.isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = true;\n      }\n\n      tokenizer.write(stream);\n\n      if (token.isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = undefined;\n      }\n    } // Unravel the next token.\n\n\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\n  token = previous;\n  index = childEvents.length;\n\n  while (index--) {\n    // Make sure we’ve at least seen something (final eol is part of the last\n    // token).\n    if (childEvents[index][0] === 'enter') {\n      entered = true;\n    } else if ( // 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)); // Help GC.\n\n      token._tokenizer = token.next = undefined;\n      token = token.previous;\n      end = index + 1;\n    }\n  } // Help GC.\n\n\n  tokenizer.events = token._tokenizer = token.next = undefined; // Do head:\n\n  add(childEvents.slice(0, end));\n  index = -1;\n  adjust = 0;\n\n  while (++index < jumps.length) {\n    gaps[adjust + jumps[index][0]] = adjust + jumps[index][1];\n    adjust += jumps[index][1] - jumps[index][0] - 1;\n  }\n\n  return gaps;\n\n  function add(slice) {\n    var start = startPositions.pop();\n    jumps.unshift([start, start + slice.length - 1]);\n    chunkedSplice(events, start, 2, slice);\n  }\n}\n\nmodule.exports = subtokenize;","'use strict';\n/* eslint-env browser */\n\nvar el;\nvar semicolon = 59; //  ';'\n\nmodule.exports = decodeEntity;\n\nfunction decodeEntity(characters) {\n  var entity = '&' + characters + ';';\n  var char;\n  el = el || document.createElement('i');\n  el.innerHTML = entity;\n  char = el.textContent; // 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\n  if (char.charCodeAt(char.length - 1) === semicolon && characters !== 'semi') {\n    return false;\n  } // If the decoded string is equal to the input, the entity was not valid\n\n\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'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;\n\nfunction z(a) {\n  if (\"object\" === typeof a && null !== a) {\n    var u = a.$$typeof;\n\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\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\n              default:\n                return u;\n            }\n\n        }\n\n      case d:\n        return u;\n    }\n  }\n}\n\nfunction A(a) {\n  return z(a) === m;\n}\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;\n\nexports.isAsyncMode = function (a) {\n  return A(a) || z(a) === l;\n};\n\nexports.isConcurrentMode = A;\n\nexports.isContextConsumer = function (a) {\n  return z(a) === k;\n};\n\nexports.isContextProvider = function (a) {\n  return z(a) === h;\n};\n\nexports.isElement = function (a) {\n  return \"object\" === typeof a && null !== a && a.$$typeof === c;\n};\n\nexports.isForwardRef = function (a) {\n  return z(a) === n;\n};\n\nexports.isFragment = function (a) {\n  return z(a) === e;\n};\n\nexports.isLazy = function (a) {\n  return z(a) === t;\n};\n\nexports.isMemo = function (a) {\n  return z(a) === r;\n};\n\nexports.isPortal = function (a) {\n  return z(a) === d;\n};\n\nexports.isProfiler = function (a) {\n  return z(a) === g;\n};\n\nexports.isStrictMode = function (a) {\n  return z(a) === f;\n};\n\nexports.isSuspense = function (a) {\n  return z(a) === p;\n};\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};\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');\n\nvar xtend = require('xtend');\n\nvar ReactIs = require('react-is');\n\nfunction astToReact(node, options) {\n  var parent = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  var index = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;\n  var renderer = options.renderers[node.type]; // Nodes created by plugins do not have positional info, in which case we set\n  // an object that matches the positon interface.\n\n  if (!node.position) {\n    node.position = {\n      start: {\n        line: null,\n        column: null,\n        offset: null\n      },\n      end: {\n        line: null,\n        column: null,\n        offset: null\n      }\n    };\n  }\n\n  var pos = node.position.start;\n  var key = [node.type, pos.line, pos.column, index].join('-');\n\n  if (!ReactIs.isValidElementType(renderer)) {\n    throw new Error(\"Renderer for type `\".concat(node.type, \"` not defined or is not renderable\"));\n  }\n\n  var nodeProps = getNodeProps(node, key, options, renderer, parent, index);\n  return React.createElement(renderer, nodeProps, nodeProps.children || resolveChildren() || undefined);\n\n  function resolveChildren() {\n    return node.children && node.children.map(function (childNode, i) {\n      return astToReact(childNode, options, {\n        node: node,\n        props: nodeProps\n      }, i);\n    });\n  }\n} // eslint-disable-next-line max-params, complexity\n\n\nfunction getNodeProps(node, key, opts, renderer, parent, index) {\n  var props = {\n    key: key\n  };\n  var isSimpleRenderer = typeof renderer === 'string' || renderer === React.Fragment; // `sourcePos` is true if the user wants source information (line/column info from markdown source)\n\n  if (opts.sourcePos && node.position) {\n    props['data-sourcepos'] = flattenPosition(node.position);\n  }\n\n  if (opts.rawSourcePos && !isSimpleRenderer) {\n    props.sourcePosition = node.position;\n  } // If `includeNodeIndex` is true, pass node index info to all non-tag renderers\n\n\n  if (opts.includeNodeIndex && parent.node && parent.node.children && !isSimpleRenderer) {\n    props.index = parent.node.children.indexOf(node);\n    props.parentChildCount = parent.node.children.length;\n  }\n\n  var ref = node.identifier !== null && node.identifier !== undefined ?\n  /* istanbul ignore next - plugins could inject an undefined reference. */\n  opts.definitions[node.identifier.toUpperCase()] || {} : null;\n\n  switch (node.type) {\n    case 'root':\n      assignDefined(props, {\n        className: opts.className\n      });\n      break;\n\n    case 'text':\n      props.nodeKey = key;\n      props.children = node.value;\n      break;\n\n    case 'heading':\n      props.level = node.depth;\n      break;\n\n    case 'list':\n      props.start = node.start;\n      props.ordered = node.ordered;\n      props.spread = node.spread;\n      props.depth = node.depth;\n      break;\n\n    case 'listItem':\n      props.checked = node.checked;\n      props.spread = node.spread;\n      props.ordered = node.ordered;\n      props.index = node.index;\n      props.children = getListItemChildren(node, parent).map(function (childNode, i) {\n        return astToReact(childNode, opts, {\n          node: node,\n          props: props\n        }, i);\n      });\n      break;\n\n    case 'definition':\n      assignDefined(props, {\n        identifier: node.identifier,\n        title: node.title,\n        url: node.url\n      });\n      break;\n\n    case 'code':\n      assignDefined(props, {\n        language: node.lang && node.lang.split(/\\s/, 1)[0]\n      });\n      break;\n\n    case 'inlineCode':\n      props.children = node.value;\n      props.inline = true;\n      break;\n\n    case 'link':\n      assignDefined(props, {\n        title: node.title || undefined,\n        target: typeof opts.linkTarget === 'function' ? opts.linkTarget(node.url, node.children, node.title) : opts.linkTarget,\n        href: opts.transformLinkUri ? opts.transformLinkUri(node.url, node.children, node.title) : node.url\n      });\n      break;\n\n    case 'image':\n      assignDefined(props, {\n        src: opts.transformImageUri ? opts.transformImageUri(node.url, node.children, node.title, node.alt) : node.url,\n        alt: node.alt || '',\n        title: node.title || undefined\n      });\n      break;\n\n    case 'linkReference':\n      assignDefined(props, xtend(ref, {\n        href: opts.transformLinkUri ? opts.transformLinkUri(ref.href) : ref.href\n      }));\n      break;\n\n    case 'imageReference':\n      assignDefined(props, {\n        src: opts.transformImageUri && ref.href ? opts.transformImageUri(ref.href, node.children, ref.title, node.alt) : ref.href,\n        alt: node.alt || '',\n        title: ref.title || undefined\n      });\n      break;\n\n    case 'table':\n    case 'tableHead':\n    case 'tableBody':\n      props.columnAlignment = node.align;\n      break;\n\n    case 'tableRow':\n      props.isHeader = parent.node.type === 'tableHead';\n      props.columnAlignment = parent.props.columnAlignment;\n      break;\n\n    case 'tableCell':\n      assignDefined(props, {\n        isHeader: parent.props.isHeader,\n        align: parent.props.columnAlignment[index]\n      });\n      break;\n\n    case 'virtualHtml':\n      props.tag = node.tag;\n      break;\n\n    case 'html':\n      // @todo find a better way than this\n      props.isBlock = node.position.start.line !== node.position.end.line;\n      props.allowDangerousHtml = opts.allowDangerousHtml;\n      props.escapeHtml = opts.escapeHtml;\n      props.skipHtml = opts.skipHtml;\n      break;\n\n    case 'parsedHtml':\n      {\n        var parsedChildren;\n\n        if (node.children) {\n          parsedChildren = node.children.map(function (child, i) {\n            return astToReact(child, opts, {\n              node: node,\n              props: props\n            }, i);\n          });\n        }\n\n        props.allowDangerousHtml = opts.allowDangerousHtml;\n        props.escapeHtml = opts.escapeHtml;\n        props.skipHtml = opts.skipHtml;\n        props.element = node.element ? mergeNodeChildren(node, parsedChildren) : null;\n        break;\n      }\n\n    default:\n      assignDefined(props, xtend(node, {\n        type: undefined,\n        position: undefined,\n        children: undefined\n      }));\n  }\n\n  if (!isSimpleRenderer && node.value) {\n    props.value = node.value;\n  }\n\n  if (!isSimpleRenderer) {\n    props.node = node;\n  }\n\n  return props;\n}\n\nfunction assignDefined(target, attrs) {\n  for (var key in attrs) {\n    if (typeof attrs[key] !== 'undefined') {\n      target[key] = attrs[key];\n    }\n  }\n}\n\nfunction mergeNodeChildren(node, parsedChildren) {\n  var el = node.element;\n\n  if (Array.isArray(el)) {\n    /* istanbul ignore next - `div` fallback for old React. */\n    var Fragment = React.Fragment || 'div';\n    return React.createElement(Fragment, null, el);\n  }\n\n  if (el.props.children || parsedChildren) {\n    var children = React.Children.toArray(el.props.children).concat(parsedChildren);\n    return React.cloneElement(el, null, children);\n  }\n\n  return React.cloneElement(el, null);\n}\n\nfunction flattenPosition(pos) {\n  return [pos.start.line, ':', pos.start.column, '-', pos.end.line, ':', pos.end.column].map(String).join('');\n}\n\nfunction getListItemChildren(node, parent) {\n  /* istanbul ignore next - list items are always in a list, but best to be sure. */\n  var loose = parent && parent.node ? listLoose(parent.node) : listItemLoose(node);\n  return loose ? node.children : unwrapParagraphs(node);\n}\n\nfunction unwrapParagraphs(node) {\n  return node.children.reduce(function (array, child) {\n    return array.concat(child.type === 'paragraph' ? child.children : [child]);\n  }, []);\n}\n\nfunction listLoose(node) {\n  var children = node.children;\n  var loose = node.spread;\n  var index = -1;\n\n  while (!loose && ++index < children.length) {\n    loose = listItemLoose(children[index]);\n  }\n\n  return loose;\n}\n\nfunction listItemLoose(node) {\n  var spread = node.spread;\n  /* istanbul ignore next - spread is present from remark-parse, but maybe plugins don’t set it. */\n\n  return spread === undefined || spread === null ? node.children.length > 1 : spread;\n}\n\nmodule.exports = astToReact;","'use strict';\n\nvar visit = require('unist-util-visit');\n\nmodule.exports = function getDefinitions(tree) {\n  var definitions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  visit(tree, 'definition', function (node) {\n    var identifier = node.identifier.toUpperCase();\n    if (identifier in definitions) return;\n    definitions[identifier] = {\n      href: node.url,\n      title: node.title\n    };\n  });\n  return definitions;\n};","\"use strict\";\n\nvar visit = require('unist-util-visit');\n\nvar splice = [].splice;\n\nexports.ofType = function (types, mode) {\n  return ifNotMatch(allow, mode);\n\n  function allow(node, index, parent) {\n    return !types.includes(node.type);\n  }\n};\n\nexports.ifNotMatch = ifNotMatch;\n\nfunction ifNotMatch(allow, mode) {\n  return transform;\n\n  function transform(tree) {\n    visit(tree, filter);\n    return tree;\n  } // eslint-disable-next-line consistent-return\n\n\n  function filter(node, index, parent) {\n    if (parent && !allow(node, index, parent)) {\n      var parameters = [index, 1];\n\n      if (mode === 'unwrap' && node.children) {\n        parameters = parameters.concat(node.children);\n      }\n\n      splice.apply(parent.children, parameters);\n      return index;\n    }\n  }\n}","\"use strict\";\n/**\n * 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 **/\n\nvar visit = require('unist-util-visit');\n\nvar type = 'virtualHtml';\nvar selfClosingRe = /^<(area|base|br|col|embed|hr|img|input|keygen|link|meta|param|source|track|wbr)\\s*\\/?>$/i;\nvar simpleTagRe = /^<(\\/?)([a-z]+)\\s*>$/;\n\nmodule.exports = function (tree) {\n  var open;\n  var currentParent;\n  visit(tree, 'html', function (node, index, parent) {\n    if (currentParent !== parent) {\n      open = [];\n      currentParent = parent;\n    }\n\n    var selfClosing = getSelfClosing(node);\n\n    if (selfClosing) {\n      parent.children.splice(index, 1, {\n        type: type,\n        tag: selfClosing,\n        position: node.position\n      });\n      return true;\n    }\n\n    var current = getSimpleTag(node, parent);\n\n    if (!current) {\n      return true;\n    }\n\n    var matching = findAndPull(open, current.tag);\n\n    if (matching) {\n      parent.children.splice(index, 0, virtual(current, matching, parent));\n    } else if (!current.opening) {\n      open.push(current);\n    }\n\n    return true;\n  }, true // Iterate in reverse\n  );\n  return tree;\n};\n\nfunction findAndPull(open, matchingTag) {\n  var i = open.length;\n\n  while (i--) {\n    if (open[i].tag === matchingTag) {\n      return open.splice(i, 1)[0];\n    }\n  }\n\n  return false;\n}\n\nfunction getSimpleTag(node, parent) {\n  var match = node.value.match(simpleTagRe);\n  return match ? {\n    tag: match[2],\n    opening: !match[1],\n    node: node\n  } : false;\n}\n\nfunction getSelfClosing(node) {\n  var match = node.value.match(selfClosingRe);\n  return match ? match[1] : false;\n}\n\nfunction virtual(fromNode, toNode, parent) {\n  var fromIndex = parent.children.indexOf(fromNode.node);\n  var toIndex = parent.children.indexOf(toNode.node);\n  var extracted = parent.children.splice(fromIndex, toIndex - fromIndex + 1);\n  var children = extracted.slice(1, -1);\n  return {\n    type: type,\n    children: children,\n    tag: fromNode.tag,\n    position: {\n      start: fromNode.node.position.start,\n      end: toNode.node.position.end,\n      indent: []\n    }\n  };\n}","'use strict';\n\nvar xtend = require('xtend');\n\nvar unified = require('unified');\n\nvar parse = require('remark-parse');\n\nvar PropTypes = require('prop-types');\n\nvar addListMetadata = require('mdast-add-list-metadata');\n\nvar naiveHtml = require('./plugins/naive-html');\n\nvar disallowNode = require('./plugins/disallow-node');\n\nvar astToReact = require('./ast-to-react');\n\nvar wrapTableRows = require('./wrap-table-rows');\n\nvar getDefinitions = require('./get-definitions');\n\nvar uriTransformer = require('./uri-transformer');\n\nvar defaultRenderers = require('./renderers');\n\nvar symbols = require('./symbols');\n\nvar allTypes = Object.keys(defaultRenderers);\n\nvar ReactMarkdown = function ReactMarkdown(props) {\n  // To do in next major: remove `source`.\n  var src = props.source || props.children || '';\n\n  if (props.allowedTypes && props.disallowedTypes) {\n    throw new Error('Only one of `allowedTypes` and `disallowedTypes` should be defined');\n  }\n\n  var renderers = xtend(defaultRenderers, props.renderers);\n  var processor = unified().use(parse).use(props.plugins || []); // eslint-disable-next-line no-sync\n\n  var tree = processor.runSync(processor.parse(src));\n  var renderProps = xtend(props, {\n    renderers: renderers,\n    definitions: getDefinitions(tree)\n  });\n  determineAstToReactTransforms(props).forEach(function (transform) {\n    tree = transform(tree, renderProps);\n  });\n  return tree;\n};\n\nfunction determineAstToReactTransforms(props) {\n  var transforms = [wrapTableRows, addListMetadata()];\n  var disallowedTypes = props.disallowedTypes;\n\n  if (props.allowedTypes) {\n    disallowedTypes = allTypes.filter(function (type) {\n      return type !== 'root' && props.allowedTypes.indexOf(type) === -1;\n    });\n  }\n\n  var removalMethod = props.unwrapDisallowed ? 'unwrap' : 'remove';\n\n  if (disallowedTypes && disallowedTypes.length > 0) {\n    transforms.push(disallowNode.ofType(disallowedTypes, removalMethod));\n  }\n\n  if (props.allowNode) {\n    transforms.push(disallowNode.ifNotMatch(props.allowNode, removalMethod));\n  } // To do in next major: remove `escapeHtml`.\n\n\n  var renderHtml = (props.allowDangerousHtml || props.escapeHtml === false) && !props.skipHtml;\n  var hasHtmlParser = (props.astPlugins || []).some(function (transform) {\n    return transform.identity === symbols.HtmlParser;\n  });\n\n  if (renderHtml && !hasHtmlParser) {\n    transforms.push(naiveHtml);\n  }\n\n  if (props.astPlugins) {\n    transforms = transforms.concat(props.astPlugins);\n  } // Add the final transform to turn everything into React.\n\n\n  transforms.push(astToReact);\n  return transforms;\n}\n\nReactMarkdown.defaultProps = {\n  transformLinkUri: uriTransformer\n};\nReactMarkdown.propTypes = {\n  className: PropTypes.string,\n  source: PropTypes.string,\n  children: PropTypes.string,\n  sourcePos: PropTypes.bool,\n  rawSourcePos: PropTypes.bool,\n  escapeHtml: PropTypes.bool,\n  allowDangerousHtml: PropTypes.bool,\n  skipHtml: PropTypes.bool,\n  allowNode: PropTypes.func,\n  allowedTypes: PropTypes.arrayOf(PropTypes.oneOf(allTypes)),\n  disallowedTypes: PropTypes.arrayOf(PropTypes.oneOf(allTypes)),\n  transformLinkUri: PropTypes.oneOfType([PropTypes.func, PropTypes.bool]),\n  linkTarget: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  transformImageUri: PropTypes.func,\n  astPlugins: PropTypes.arrayOf(PropTypes.func),\n  unwrapDisallowed: PropTypes.bool,\n  renderers: PropTypes.object,\n  plugins: PropTypes.array\n};\nReactMarkdown.types = allTypes;\nReactMarkdown.renderers = defaultRenderers;\nReactMarkdown.uriTransformer = uriTransformer;\nmodule.exports = ReactMarkdown;","/* eslint-disable react/prop-types, react/no-multi-comp */\n'use strict';\n\nvar xtend = require('xtend');\n\nvar React = require('react');\n/* istanbul ignore next - Don’t crash on old React. */\n\n\nvar supportsStringRender = parseInt((React.version || '16').slice(0, 2), 10) >= 16;\nvar createElement = React.createElement;\nmodule.exports = {\n  break: 'br',\n  paragraph: 'p',\n  emphasis: 'em',\n  strong: 'strong',\n  thematicBreak: 'hr',\n  blockquote: 'blockquote',\n  delete: 'del',\n  link: 'a',\n  image: 'img',\n  linkReference: 'a',\n  imageReference: 'img',\n  table: SimpleRenderer.bind(null, 'table'),\n  tableHead: SimpleRenderer.bind(null, 'thead'),\n  tableBody: SimpleRenderer.bind(null, 'tbody'),\n  tableRow: SimpleRenderer.bind(null, 'tr'),\n  tableCell: TableCell,\n  root: Root,\n  text: TextRenderer,\n  list: List,\n  listItem: ListItem,\n  definition: NullRenderer,\n  heading: Heading,\n  inlineCode: InlineCode,\n  code: CodeBlock,\n  html: Html,\n  virtualHtml: VirtualHtml,\n  parsedHtml: ParsedHtml\n};\n\nfunction TextRenderer(props) {\n  /* istanbul ignore next - a text node w/o a value could be injected by plugins */\n  var children = props.children || '';\n  /* istanbul ignore next - `span` is a fallback for old React. */\n\n  return supportsStringRender ? children : createElement('span', null, children);\n}\n\nfunction Root(props) {\n  var className = props.className;\n  var root = !className && React.Fragment || 'div';\n  return createElement(root, className ? {\n    className: className\n  } : null, props.children);\n}\n\nfunction SimpleRenderer(tag, props) {\n  return createElement(tag, getCoreProps(props), props.children);\n}\n\nfunction TableCell(props) {\n  var style = props.align ? {\n    textAlign: props.align\n  } : undefined;\n  var coreProps = getCoreProps(props);\n  return createElement(props.isHeader ? 'th' : 'td', style ? xtend({\n    style: style\n  }, coreProps) : coreProps, props.children);\n}\n\nfunction Heading(props) {\n  return createElement(\"h\".concat(props.level), getCoreProps(props), props.children);\n}\n\nfunction List(props) {\n  var attrs = getCoreProps(props);\n\n  if (props.start !== null && props.start !== 1 && props.start !== undefined) {\n    attrs.start = props.start.toString();\n  }\n\n  return createElement(props.ordered ? 'ol' : 'ul', attrs, props.children);\n}\n\nfunction ListItem(props) {\n  var checkbox = null;\n\n  if (props.checked !== null && props.checked !== undefined) {\n    var checked = props.checked;\n    checkbox = createElement('input', {\n      type: 'checkbox',\n      checked: checked,\n      readOnly: true\n    });\n  }\n\n  return createElement('li', getCoreProps(props), checkbox, props.children);\n}\n\nfunction CodeBlock(props) {\n  var className = props.language && \"language-\".concat(props.language);\n  var code = createElement('code', className ? {\n    className: className\n  } : null, props.value);\n  return createElement('pre', getCoreProps(props), code);\n}\n\nfunction InlineCode(props) {\n  return createElement('code', getCoreProps(props), props.children);\n}\n\nfunction Html(props) {\n  if (props.skipHtml) {\n    return null;\n  }\n\n  var dangerous = props.allowDangerousHtml || props.escapeHtml === false;\n  var tag = props.isBlock ? 'div' : 'span';\n\n  if (!dangerous) {\n    /* istanbul ignore next - `tag` is a fallback for old React. */\n    return createElement(React.Fragment || tag, null, props.value);\n  }\n\n  var nodeProps = {\n    dangerouslySetInnerHTML: {\n      __html: props.value\n    }\n  };\n  return createElement(tag, nodeProps);\n}\n\nfunction ParsedHtml(props) {\n  /* To do: `React.cloneElement` is slow, is it really needed? */\n  return props['data-sourcepos'] ? React.cloneElement(props.element, {\n    'data-sourcepos': props['data-sourcepos']\n  }) : props.element;\n}\n\nfunction VirtualHtml(props) {\n  return createElement(props.tag, getCoreProps(props), props.children);\n}\n\nfunction NullRenderer() {\n  return null;\n}\n\nfunction getCoreProps(props) {\n  var source = props['data-sourcepos'];\n  /* istanbul ignore next - nodes from plugins w/o position */\n\n  return source ? {\n    'data-sourcepos': source\n  } : {};\n}","\"use strict\";\n\nvar HtmlParser = '__RMD_HTML_PARSER__';\n/* istanbul ignore next - Fallback for `Symbol`. */\n\nexports.HtmlParser = typeof Symbol === 'undefined' ? HtmlParser : Symbol(HtmlParser);","\"use strict\";\n\nvar protocols = ['http', 'https', 'mailto', 'tel'];\n\nmodule.exports = function uriTransformer(uri) {\n  var url = (uri || '').trim();\n  var first = url.charAt(0);\n\n  if (first === '#' || first === '/') {\n    return url;\n  }\n\n  var colon = url.indexOf(':');\n\n  if (colon === -1) {\n    return url;\n  }\n\n  var length = protocols.length;\n  var index = -1;\n\n  while (++index < length) {\n    var protocol = protocols[index];\n\n    if (colon === protocol.length && url.slice(0, protocol.length).toLowerCase() === protocol) {\n      return url;\n    }\n  }\n\n  index = url.indexOf('?');\n\n  if (index !== -1 && colon > index) {\n    return url;\n  }\n\n  index = url.indexOf('#');\n\n  if (index !== -1 && colon > index) {\n    return url;\n  } // eslint-disable-next-line no-script-url\n\n\n  return 'javascript:void(0)';\n};","'use strict';\n\nvar visit = require('unist-util-visit');\n\nmodule.exports = function (node) {\n  visit(node, 'table', wrap);\n  return node;\n};\n\nfunction wrap(table) {\n  var children = table.children;\n  table.children = [{\n    type: 'tableHead',\n    align: table.align,\n    children: [children[0]],\n    position: children[0].position\n  }];\n\n  if (children.length > 1) {\n    table.children.push({\n      type: 'tableBody',\n      align: table.align,\n      children: children.slice(1),\n      position: {\n        start: children[1].position.start,\n        end: children[children.length - 1].position.end\n      }\n    });\n  }\n}","'use strict';\n\nmodule.exports = function (value) {\n  if (Object.prototype.toString.call(value) !== '[object Object]') {\n    return false;\n  }\n\n  var prototype = Object.getPrototypeOf(value);\n  return prototype === null || prototype === Object.prototype;\n};","'use strict';\n\nmodule.exports = parse;\n\nvar fromMarkdown = require('mdast-util-from-markdown');\n\nfunction parse(options) {\n  var self = this;\n  this.Parser = parse;\n\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\nvar bail = require('bail');\n\nvar buffer = require('is-buffer');\n\nvar extend = require('extend');\n\nvar plain = require('is-plain-obj');\n\nvar trough = require('trough');\n\nvar vfile = require('vfile'); // Expose a frozen processor.\n\n\nmodule.exports = unified().freeze();\nvar slice = [].slice;\nvar own = {}.hasOwnProperty; // Process pipeline.\n\nvar pipeline = trough().use(pipelineParse).use(pipelineRun).use(pipelineStringify);\n\nfunction pipelineParse(p, ctx) {\n  ctx.tree = p.parse(ctx.file);\n}\n\nfunction pipelineRun(p, ctx, next) {\n  p.run(ctx.tree, ctx.file, done);\n\n  function done(error, tree, file) {\n    if (error) {\n      next(error);\n    } else {\n      ctx.tree = tree;\n      ctx.file = file;\n      next();\n    }\n  }\n}\n\nfunction pipelineStringify(p, ctx) {\n  var result = p.stringify(ctx.tree, ctx.file);\n\n  if (result === undefined || result === null) {// Empty.\n  } else if (typeof result === 'string' || buffer(result)) {\n    ctx.file.contents = result;\n  } else {\n    ctx.file.result = result;\n  }\n} // Function to create the first processor.\n\n\nfunction unified() {\n  var attachers = [];\n  var transformers = trough();\n  var namespace = {};\n  var freezeIndex = -1;\n  var frozen; // Data management.\n\n  processor.data = data; // Lock.\n\n  processor.freeze = freeze; // Plugins.\n\n  processor.attachers = attachers;\n  processor.use = use; // API.\n\n  processor.parse = parse;\n  processor.stringify = stringify;\n  processor.run = run;\n  processor.runSync = runSync;\n  processor.process = process;\n  processor.processSync = processSync; // Expose.\n\n  return processor; // Create a new processor based on the processor in the current scope.\n\n  function processor() {\n    var destination = unified();\n    var index = -1;\n\n    while (++index < attachers.length) {\n      destination.use.apply(null, attachers[index]);\n    }\n\n    destination.data(extend(true, {}, namespace));\n    return destination;\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\n\n  function freeze() {\n    var values;\n    var transformer;\n\n    if (frozen) {\n      return processor;\n    }\n\n    while (++freezeIndex < attachers.length) {\n      values = attachers[freezeIndex];\n\n      if (values[1] === false) {\n        continue;\n      }\n\n      if (values[1] === true) {\n        values[1] = undefined;\n      }\n\n      transformer = values[0].apply(processor, values.slice(1));\n\n      if (typeof transformer === 'function') {\n        transformers.use(transformer);\n      }\n    }\n\n    frozen = true;\n    freezeIndex = Infinity;\n    return processor;\n  } // Data management.\n  // Getter / setter for processor-specific informtion.\n\n\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      } // Get `key`.\n\n\n      return own.call(namespace, key) && namespace[key] || null;\n    } // Set space.\n\n\n    if (key) {\n      assertUnfrozen('data', frozen);\n      namespace = key;\n      return processor;\n    } // Get space.\n\n\n    return namespace;\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\n\n  function use(value) {\n    var settings;\n    assertUnfrozen('use', frozen);\n\n    if (value === null || value === undefined) {// Empty.\n    } else if (typeof value === 'function') {\n      addPlugin.apply(null, arguments);\n    } else if (typeof value === 'object') {\n      if ('length' in value) {\n        addList(value);\n      } else {\n        addPreset(value);\n      }\n    } else {\n      throw new Error('Expected usable value, not `' + value + '`');\n    }\n\n    if (settings) {\n      namespace.settings = extend(namespace.settings || {}, settings);\n    }\n\n    return processor;\n\n    function addPreset(result) {\n      addList(result.plugins);\n\n      if (result.settings) {\n        settings = extend(settings || {}, result.settings);\n      }\n    }\n\n    function add(value) {\n      if (typeof value === 'function') {\n        addPlugin(value);\n      } else if (typeof value === 'object') {\n        if ('length' in value) {\n          addPlugin.apply(null, value);\n        } else {\n          addPreset(value);\n        }\n      } else {\n        throw new Error('Expected usable value, not `' + value + '`');\n      }\n    }\n\n    function addList(plugins) {\n      var index = -1;\n\n      if (plugins === null || plugins === undefined) {// Empty.\n      } else if (typeof plugins === 'object' && 'length' in plugins) {\n        while (++index < plugins.length) {\n          add(plugins[index]);\n        }\n      } else {\n        throw new Error('Expected a list of plugins, not `' + plugins + '`');\n      }\n    }\n\n    function addPlugin(plugin, value) {\n      var entry = find(plugin);\n\n      if (entry) {\n        if (plain(entry[1]) && plain(value)) {\n          value = extend(true, entry[1], value);\n        }\n\n        entry[1] = value;\n      } else {\n        attachers.push(slice.call(arguments));\n      }\n    }\n  }\n\n  function find(plugin) {\n    var index = -1;\n\n    while (++index < attachers.length) {\n      if (attachers[index][0] === plugin) {\n        return attachers[index];\n      }\n    }\n  } // Parse a file (in string or vfile representation) into a unist node using\n  // the `Parser` on the processor.\n\n\n  function parse(doc) {\n    var file = vfile(doc);\n    var Parser;\n    freeze();\n    Parser = processor.Parser;\n    assertParser('parse', Parser);\n\n    if (newable(Parser, 'parse')) {\n      return new Parser(String(file), file).parse();\n    }\n\n    return Parser(String(file), file); // eslint-disable-line new-cap\n  } // Run transforms on a unist node representation of a file (in string or\n  // vfile representation), async.\n\n\n  function run(node, file, cb) {\n    assertNode(node);\n    freeze();\n\n    if (!cb && typeof file === 'function') {\n      cb = file;\n      file = null;\n    }\n\n    if (!cb) {\n      return new Promise(executor);\n    }\n\n    executor(null, cb);\n\n    function executor(resolve, reject) {\n      transformers.run(node, vfile(file), done);\n\n      function done(error, tree, file) {\n        tree = tree || node;\n\n        if (error) {\n          reject(error);\n        } else if (resolve) {\n          resolve(tree);\n        } else {\n          cb(null, tree, file);\n        }\n      }\n    }\n  } // Run transforms on a unist node representation of a file (in string or\n  // vfile representation), sync.\n\n\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\n    function done(error, tree) {\n      complete = true;\n      result = tree;\n      bail(error);\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\n\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\n    if (newable(Compiler, 'compile')) {\n      return new Compiler(node, file).compile();\n    }\n\n    return Compiler(node, file); // eslint-disable-line new-cap\n  } // 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\n\n  function process(doc, cb) {\n    freeze();\n    assertParser('process', processor.Parser);\n    assertCompiler('process', processor.Compiler);\n\n    if (!cb) {\n      return new Promise(executor);\n    }\n\n    executor(null, cb);\n\n    function executor(resolve, reject) {\n      var file = vfile(doc);\n      pipeline.run(processor, {\n        file: file\n      }, done);\n\n      function done(error) {\n        if (error) {\n          reject(error);\n        } else if (resolve) {\n          resolve(file);\n        } else {\n          cb(null, file);\n        }\n      }\n    }\n  } // Process the given document (in string or vfile representation), sync.\n\n\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\n    function done(error) {\n      complete = true;\n      bail(error);\n    }\n  }\n} // Check if `value` is a constructor.\n\n\nfunction newable(value, name) {\n  return typeof value === 'function' && value.prototype && (keys(value.prototype) || name in value.prototype);\n} // Check if `value` is an object with keys.\n\n\nfunction keys(value) {\n  var key;\n\n  for (key in value) {\n    return true;\n  }\n\n  return false;\n} // Assert a parser is available.\n\n\nfunction assertParser(name, Parser) {\n  if (typeof Parser !== 'function') {\n    throw new Error('Cannot `' + name + '` without `Parser`');\n  }\n} // Assert a compiler is available.\n\n\nfunction assertCompiler(name, Compiler) {\n  if (typeof Compiler !== 'function') {\n    throw new Error('Cannot `' + name + '` without `Compiler`');\n  }\n} // Assert the processor is not frozen.\n\n\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} // Assert `node` is a unist node.\n\n\nfunction assertNode(node) {\n  if (!node || typeof node.type !== 'string') {\n    throw new Error('Expected node, got `' + node + '`');\n  }\n} // Assert that `complete` is `true`.\n\n\nfunction assertDone(name, asyncName, complete) {\n  if (!complete) {\n    throw new Error('`' + name + '` finished async. Use `' + asyncName + '` instead');\n  }\n}","'use strict';\n\nvar syntax = require('micromark-extension-gfm');\n\nvar fromMarkdown = require('mdast-util-gfm/from-markdown');\n\nvar toMarkdown = require('mdast-util-gfm/to-markdown');\n\nvar warningIssued;\nmodule.exports = gfm;\n\nfunction gfm(options) {\n  var data = this.data();\n  /* istanbul ignore next - old remark. */\n\n  if (!warningIssued && (this.Parser && this.Parser.prototype && this.Parser.prototype.blockTokenizers || this.Compiler && this.Compiler.prototype && this.Compiler.prototype.visitors)) {\n    warningIssued = true;\n    console.warn('[remark-gfm] Warning: please upgrade to remark 13 to use this plugin');\n  }\n\n  add('micromarkExtensions', syntax(options));\n  add('fromMarkdownExtensions', fromMarkdown);\n  add('toMarkdownExtensions', toMarkdown(options));\n\n  function add(field, value) {\n    /* istanbul ignore if - other extensions. */\n    if (data[field]) data[field].push(value);else data[field] = [value];\n  }\n}","/*!\n * repeat-string <https://github.com/jonschlinkert/repeat-string>\n *\n * Copyright (c) 2014-2015, Jon Schlinkert.\n * Licensed under the MIT License.\n */\n'use strict';\n/**\n * Results cache\n */\n\nvar res = '';\nvar cache;\n/**\n * Expose `repeat`\n */\n\nmodule.exports = repeat;\n/**\n * Repeat the given `string` the specified `number`\n * of times.\n *\n * **Example:**\n *\n * ```js\n * var repeat = require('repeat-string');\n * repeat('A', 5);\n * //=> AAAAA\n * ```\n *\n * @param {String} `string` The string to repeat\n * @param {Number} `number` The number of times to repeat the string\n * @return {String} Repeated string\n * @api public\n */\n\nfunction repeat(str, num) {\n  if (typeof str !== 'string') {\n    throw new TypeError('expected a string');\n  } // cover common, quick use cases\n\n\n  if (num === 1) return str;\n  if (num === 2) return str + str;\n  var max = str.length * num;\n\n  if (cache !== str || typeof cache === 'undefined') {\n    cache = str;\n    res = '';\n  } else if (res.length >= max) {\n    return res.substr(0, max);\n  }\n\n  while (max > res.length && num > 1) {\n    if (num & 1) {\n      res += str;\n    }\n\n    num >>= 1;\n    str += str;\n  }\n\n  res += str;\n  res = res.substr(0, max);\n  return res;\n}","// replaces all whitespace with '-' and removes\n// all non-url friendly characters\n(function () {\n  var whitespace = /\\s+/g;\n\n  function slugger(string, opts) {\n    opts || (opts = {});\n    var allowedCharacters = \"A-Za-z0-9_ -\";\n    if (opts.alsoAllow) allowedCharacters = opts.alsoAllow + allowedCharacters;\n    var re = new RegExp('[^' + allowedCharacters + ']', 'g');\n    var maintainCase = opts.maintainCase || false;\n    var replacement = opts.replacement || '-';\n    var smartTrim = opts.smartTrim;\n    var decode = opts.decode !== false;\n    var result;\n    var lucky;\n    if (typeof string !== 'string') return '';\n    if (!maintainCase) string = string.toLowerCase();\n    if (decode) string = decodeURIComponent(string);\n    result = string.trim().replace(re, '').replace(whitespace, replacement);\n\n    if (smartTrim && result.length > smartTrim) {\n      lucky = result.charAt(smartTrim) === replacement;\n      result = result.slice(0, smartTrim);\n      if (!lucky) result = result.slice(0, result.lastIndexOf(replacement));\n    }\n\n    return result;\n  }\n\n  if (typeof module !== 'undefined') {\n    module.exports = slugger;\n  } else {\n    window.slugger = slugger;\n  }\n})();","'use strict';\n\nvar wrap = require('./wrap.js');\n\nmodule.exports = trough;\ntrough.wrap = wrap;\nvar slice = [].slice; // Create new middleware.\n\nfunction trough() {\n  var fns = [];\n  var middleware = {};\n  middleware.run = run;\n  middleware.use = use;\n  return middleware; // Run `fns`.  Last argument must be a completion handler.\n\n  function run() {\n    var index = -1;\n    var input = slice.call(arguments, 0, -1);\n    var done = arguments[arguments.length - 1];\n\n    if (typeof done !== 'function') {\n      throw new Error('Expected function as last argument, not ' + done);\n    }\n\n    next.apply(null, [null].concat(input)); // Run the next `fn`, if any.\n\n    function next(err) {\n      var fn = fns[++index];\n      var params = slice.call(arguments, 0);\n      var values = params.slice(1);\n      var length = input.length;\n      var pos = -1;\n\n      if (err) {\n        done(err);\n        return;\n      } // Copy non-nully input into values.\n\n\n      while (++pos < length) {\n        if (values[pos] === null || values[pos] === undefined) {\n          values[pos] = input[pos];\n        }\n      }\n\n      input = values; // Next or done.\n\n      if (fn) {\n        wrap(fn, next).apply(null, input);\n      } else {\n        done.apply(null, [null].concat(input));\n      }\n    }\n  } // Add `fn` to the list.\n\n\n  function use(fn) {\n    if (typeof fn !== 'function') {\n      throw new Error('Expected `fn` to be a function, not ' + fn);\n    }\n\n    fns.push(fn);\n    return middleware;\n  }\n}","'use strict';\n\nvar slice = [].slice;\nmodule.exports = wrap; // Wrap `fn`.\n// Can be sync or async; return a promise, receive a completion handler, return\n// new values and errors.\n\nfunction wrap(fn, callback) {\n  var invoked;\n  return wrapped;\n\n  function wrapped() {\n    var params = slice.call(arguments, 0);\n    var callback = fn.length > params.length;\n    var result;\n\n    if (callback) {\n      params.push(done);\n    }\n\n    try {\n      result = fn.apply(null, params);\n    } catch (error) {\n      // Well, this is quite the pickle.\n      // `fn` received a callback and invoked it (thus continuing the pipeline),\n      // but later also threw an error.\n      // We’re not about to restart the pipeline again, so the only thing left\n      // to do is to throw the thing instead.\n      if (callback && invoked) {\n        throw error;\n      }\n\n      return done(error);\n    }\n\n    if (!callback) {\n      if (result && typeof result.then === 'function') {\n        result.then(then, done);\n      } else if (result instanceof Error) {\n        done(result);\n      } else {\n        then(result);\n      }\n    }\n  } // Invoke `next`, only once.\n\n\n  function done() {\n    if (!invoked) {\n      invoked = true;\n      callback.apply(null, arguments);\n    }\n  } // Invoke `done` with one value.\n  // Tracks if an error is passed, too.\n\n\n  function then(value) {\n    done(null, value);\n  }\n}","'use strict';\n\nmodule.exports = convert;\n\nfunction convert(test) {\n  if (test == null) {\n    return ok;\n  }\n\n  if (typeof test === 'string') {\n    return typeFactory(test);\n  }\n\n  if (typeof test === 'object') {\n    return 'length' in test ? anyFactory(test) : allFactory(test);\n  }\n\n  if (typeof test === 'function') {\n    return test;\n  }\n\n  throw new Error('Expected function, string, or object as test');\n} // Utility assert each property in `test` is represented in `node`, and each\n// values are strictly equal.\n\n\nfunction allFactory(test) {\n  return all;\n\n  function all(node) {\n    var key;\n\n    for (key in test) {\n      if (node[key] !== test[key]) return false;\n    }\n\n    return true;\n  }\n}\n\nfunction anyFactory(tests) {\n  var checks = [];\n  var index = -1;\n\n  while (++index < tests.length) {\n    checks[index] = convert(tests[index]);\n  }\n\n  return any;\n\n  function any() {\n    var index = -1;\n\n    while (++index < checks.length) {\n      if (checks[index].apply(this, arguments)) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n} // Utility to convert a string into a function which checks a given node’s type\n// for said string.\n\n\nfunction typeFactory(test) {\n  return type;\n\n  function type(node) {\n    return Boolean(node && node.type === test);\n  }\n} // Utility to return true.\n\n\nfunction ok() {\n  return true;\n}","'use strict';\n\nvar own = {}.hasOwnProperty;\nmodule.exports = stringify;\n\nfunction stringify(value) {\n  // Nothing.\n  if (!value || typeof value !== 'object') {\n    return '';\n  } // Node.\n\n\n  if (own.call(value, 'position') || own.call(value, 'type')) {\n    return position(value.position);\n  } // Position.\n\n\n  if (own.call(value, 'start') || own.call(value, 'end')) {\n    return position(value);\n  } // Point.\n\n\n  if (own.call(value, 'line') || own.call(value, 'column')) {\n    return point(value);\n  } // ?\n\n\n  return '';\n}\n\nfunction point(point) {\n  if (!point || typeof point !== 'object') {\n    point = {};\n  }\n\n  return index(point.line) + ':' + index(point.column);\n}\n\nfunction position(pos) {\n  if (!pos || typeof pos !== 'object') {\n    pos = {};\n  }\n\n  return point(pos.start) + '-' + point(pos.end);\n}\n\nfunction index(value) {\n  return value && typeof value === 'number' ? value : 1;\n}","module.exports = identity;\n\nfunction identity(d) {\n  return d;\n}","'use strict';\n\nmodule.exports = visitParents;\n\nvar convert = require('unist-util-is/convert');\n\nvar color = require('./color');\n\nvar CONTINUE = true;\nvar SKIP = 'skip';\nvar EXIT = false;\nvisitParents.CONTINUE = CONTINUE;\nvisitParents.SKIP = SKIP;\nvisitParents.EXIT = EXIT;\n\nfunction visitParents(tree, test, visitor, reverse) {\n  var step;\n  var is;\n\n  if (typeof test === 'function' && typeof visitor !== 'function') {\n    reverse = visitor;\n    visitor = test;\n    test = null;\n  }\n\n  is = convert(test);\n  step = reverse ? -1 : 1;\n  factory(tree, null, [])();\n\n  function factory(node, index, parents) {\n    var value = typeof node === 'object' && node !== null ? node : {};\n    var name;\n\n    if (typeof value.type === 'string') {\n      name = typeof value.tagName === 'string' ? value.tagName : typeof value.name === 'string' ? value.name : undefined;\n      visit.displayName = 'node (' + color(value.type + (name ? '<' + name + '>' : '')) + ')';\n    }\n\n    return visit;\n\n    function visit() {\n      var grandparents = parents.concat(node);\n      var result = [];\n      var subresult;\n      var offset;\n\n      if (!test || is(node, index, parents[parents.length - 1] || null)) {\n        result = toResult(visitor(node, parents));\n\n        if (result[0] === EXIT) {\n          return result;\n        }\n      }\n\n      if (node.children && result[0] !== SKIP) {\n        offset = (reverse ? node.children.length : -1) + step;\n\n        while (offset > -1 && offset < node.children.length) {\n          subresult = factory(node.children[offset], offset, grandparents)();\n\n          if (subresult[0] === EXIT) {\n            return subresult;\n          }\n\n          offset = typeof subresult[1] === 'number' ? subresult[1] : offset + step;\n        }\n      }\n\n      return result;\n    }\n  }\n}\n\nfunction toResult(value) {\n  if (value !== null && typeof value === 'object' && 'length' in value) {\n    return value;\n  }\n\n  if (typeof value === 'number') {\n    return [CONTINUE, value];\n  }\n\n  return [value];\n}","'use strict';\n\nmodule.exports = visit;\n\nvar visitParents = require('unist-util-visit-parents');\n\nvar CONTINUE = visitParents.CONTINUE;\nvar SKIP = visitParents.SKIP;\nvar EXIT = visitParents.EXIT;\nvisit.CONTINUE = CONTINUE;\nvisit.SKIP = SKIP;\nvisit.EXIT = EXIT;\n\nfunction visit(tree, test, visitor, reverse) {\n  if (typeof test === 'function' && typeof visitor !== 'function') {\n    reverse = visitor;\n    visitor = test;\n    test = null;\n  }\n\n  visitParents(tree, test, overload, reverse);\n\n  function overload(node, parents) {\n    var parent = parents[parents.length - 1];\n    var index = parent ? parent.children.indexOf(node) : null;\n    return visitor(node, index, parent);\n  }\n}","'use strict';\n\nvar stringify = require('unist-util-stringify-position');\n\nmodule.exports = VMessage; // Inherit from `Error#`.\n\nfunction VMessagePrototype() {}\n\nVMessagePrototype.prototype = Error.prototype;\nVMessage.prototype = new VMessagePrototype(); // Message properties.\n\nvar proto = VMessage.prototype;\nproto.file = '';\nproto.name = '';\nproto.reason = '';\nproto.message = '';\nproto.stack = '';\nproto.fatal = null;\nproto.column = null;\nproto.line = null; // 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.\n\nfunction VMessage(reason, position, origin) {\n  var parts;\n  var range;\n  var location;\n\n  if (typeof position === 'string') {\n    origin = position;\n    position = null;\n  }\n\n  parts = parseOrigin(origin);\n  range = stringify(position) || '1:1';\n  location = {\n    start: {\n      line: null,\n      column: null\n    },\n    end: {\n      line: null,\n      column: null\n    }\n  }; // Node.\n\n  if (position && position.position) {\n    position = position.position;\n  }\n\n  if (position) {\n    // Position.\n    if (position.start) {\n      location = position;\n      position = position.start;\n    } else {\n      // Point.\n      location.start = position;\n    }\n  }\n\n  if (reason.stack) {\n    this.stack = reason.stack;\n    reason = reason.message;\n  }\n\n  this.message = reason;\n  this.name = range;\n  this.reason = reason;\n  this.line = position ? position.line : null;\n  this.column = position ? position.column : null;\n  this.location = location;\n  this.source = parts[0];\n  this.ruleId = parts[1];\n}\n\nfunction parseOrigin(origin) {\n  var result = [null, null];\n  var index;\n\n  if (typeof origin === 'string') {\n    index = origin.indexOf(':');\n\n    if (index === -1) {\n      result[1] = origin;\n    } else {\n      result[0] = origin.slice(0, index);\n      result[1] = origin.slice(index + 1);\n    }\n  }\n\n  return result;\n}","'use strict';\n\nmodule.exports = require('./lib');","'use strict';\n\nvar p = require('./minpath');\n\nvar proc = require('./minproc');\n\nvar buffer = require('is-buffer');\n\nmodule.exports = VFile;\nvar own = {}.hasOwnProperty; // 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.\n\nvar order = ['history', 'path', 'basename', 'stem', 'extname', 'dirname'];\nVFile.prototype.toString = toString; // Access full path (`~/index.min.js`).\n\nObject.defineProperty(VFile.prototype, 'path', {\n  get: getPath,\n  set: setPath\n}); // Access parent path (`~`).\n\nObject.defineProperty(VFile.prototype, 'dirname', {\n  get: getDirname,\n  set: setDirname\n}); // Access basename (`index.min.js`).\n\nObject.defineProperty(VFile.prototype, 'basename', {\n  get: getBasename,\n  set: setBasename\n}); // Access extname (`.js`).\n\nObject.defineProperty(VFile.prototype, 'extname', {\n  get: getExtname,\n  set: setExtname\n}); // Access stem (`index.min`).\n\nObject.defineProperty(VFile.prototype, 'stem', {\n  get: getStem,\n  set: setStem\n}); // Construct a new file.\n\nfunction VFile(options) {\n  var prop;\n  var index;\n\n  if (!options) {\n    options = {};\n  } else if (typeof options === 'string' || buffer(options)) {\n    options = {\n      contents: options\n    };\n  } else if ('message' in options && 'messages' in options) {\n    return options;\n  }\n\n  if (!(this instanceof VFile)) {\n    return new VFile(options);\n  }\n\n  this.data = {};\n  this.messages = [];\n  this.history = [];\n  this.cwd = proc.cwd(); // Set path related properties in the correct order.\n\n  index = -1;\n\n  while (++index < order.length) {\n    prop = order[index];\n\n    if (own.call(options, prop)) {\n      this[prop] = options[prop];\n    }\n  } // Set non-path related properties.\n\n\n  for (prop in options) {\n    if (order.indexOf(prop) < 0) {\n      this[prop] = options[prop];\n    }\n  }\n}\n\nfunction getPath() {\n  return this.history[this.history.length - 1];\n}\n\nfunction setPath(path) {\n  assertNonEmpty(path, 'path');\n\n  if (this.path !== path) {\n    this.history.push(path);\n  }\n}\n\nfunction getDirname() {\n  return typeof this.path === 'string' ? p.dirname(this.path) : undefined;\n}\n\nfunction setDirname(dirname) {\n  assertPath(this.path, 'dirname');\n  this.path = p.join(dirname || '', this.basename);\n}\n\nfunction getBasename() {\n  return typeof this.path === 'string' ? p.basename(this.path) : undefined;\n}\n\nfunction setBasename(basename) {\n  assertNonEmpty(basename, 'basename');\n  assertPart(basename, 'basename');\n  this.path = p.join(this.dirname || '', basename);\n}\n\nfunction getExtname() {\n  return typeof this.path === 'string' ? p.extname(this.path) : undefined;\n}\n\nfunction setExtname(extname) {\n  assertPart(extname, 'extname');\n  assertPath(this.path, 'extname');\n\n  if (extname) {\n    if (extname.charCodeAt(0) !== 46\n    /* `.` */\n    ) {\n      throw new Error('`extname` must start with `.`');\n    }\n\n    if (extname.indexOf('.', 1) > -1) {\n      throw new Error('`extname` cannot contain multiple dots');\n    }\n  }\n\n  this.path = p.join(this.dirname, this.stem + (extname || ''));\n}\n\nfunction getStem() {\n  return typeof this.path === 'string' ? p.basename(this.path, this.extname) : undefined;\n}\n\nfunction setStem(stem) {\n  assertNonEmpty(stem, 'stem');\n  assertPart(stem, 'stem');\n  this.path = p.join(this.dirname || '', stem + (this.extname || ''));\n} // Get the value of the file.\n\n\nfunction toString(encoding) {\n  return (this.contents || '').toString(encoding);\n} // Assert that `part` is not a path (i.e., does not contain `p.sep`).\n\n\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} // Assert that `part` is not empty.\n\n\nfunction assertNonEmpty(part, name) {\n  if (!part) {\n    throw new Error('`' + name + '` cannot be empty');\n  }\n} // Assert `path` exists.\n\n\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');\n\nvar VFile = require('./core.js');\n\nmodule.exports = VFile;\nVFile.prototype.message = message;\nVFile.prototype.info = info;\nVFile.prototype.fail = fail; // Create a message with `reason` at `position`.\n// When an error is passed in as `reason`, copies the stack.\n\nfunction message(reason, position, origin) {\n  var message = new VMessage(reason, position, origin);\n\n  if (this.path) {\n    message.name = this.path + ':' + message.name;\n    message.file = this.path;\n  }\n\n  message.fatal = false;\n  this.messages.push(message);\n  return message;\n} // Fail: creates a vmessage, associates it with the file, and throws it.\n\n\nfunction fail() {\n  var message = this.message.apply(this, arguments);\n  message.fatal = true;\n  throw message;\n} // Info: creates a vmessage, associates it with the file, and marks the fatality\n// as null.\n\n\nfunction info() {\n  var message = this.message.apply(this, arguments);\n  message.fatal = null;\n  return message;\n}","'use strict'; // A derivative work based on:\n// <https://github.com/browserify/path-browserify>.\n// Which is licensed:\n//\n// MIT License\n//\n// Copyright (c) 2013 James Halliday\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy of\n// this software and associated documentation files (the \"Software\"), to deal in\n// the Software without restriction, including without limitation the rights to\n// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\n// the Software, and to permit persons to whom the Software is furnished to do so,\n// subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\n// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\n// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\n// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\n// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n// A derivative work based on:\n//\n// Parts of that are extracted from Node’s internal `path` module:\n// <https://github.com/nodejs/node/blob/master/lib/path.js>.\n// Which is licensed:\n//\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nexports.basename = basename;\nexports.dirname = dirname;\nexports.extname = extname;\nexports.join = join;\nexports.sep = '/';\n\nfunction basename(path, ext) {\n  var start = 0;\n  var end = -1;\n  var index;\n  var firstNonSlashEnd;\n  var seenNonSlash;\n  var extIndex;\n\n  if (ext !== undefined && typeof ext !== 'string') {\n    throw new TypeError('\"ext\" argument must be a string');\n  }\n\n  assertPath(path);\n  index = path.length;\n\n  if (ext === undefined || !ext.length || ext.length > path.length) {\n    while (index--) {\n      if (path.charCodeAt(index) === 47\n      /* `/` */\n      ) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now.\n        if (seenNonSlash) {\n          start = index + 1;\n          break;\n        }\n      } else if (end < 0) {\n        // We saw the first non-path separator, mark this as the end of our\n        // path component.\n        seenNonSlash = true;\n        end = index + 1;\n      }\n    }\n\n    return end < 0 ? '' : path.slice(start, end);\n  }\n\n  if (ext === path) {\n    return '';\n  }\n\n  firstNonSlashEnd = -1;\n  extIndex = ext.length - 1;\n\n  while (index--) {\n    if (path.charCodeAt(index) === 47\n    /* `/` */\n    ) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now.\n      if (seenNonSlash) {\n        start = index + 1;\n        break;\n      }\n    } else {\n      if (firstNonSlashEnd < 0) {\n        // We saw the first non-path separator, remember this index in case\n        // we need it if the extension ends up not matching.\n        seenNonSlash = true;\n        firstNonSlashEnd = index + 1;\n      }\n\n      if (extIndex > -1) {\n        // Try to match the explicit extension.\n        if (path.charCodeAt(index) === ext.charCodeAt(extIndex--)) {\n          if (extIndex < 0) {\n            // We matched the extension, so mark this as the end of our path\n            // component\n            end = index;\n          }\n        } else {\n          // Extension does not match, so our result is the entire path\n          // component\n          extIndex = -1;\n          end = firstNonSlashEnd;\n        }\n      }\n    }\n  }\n\n  if (start === end) {\n    end = firstNonSlashEnd;\n  } else if (end < 0) {\n    end = path.length;\n  }\n\n  return path.slice(start, end);\n}\n\nfunction dirname(path) {\n  var end;\n  var unmatchedSlash;\n  var index;\n  assertPath(path);\n\n  if (!path.length) {\n    return '.';\n  }\n\n  end = -1;\n  index = path.length; // Prefix `--` is important to not run on `0`.\n\n  while (--index) {\n    if (path.charCodeAt(index) === 47\n    /* `/` */\n    ) {\n      if (unmatchedSlash) {\n        end = index;\n        break;\n      }\n    } else if (!unmatchedSlash) {\n      // We saw the first non-path separator\n      unmatchedSlash = true;\n    }\n  }\n\n  return end < 0 ? path.charCodeAt(0) === 47\n  /* `/` */\n  ? '/' : '.' : end === 1 && path.charCodeAt(0) === 47\n  /* `/` */\n  ? '//' : path.slice(0, end);\n}\n\nfunction extname(path) {\n  var startDot = -1;\n  var startPart = 0;\n  var end = -1; // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find.\n\n  var preDotState = 0;\n  var unmatchedSlash;\n  var code;\n  var index;\n  assertPath(path);\n  index = path.length;\n\n  while (index--) {\n    code = path.charCodeAt(index);\n\n    if (code === 47\n    /* `/` */\n    ) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now.\n      if (unmatchedSlash) {\n        startPart = index + 1;\n        break;\n      }\n\n      continue;\n    }\n\n    if (end < 0) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension.\n      unmatchedSlash = true;\n      end = index + 1;\n    }\n\n    if (code === 46\n    /* `.` */\n    ) {\n      // If this is our first dot, mark it as the start of our extension.\n      if (startDot < 0) {\n        startDot = index;\n      } else if (preDotState !== 1) {\n        preDotState = 1;\n      }\n    } else if (startDot > -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension.\n      preDotState = -1;\n    }\n  }\n\n  if (startDot < 0 || end < 0 || // We saw a non-dot character immediately before the dot.\n  preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n    return '';\n  }\n\n  return path.slice(startDot, end);\n}\n\nfunction join() {\n  var index = -1;\n  var joined;\n\n  while (++index < arguments.length) {\n    assertPath(arguments[index]);\n\n    if (arguments[index]) {\n      joined = joined === undefined ? arguments[index] : joined + '/' + arguments[index];\n    }\n  }\n\n  return joined === undefined ? '.' : normalize(joined);\n} // Note: `normalize` is not exposed as `path.normalize`, so some code is\n// manually removed from it.\n\n\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\n  value = normalizeString(path, !absolute);\n\n  if (!value.length && !absolute) {\n    value = '.';\n  }\n\n  if (value.length && path.charCodeAt(path.length - 1) === 47\n  /* / */\n  ) {\n    value += '/';\n  }\n\n  return absolute ? '/' + value : value;\n} // Resolve `.` and `..` elements in a path with directory names.\n\n\nfunction normalizeString(path, allowAboveRoot) {\n  var result = '';\n  var lastSegmentLength = 0;\n  var lastSlash = -1;\n  var dots = 0;\n  var index = -1;\n  var code;\n  var lastSlashIndex;\n\n  while (++index <= path.length) {\n    if (index < path.length) {\n      code = path.charCodeAt(index);\n    } else if (code === 47\n    /* `/` */\n    ) {\n      break;\n    } else {\n      code = 47;\n      /* `/` */\n    }\n\n    if (code === 47\n    /* `/` */\n    ) {\n      if (lastSlash === index - 1 || dots === 1) {// Empty.\n      } else if (lastSlash !== index - 1 && dots === 2) {\n        if (result.length < 2 || lastSegmentLength !== 2 || result.charCodeAt(result.length - 1) !== 46\n        /* `.` */\n        || result.charCodeAt(result.length - 2) !== 46\n        /* `.` */\n        ) {\n          if (result.length > 2) {\n            lastSlashIndex = result.lastIndexOf('/');\n            /* istanbul ignore else - No clue how to cover it. */\n\n            if (lastSlashIndex !== result.length - 1) {\n              if (lastSlashIndex < 0) {\n                result = '';\n                lastSegmentLength = 0;\n              } else {\n                result = result.slice(0, lastSlashIndex);\n                lastSegmentLength = result.length - 1 - result.lastIndexOf('/');\n              }\n\n              lastSlash = index;\n              dots = 0;\n              continue;\n            }\n          } else if (result.length) {\n            result = '';\n            lastSegmentLength = 0;\n            lastSlash = index;\n            dots = 0;\n            continue;\n          }\n        }\n\n        if (allowAboveRoot) {\n          result = result.length ? result + '/..' : '..';\n          lastSegmentLength = 2;\n        }\n      } else {\n        if (result.length) {\n          result += '/' + path.slice(lastSlash + 1, index);\n        } else {\n          result = path.slice(lastSlash + 1, index);\n        }\n\n        lastSegmentLength = index - lastSlash - 1;\n      }\n\n      lastSlash = index;\n      dots = 0;\n    } else if (code === 46\n    /* `.` */\n    && dots > -1) {\n      dots++;\n    } else {\n      dots = -1;\n    }\n  }\n\n  return result;\n}\n\nfunction assertPath(path) {\n  if (typeof path !== 'string') {\n    throw new TypeError('Path must be a string. Received ' + JSON.stringify(path));\n  }\n}","'use strict'; // 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. 😅\n\nexports.cwd = cwd;\n\nfunction cwd() {\n  return '/';\n}","module.exports = extend;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nfunction extend() {\n  var target = {};\n\n  for (var i = 0; i < arguments.length; i++) {\n    var source = arguments[i];\n\n    for (var key in source) {\n      if (hasOwnProperty.call(source, key)) {\n        target[key] = source[key];\n      }\n    }\n  }\n\n  return target;\n}","export const translate = (language, german, english, simpleGerman) => {\n    if(language === \"german\") {\n        return german;\n}\nif(language === \"english\") {\n        return english;\n}\nif(language === \"simpleGerman\") {\n        return simpleGerman;\n}\n    \n} ","import React from \"react\"\nimport ReactMarkdown from 'react-markdown'\nimport slugger from 'slugger'\nimport gfm from 'remark-gfm'\n\nconst renderers = {\n    heading: props => {\n        const Tag = `h${Math.min(props.level + 1, 5)}`;\n        const text = props.node.children[0].value\n        return <Tag children={props.children} id={slugger(text)} />\n    },\n    link: props =>  {\n        return <a {...props} className=\"link\" />\n    }\n}\n\nconst renderersTitel = { ...renderers, paragraph: props => <>{props.children}</> }\n\nexport function renderMarkdown(text) {\n    return (\n        <div className=\"rendered-markdown\">\n        <ReactMarkdown renderers={renderers} plugins={[gfm]} children={text} linkTarget=\"_blank\" />\n        </div>\n    )\n}\n\nexport function renderMarkdownTitel(text) {\n    return (\n        <ReactMarkdown renderers={renderersTitel} plugins={[gfm]} children={text} linkTarget=\"_blank\" />\n    )\n}"],"names":["module","exports","err","source","character","index","value","String","count","Error","indexOf","length","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","newValue","writable","getProperty","extend","src","copy","copyIsArray","clone","arguments","i","deep","isBuffer","repeat","table","cells","columnIndex","columnLength","largest","size","cell","lines","line","before","after","code","settings","padding","start","delimiterStart","end","delimiterEnd","align","concat","alignDelimiters","alignments","stringLength","defaultStringLength","rowIndex","rowLength","cellMatrix","sizeMatrix","row","sizes","longestCellByColumn","mostCellsPerRow","undefined","push","toAlignment","colon","r","Math","max","splice","space","join","replace","trailingWhitespace","charCodeAt","visitWithParents","ast","listNode","parents","n","depth","type","children","child","ordered","tree","visitor","stack","one","node","result","parent","pop","all","find","schema","exec","search","handlerFactory","pairs","pair","handler","position","match","subhandler","nodes","lastIndex","apply","input","slice","global","unshift","toExpression","toFunction","toPairs","visit","convert","escape","ignored","ignore","grandparent","RegExp","string","TypeError","encoding","config","extensions","extension","configure","transforms","canContainEols","enter","autolink","opener","link","autolinkProtocol","onenterdata","autolinkEmail","atxHeading","heading","blockQuote","characterEscape","characterReference","codeFenced","codeFlow","codeFencedFenceInfo","buffer","codeFencedFenceMeta","codeIndented","codeText","codeTextData","data","codeFlowValue","definition","definitionDestinationString","definitionLabelString","definitionTitleString","emphasis","hardBreakEscape","hardBreak","hardBreakTrailing","htmlFlow","html","htmlFlowData","htmlText","htmlTextData","image","label","listItem","listItemValue","onenterlistitemvalue","listOrdered","list","onenterlistordered","listUnordered","paragraph","reference","onenterreference","referenceString","resourceDestinationString","resourceTitleString","setextHeading","strong","thematicBreak","exit","closer","atxHeadingSequence","onexitatxheadingsequence","onexitautolinkemail","onexitautolinkprotocol","characterEscapeValue","onexitdata","characterReferenceMarkerHexadecimal","onexitcharacterreferencemarker","characterReferenceMarkerNumeric","characterReferenceValue","onexitcharacterreferencevalue","onexitcodefenced","codeFencedFence","onexitcodefencedfence","onexitcodefencedfenceinfo","onexitcodefencedfencemeta","onexitcodeindented","onexitcodetext","onexitdefinitiondestinationstring","onexitdefinitionlabelstring","onexitdefinitiontitlestring","onexithardbreak","onexithtmlflow","onexithtmltext","onexitimage","onexitlabel","labelText","onexitlabeltext","lineEnding","onexitlineending","onexitlink","onexitreferencestring","onexitresourcedestinationstring","onexitresourcetitlestring","resource","onexitresource","onexitsetextheading","setextHeadingLineSequence","onexitsetextheadinglinesequence","setextHeadingText","onexitsetextheadingtext","mdastExtensions","compile","events","tokenStack","listStack","context","resume","setData","getData","prepareList","own","assign","sliceSerialize","stringifyPosition","point","column","offset","tailIndex","lineIndex","tailEvent","event","firstBlankLineIndex","atMarker","containerBalance","listSpread","_spread","d","create","and","open","token","this","close","parseInt","lang","meta","identifier","normalizeIdentifier","toLowerCase","title","url","siblings","tail","text","referenceType","fragment","alt","safeFromInt","decode","spread","checked","compiler","postprocess","parser","document","write","preprocessor","left","ccount","findAndReplace","unicodePunctuation","unicodeWhitespace","enterLiteralAutolinkValue","findUrl","$0","protocol","domain","path","parts","prefix","previous","test","split","isCorrectDomain","closingParenIndex","openingParens","closingParens","trail","splitUrl","findEmail","atext","email","literalAutolink","literalAutolinkEmail","literalAutolinkHttp","literalAutolinkWww","inConstruct","notInConstruct","unsafe","strikethrough","phrasing","handleDelete","_","handlers","delete","peek","enterCell","$1","_align","tableData","tableHeader","tableRow","defaultInlineCode","markdownTable","tableCellPadding","tablePipeAlign","around","atBreak","serializeData","subexit","handleTableRowAsData","handleTableAsData","tableCell","handleTableCell","inlineCode","matrix","exitCheck","taskListCheckValueChecked","taskListCheckValueUnchecked","firstParaghraph","head","shift","defaultListItem","autolinkLiteral","taskListItem","right","base","patternCompile","pattern","expression","sequence","charAt","bullet","checkBullet","listItemIndent","checkListItemIndent","incrementListMarker","ceil","indentLines","flow","blank","marker","style","results","handle","between","Number","safeOptions","map","eol","_compiled","values","asciiAlpha","asciiAlphanumeric","asciiControl","markdownLineEnding","www","tokenize","effects","ok","nok","consume","w2","w3","dot","partial","hasUnderscoreInLastSegment","hasUnderscoreInLastLastSegment","check","namedCharacterReference","done","punctuationContinuation","punctuation","balance","inPath","continuedPunctuation","paren","parenAtPathEnd","pathEnd","trailingPunctuation","inside","wwwAutolink","self","previousWww","attempt","httpAutolink","previousHttp","t1","t2","p","s","slash1","slash2","emailAutolink","hasDot","gfmAtext","previousEmail","dotContinuation","dashOrUnderscoreContinuation","afterDashOrUnderscore","_balanced","single","singleTilde","tokenizer","more","classifyCharacter","_open","_close","resolveAll","nextEvents","shallow","chunkedSplice","constructs","insideSpan","null","removeRemainingSequences","seenDelimiter","hasDash","tableHeaderCount","cellDividerHead","inCellContentHead","cellBreakHead","setextUnderlineMini","createSpace","rowStartDelimiter","atRowEndHead","inWhitespaceHead","inCellContentEscapeHead","atDelimiterRowBreak","rowEndDelimiter","inWhitespaceDelimiter","inFillerDelimiter","afterLeftAlignment","afterRightAlignment","tableClose","nextPrefixedOrBlank","tableContinue","bodyStart","rowStartBody","cellDividerBody","inCellContentBody","cellBreakBody","tableBodyClose","tableBodyContinue","atRowEndBody","inWhitespaceBody","inCellContentEscapeBody","resolve","inHead","inDelimiterRow","inRow","content","contentStart","contentEnd","cellStart","contentType","interruptible","whitespace","markdownLineEndingOrSpace","spaceFactory","prefixSize","tasklistCheck","_gfmTasklistFirstContentOfListItem","spaceThenNonSpace","combine","tasklist","regexCheck","asciiAtext","asciiDigit","asciiHexDigit","asciiPunctuation","unicodePunctuationRegex","fromCharCode","text$1","attention","headingAtx","labelEnd","labelStartImage","labelStartLink","setextUnderline","contentInitial","flowInitial","resolver","disable","factorySpace","lineStart","next","partialBlankLine","inspectResult","childFlow","childToken","continued","inspectConstruct","subcontinued","inspectStart","containerState","continuation","inspectContinue","inspectLess","currentConstruct","concrete","flowContinue","inspectDone","interrupt","containerConstruct","inspectFlowEnd","_closeFlow","lazy","lazyFlowConstruct","inspectLazy","flowEnd","documentContinue","documentContinued","flowStart","containerContinue","exitContainers","now","_tokenizer","continueFlow","documentAfterPeek","defineSkip","sliceStream","initial","afterConstruct","initializeFactory","createResolver","field","notText","resolveAllLineSuffixes","extraResolver","chunks","chunk","bufferIndex","tabs","eventIndex","_index","_bufferIndex","combineExtensions","createTokenizer","miniflat","defined","initializer","from","subtokenize","atCarriageReturn","startPosition","endPosition","chunkedPush","movePoint","group","openingSequence","closingSequence","use","schemeOrEmailAtext","emailAtext","schemeInsideOrEmailAtext","urlInside","emailAtSignOrDot","emailLabel","emailValue","markdownSpace","_container","decodeEntity","_interopDefaultLegacy","e","default","decodeEntity__default","numeric","closingFenceConstruct","closingSequenceStart","sizeOpen","closingSequenceEnd","initialPrefix","sequenceOpen","infoOpen","openAfter","info","infoAfter","contentContinue","indentedContentConstruct","afterPrefix","gap","tailExitIndex","headEnterIndex","continuationConstruct","prefixed","factoryDestination","factoryLabel","factoryWhitespace","factoryTitle","labelAfter","titleConstruct","literalType","literalMarkerType","rawType","stringType","limit","Infinity","destinationEnclosedBefore","destinationRaw","destinationEnclosed","destinationEnclosedEscape","destinationRawEscape","markerType","labelEscape","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","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","_inactive","balanced","afterLabelEnd","resourceConstruct","fullReferenceConstruct","collapsedReferenceConstruct","media","_used","destinationAfter","afterLabel","sizeChunks","initialSize","onBlank","listItemPrefixWhitespaceConstruct","endOfPrefix","otherPrefix","initialBlankLine","furtherBlankLines","notInCurrentItem","indentConstruct","items","remove","parameters","chunkStart","hook","existing","add","serializeChunks","sliceChunks","initialize","columnStart","resolveAllConstructs","accountForPotentialSkip","fields","constructFactory","construct","addResult","onsuccessfulcheck","main","state","chunkIndex","go","restore","onreturn","bogusState","listOfConstructs","constructIndex","handleListOfConstructs","handleConstruct","startPoint","startPrevious","startCurrentConstruct","startEventsIndex","startStack","store","toUpperCase","regex","called","atTab","object","view","startIndex","startBufferIndex","endIndex","endBufferIndex","subcontent","stream","entered","adjust","startPositions","childEvents","jumps","gaps","isInFirstContentOfListItem","otherIndex","otherEvent","subevents","_movePreviousLineEndings","el","characters","char","entity","createElement","innerHTML","textContent","b","Symbol","for","c","f","g","h","k","l","m","q","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","renderer","renderers","pos","nodeProps","getNodeProps","resolveChildren","childNode","props","opts","isSimpleRenderer","sourcePos","rawSourcePos","sourcePosition","includeNodeIndex","parentChildCount","ref","definitions","assignDefined","className","nodeKey","level","loose","listItemLoose","listLoose","reduce","array","unwrapParagraphs","getListItemChildren","language","inline","linkTarget","href","transformLinkUri","transformImageUri","columnAlignment","isHeader","tag","isBlock","allowDangerousHtml","escapeHtml","skipHtml","parsedChildren","element","Children","toArray","cloneElement","mergeNodeChildren","attrs","ifNotMatch","allow","mode","filter","ofType","types","includes","selfClosingRe","simpleTagRe","currentParent","selfClosing","getSelfClosing","current","opening","getSimpleTag","matching","matchingTag","findAndPull","fromNode","toNode","fromIndex","toIndex","indent","virtual","unified","parse","PropTypes","addListMetadata","naiveHtml","disallowNode","wrapTableRows","getDefinitions","uriTransformer","defaultRenderers","symbols","allTypes","keys","ReactMarkdown","allowedTypes","disallowedTypes","processor","plugins","runSync","renderProps","removalMethod","unwrapDisallowed","allowNode","renderHtml","hasHtmlParser","astPlugins","some","transform","identity","HtmlParser","determineAstToReactTransforms","forEach","defaultProps","propTypes","bool","func","arrayOf","oneOf","oneOfType","supportsStringRender","version","SimpleRenderer","getCoreProps","break","blockquote","linkReference","imageReference","bind","tableHead","tableBody","textAlign","coreProps","root","checkbox","readOnly","dangerous","dangerouslySetInnerHTML","__html","virtualHtml","parsedHtml","protocols","uri","trim","first","wrap","getPrototypeOf","Parser","doc","fromMarkdown","bail","plain","trough","vfile","frozen","attachers","transformers","namespace","freezeIndex","assertUnfrozen","freeze","addPlugin","addList","addPreset","plugin","entry","file","assertParser","newable","stringify","Compiler","assertCompiler","assertNode","run","complete","assertDone","error","process","processSync","destination","transformer","cb","Promise","executor","reject","pipeline","ctx","contents","asyncName","warningIssued","syntax","toMarkdown","blockTokenizers","visitors","console","warn","cache","res","str","num","substr","allowedCharacters","alsoAllow","lucky","re","maintainCase","replacement","smartTrim","decodeURIComponent","lastIndexOf","fns","middleware","fn","params","callback","invoked","then","Boolean","typeFactory","tests","checks","any","anyFactory","allFactory","visitParents","color","CONTINUE","SKIP","EXIT","reverse","step","is","factory","displayName","subresult","grandparents","toResult","VMessagePrototype","VMessage","proto","reason","origin","range","location","parseOrigin","message","ruleId","fatal","proc","VFile","order","prop","messages","history","cwd","assertPart","part","sep","assertNonEmpty","assertPath","get","set","dirname","basename","extname","stem","fail","normalize","absolute","allowAboveRoot","lastSlashIndex","lastSegmentLength","lastSlash","dots","normalizeString","JSON","ext","firstNonSlashEnd","seenNonSlash","extIndex","unmatchedSlash","startDot","startPart","preDotState","joined","translate","german","english","simpleGerman","Tag","min","id","slugger","renderersTitel","renderMarkdown","gfm","renderMarkdownTitel"],"sourceRoot":""}