@readme/markdown 6.63.0 → 6.64.0

package/dist/main.js

@@ -115,7 +115,7 @@ var h = __webpack_require__(1742);
 var find = __webpack_require__(9560);
 var html = __webpack_require__(7247);
 var svg = __webpack_require__(1218);
-var vfileLocation = __webpack_require__(6976);
+var vfileLocation = __webpack_require__(4787);
 var ns = __webpack_require__(6);
 module.exports = wrapper;
 var own = {}.hasOwnProperty;
@@ -312,59 +312,6 @@ function point(point) {
 
 /***/ }),
 
-/***/ 6976:
-/***/ ((module) => {
-
-"use strict";
-
-
-module.exports = factory;
-function factory(file) {
-  var value = String(file);
-  var indices = [];
-  var search = /\r?\n|\r/g;
-  while (search.exec(value)) {
-    indices.push(search.lastIndex);
-  }
-  indices.push(value.length + 1);
-  return {
-    toPoint: offsetToPoint,
-    toPosition: offsetToPoint,
-    toOffset: pointToOffset
-  };
-
-  // Get the line and column-based `point` for `offset` in the bound indices.
-  function offsetToPoint(offset) {
-    var index = -1;
-    if (offset > -1 && offset < indices[indices.length - 1]) {
-      while (++index < indices.length) {
-        if (indices[index] > offset) {
-          return {
-            line: index + 1,
-            column: offset - (indices[index - 1] || 0) + 1,
-            offset: offset
-          };
-        }
-      }
-    }
-    return {};
-  }
-
-  // Get the `offset` for a line and column-based `point` in the bound
-  // indices.
-  function pointToOffset(point) {
-    var line = point && point.line;
-    var column = point && point.column;
-    var offset;
-    if (!isNaN(line) && !isNaN(column) && line - 1 in indices) {
-      offset = (indices[line - 2] || 0) + column - 1 || 0;
-    }
-    return offset > -1 && offset < indices[indices.length - 1] ? offset : -1;
-  }
-}
-
-/***/ }),
-
 /***/ 8335:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
@@ -8643,7 +8590,10 @@ module.exports = function CodeTabsCompiler() {
   var Compiler = this.Compiler;
   var visitors = Compiler.prototype.visitors;
   function compile(node) {
-    return this.block(node).split('```\n\n').join('```\n');
+    var fence = '```';
+    return node.children.map(function (code) {
+      return "".concat(fence).concat(code.lang || '').concat(code.meta ? " ".concat(code.meta) : '', "\n").concat(code.value ? "".concat(code.value, "\n") : '').concat(fence);
+    }).join('\n');
   }
   visitors['code-tabs'] = compile;
 };
@@ -9001,8 +8951,6 @@ function tokenizer(eat, value) {
     hash = _rgx$exec2[1],
     text = _rgx$exec2[2];
   var now = eat.now();
-  now.column += match.length;
-  now.offset += match.length;
   return eat(match)({
     type: 'heading',
     depth: hash.length,
@@ -9320,8 +9268,8 @@ function parser() {
   var Parser = this.Parser;
   var tokenizers = Parser.prototype.blockTokenizers;
   var methods = Parser.prototype.blockMethods;
-  tokenizers.CodeTabs = tokenizer;
-  methods.splice(methods.indexOf('newline'), 0, 'CodeTabs');
+  tokenizers.codeTabs = tokenizer;
+  methods.splice(methods.indexOf('indentedCode') - 1, 0, 'codeTabs');
 }
 module.exports = parser;
 module.exports.sanitize = function (sanitizeSchema) {
@@ -11879,60 +11827,6 @@ exports.doubleQuotesEscapeChars = {
 };
 
 
-/***/ }),
-
-/***/ 3128:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-"use strict";
-
-
-module.exports = detab
-
-var repeat = __webpack_require__(6464)
-
-var tab = 0x09
-var lineFeed = 0x0a
-var carriageReturn = 0x0d
-
-// Replace tabs with spaces, being smart about which column the tab is at and
-// which size should be used.
-function detab(value, size) {
-  var string = typeof value === 'string'
-  var length = string && value.length
-  var start = 0
-  var index = -1
-  var column = -1
-  var tabSize = size || 4
-  var results = []
-  var code
-  var add
-
-  if (!string) {
-    throw new Error('detab expected string')
-  }
-
-  while (++index < length) {
-    code = value.charCodeAt(index)
-
-    if (code === tab) {
-      add = tabSize - ((column + 1) % tabSize)
-      column += add
-      results.push(value.slice(start, index) + repeat(' ', add))
-      start = index + 1
-    } else if (code === lineFeed || code === carriageReturn) {
-      column = -1
-    } else {
-      column++
-    }
-  }
-
-  results.push(value.slice(start))
-
-  return results.join('')
-}
-
-
 /***/ }),
 
 /***/ 4470:
@@ -16415,27 +16309,23 @@ function getDefinitionFactory(node, options) {
 }
 
 // Gather all definitions in `node`
-function gather(node, options) {
+function gather(node) {
   var cache = {}
 
   if (!node || !node.type) {
     throw new Error('mdast-util-definitions expected node')
   }
 
-  visit(node, 'definition', options && options.commonmark ? commonmark : normal)
+  visit(node, 'definition', ondefinition)
 
   return cache
 
-  function commonmark(definition) {
+  function ondefinition(definition) {
     var id = normalise(definition.identifier)
     if (!own.call(cache, id)) {
       cache[id] = definition
     }
   }
-
-  function normal(definition) {
-    cache[normalise(definition.identifier)] = definition
-  }
 }
 
 // Factory to get a node from the given definition-cache.
@@ -16862,19 +16752,27 @@ function hardBreak(h, node) {
 
 module.exports = code
 
-var detab = __webpack_require__(3128)
 var u = __webpack_require__(914)
 
 function code(h, node) {
-  var value = node.value ? detab(node.value + '\n') : ''
+  var value = node.value ? node.value + '\n' : ''
+  // To do: next major, use `node.lang` w/o regex, the splitting’s been going
+  // on for years in remark now.
   var lang = node.lang && node.lang.match(/^[^ \t]+(?=[ \t]|$)/)
   var props = {}
+  var code
 
   if (lang) {
     props.className = ['language-' + lang]
   }
 
-  return h(node.position, 'pre', [h(node, 'code', props, [u('text', value)])])
+  code = h(node, 'code', props, [u('text', value)])
+
+  if (node.meta) {
+    code.data = {meta: node.meta}
+  }
+
+  return h(node.position, 'pre', [code])
 }
 
 
@@ -17124,11 +17022,11 @@ function ignore() {
 
 module.exports = inlineCode
 
-var collapse = __webpack_require__(9357)
 var u = __webpack_require__(914)
 
 function inlineCode(h, node) {
-  return h(node, 'code', [u('text', collapse(node.value))])
+  var value = node.value.replace(/\r?\n|\r/g, ' ')
+  return h(node, 'code', [u('text', value)])
 }
 
 
@@ -17199,52 +17097,29 @@ function link(h, node) {
 module.exports = listItem
 
 var u = __webpack_require__(914)
-var wrap = __webpack_require__(2931)
 var all = __webpack_require__(5426)
 
 function listItem(h, node, parent) {
-  var children = node.children
-  var head = children[0]
-  var raw = all(h, node)
+  var result = all(h, node)
+  var head = result[0]
   var loose = parent ? listLoose(parent) : listItemLoose(node)
   var props = {}
-  var result
-  var container
-  var index
+  var wrapped = []
   var length
+  var index
   var child
 
-  // Tight lists should not render `paragraph` nodes as `p` elements.
-  if (loose) {
-    result = raw
-  } else {
-    result = []
-    length = raw.length
-    index = -1
-
-    while (++index < length) {
-      child = raw[index]
-
-      if (child.tagName === 'p') {
-        result = result.concat(child.children)
-      } else {
-        result.push(child)
-      }
-    }
-  }
-
   if (typeof node.checked === 'boolean') {
-    if (loose && (!head || head.type !== 'paragraph')) {
-      result.unshift(h(null, 'p', []))
+    if (!head || head.tagName !== 'p') {
+      head = h(null, 'p', [])
+      result.unshift(head)
     }
 
-    container = loose ? result[0].children : result
-
-    if (container.length !== 0) {
-      container.unshift(u('text', ' '))
+    if (head.children.length > 0) {
+      head.children.unshift(u('text', ' '))
     }
 
-    container.unshift(
+    head.children.unshift(
       h(null, 'input', {
         type: 'checkbox',
         checked: node.checked,
@@ -17257,11 +17132,30 @@ function listItem(h, node, parent) {
     props.className = ['task-list-item']
   }
 
-  if (loose && result.length !== 0) {
-    result = wrap(result, true)
+  length = result.length
+  index = -1
+
+  while (++index < length) {
+    child = result[index]
+
+    // Add eols before nodes, except if this is a loose, first paragraph.
+    if (loose || index !== 0 || child.tagName !== 'p') {
+      wrapped.push(u('text', '\n'))
+    }
+
+    if (child.tagName === 'p' && !loose) {
+      wrapped = wrapped.concat(child.children)
+    } else {
+      wrapped.push(child)
+    }
+  }
+
+  // Add a final eol.
+  if (length && (loose || child.tagName !== 'p')) {
+    wrapped.push(u('text', '\n'))
   }
 
-  return h(node, 'li', props, result)
+  return h(node, 'li', props, wrapped)
 }
 
 function listLoose(node) {
@@ -17398,7 +17292,7 @@ var all = __webpack_require__(5426)
 function table(h, node) {
   var rows = node.children
   var index = rows.length
-  var align = node.align
+  var align = node.align || []
   var alignLength = align.length
   var result = []
   var pos
@@ -17410,7 +17304,7 @@ function table(h, node) {
   while (index--) {
     row = rows[index].children
     name = index === 0 ? 'th' : 'td'
-    pos = alignLength
+    pos = alignLength || row.length
     out = []
 
     while (pos--) {
@@ -17425,17 +17319,18 @@ function table(h, node) {
     node,
     'table',
     wrap(
-      [
-        h(result[0].position, 'thead', wrap([result[0]], true)),
-        h(
-          {
-            start: position.start(result[1]),
-            end: position.end(result[result.length - 1])
-          },
-          'tbody',
-          wrap(result.slice(1), true)
-        )
-      ],
+      [h(result[0].position, 'thead', wrap([result[0]], true))].concat(
+        result[1]
+          ? h(
+              {
+                start: position.start(result[1]),
+                end: position.end(result[result.length - 1])
+              },
+              'tbody',
+              wrap(result.slice(1), true)
+            )
+          : []
+      ),
       true
     )
   )
@@ -17453,10 +17348,12 @@ function table(h, node) {
 module.exports = text
 
 var u = __webpack_require__(914)
-var trimLines = __webpack_require__(6221)
 
 function text(h, node) {
-  return h.augment(node, u('text', trimLines(node.value)))
+  return h.augment(
+    node,
+    u('text', String(node.value).replace(/[ \t]*(\r?\n|\r)[ \t]*/g, '$1'))
+  )
 }
 
 
@@ -17514,12 +17411,13 @@ function factory(tree, options) {
   var footnoteById = {}
 
   h.dangerous = dangerous
-  h.definition = definitions(tree, settings)
+  h.definition = definitions(tree)
   h.footnoteById = footnoteById
   h.footnoteOrder = []
   h.augment = augment
   h.handlers = Object.assign({}, handlers, settings.handlers)
   h.unknownHandler = settings.unknownHandler
+  h.passThrough = settings.passThrough
 
   visit(tree, 'footnoteDefinition', onfootnotedefinition)
 
@@ -17531,10 +17429,19 @@ function factory(tree, options) {
     var ctx
 
     // Handle `data.hName`, `data.hProperties, `data.hChildren`.
-    if (left && 'data' in left) {
+    if (left && left.data) {
       data = left.data
 
-      if (right.type === 'element' && data.hName) {
+      if (data.hName) {
+        if (right.type !== 'element') {
+          right = {
+            type: 'element',
+            tagName: '',
+            properties: {},
+            children: []
+          }
+        }
+
         right.tagName = data.hName
       }
 
@@ -17582,7 +17489,7 @@ function factory(tree, options) {
     var id = String(definition.identifier).toUpperCase()
 
     // Mimick CM behavior of link definitions.
-    // See: <https://github.com/syntax-tree/mdast-util-definitions/blob/8d48e57/index.js#L26>.
+    // See: <https://github.com/syntax-tree/mdast-util-definitions/blob/8290999/index.js#L26>.
     if (!own.call(footnoteById, id)) {
       footnoteById[id] = definition
     }
@@ -17630,13 +17537,21 @@ function unknown(h, node) {
 // Visit a node.
 function one(h, node, parent) {
   var type = node && node.type
-  var fn = own.call(h.handlers, type) ? h.handlers[type] : h.unknownHandler
+  var fn
 
   // Fail on non-nodes.
   if (!type) {
     throw new Error('Expected node, got `' + node + '`')
   }
 
+  if (own.call(h.handlers, type)) {
+    fn = h.handlers[type]
+  } else if (h.passThrough && h.passThrough.indexOf(type) > -1) {
+    fn = returnNode
+  } else {
+    fn = h.unknownHandler
+  }
+
   return (typeof fn === 'function' ? fn : unknown)(h, node, parent)
 }
 
@@ -17655,6 +17570,18 @@ function text(node) {
   return 'value' in node
 }
 
+function returnNode(h, node) {
+  var clone
+
+  if (node.children) {
+    clone = Object.assign({}, node)
+    clone.children = all(h, node)
+    return clone
+  }
+
+  return node
+}
+
 
 /***/ }),
 
@@ -17739,7 +17666,7 @@ function wrap(nodes, loose) {
     result.push(nodes[index])
   }
 
-  if (loose && nodes.length !== 0) {
+  if (loose && nodes.length > 0) {
     result.push(u('text', '\n'))
   }
 
@@ -18952,15 +18879,15 @@ var defaults = {
 // Characters.
 var tab = 9 // '\t'
 var lineFeed = 10 // '\n'
-var formFeed = 12 //  '\f'
+var formFeed = 12 // '\f'
 var space = 32 // ' '
-var ampersand = 38 //  '&'
-var semicolon = 59 //  ';'
-var lessThan = 60 //  '<'
-var equalsTo = 61 //  '='
-var numberSign = 35 //  '#'
-var uppercaseX = 88 //  'X'
-var lowercaseX = 120 //  'x'
+var ampersand = 38 // '&'
+var semicolon = 59 // ';'
+var lessThan = 60 // '<'
+var equalsTo = 61 // '='
+var numberSign = 35 // '#'
+var uppercaseX = 88 // 'X'
+var lowercaseX = 120 // 'x'
 var replacementCharacter = 65533 // '�'
 
 // Reference types.
@@ -19082,7 +19009,8 @@ function parse(value, settings) {
   // Wrap `handleWarning`.
   warning = handleWarning ? parseError : noop
 
-  // Ensure the algorithm walks over the first character and the end (inclusive).
+  // Ensure the algorithm walks over the first character and the end
+  // (inclusive).
   index--
   length++
 
@@ -19315,7 +19243,7 @@ function parse(value, settings) {
     }
   }
 
-  // Return the reduced nodes, and any possible warnings.
+  // Return the reduced nodes.
   return result.join('')
 
   // Get current position.
@@ -21929,7 +21857,6 @@ module.exports = {
   position: true,
   gfm: true,
   commonmark: false,
-  footnotes: false,
   pedantic: false,
   blocks: __webpack_require__(8829)
 }
@@ -21990,6 +21917,65 @@ function locate(value, fromIndex) {
 }
 
 
+/***/ }),
+
+/***/ 858:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+var decimal = __webpack_require__(6195)
+var alphabetical = __webpack_require__(6260)
+
+var plusSign = 43 // '+'
+var dash = 45 // '-'
+var dot = 46 // '.'
+var underscore = 95 // '_'
+
+module.exports = locate
+
+// See: <https://github.github.com/gfm/#extended-email-autolink>
+function locate(value, fromIndex) {
+  var self = this
+  var at
+  var position
+
+  if (!this.options.gfm) {
+    return -1
+  }
+
+  at = value.indexOf('@', fromIndex)
+
+  if (at === -1) {
+    return -1
+  }
+
+  position = at
+
+  if (position === fromIndex || !isGfmAtext(value.charCodeAt(position - 1))) {
+    return locate.call(self, value, at + 1)
+  }
+
+  while (position > fromIndex && isGfmAtext(value.charCodeAt(position - 1))) {
+    position--
+  }
+
+  return position
+}
+
+function isGfmAtext(code) {
+  return (
+    decimal(code) ||
+    alphabetical(code) ||
+    code === plusSign ||
+    code === dash ||
+    code === dot ||
+    code === underscore
+  )
+}
+
+
 /***/ }),
 
 /***/ 6131:
@@ -22106,22 +22092,25 @@ function locate(value, fromIndex) {
 
 module.exports = locate
 
-var protocols = ['https://', 'http://', 'mailto:']
+var values = ['www.', 'http://', 'https://']
 
 function locate(value, fromIndex) {
-  var length = protocols.length
-  var index = -1
   var min = -1
+  var index
+  var length
   var position
 
   if (!this.options.gfm) {
-    return -1
+    return min
   }
 
+  length = values.length
+  index = -1
+
   while (++index < length) {
-    position = value.indexOf(protocols[index], fromIndex)
+    position = value.indexOf(values[index], fromIndex)
 
-    if (position !== -1 && (position < min || min === -1)) {
+    if (position !== -1 && (min === -1 || position < min)) {
       min = position
     }
   }
@@ -22238,13 +22227,13 @@ proto.enterBlock = toggle('inBlock', false)
 // In the above example, the thematic break “interupts” the paragraph.
 proto.interruptParagraph = [
   ['thematicBreak'],
+  ['list'],
   ['atxHeading'],
   ['fencedCode'],
   ['blockquote'],
   ['html'],
   ['setextHeading', {commonmark: false}],
-  ['definition', {commonmark: false}],
-  ['footnote', {commonmark: false}]
+  ['definition', {commonmark: false}]
 ]
 
 // Nodes that can interupt a list:
@@ -22259,8 +22248,7 @@ proto.interruptList = [
   ['atxHeading', {pedantic: false}],
   ['fencedCode', {pedantic: false}],
   ['thematicBreak', {pedantic: false}],
-  ['definition', {commonmark: false}],
-  ['footnote', {commonmark: false}]
+  ['definition', {commonmark: false}]
 ]
 
 // Nodes that can interupt a blockquote:
@@ -22279,13 +22267,12 @@ proto.interruptBlockquote = [
   ['thematicBreak', {commonmark: true}],
   ['html', {commonmark: true}],
   ['list', {commonmark: true}],
-  ['definition', {commonmark: false}],
-  ['footnote', {commonmark: false}]
+  ['definition', {commonmark: false}]
 ]
 
 // Handlers.
 proto.blockTokenizers = {
-  newline: __webpack_require__(3885),
+  blankLine: __webpack_require__(8086),
   indentedCode: __webpack_require__(1018),
   fencedCode: __webpack_require__(4967),
   blockquote: __webpack_require__(1153),
@@ -22294,7 +22281,6 @@ proto.blockTokenizers = {
   list: __webpack_require__(8332),
   setextHeading: __webpack_require__(6530),
   html: __webpack_require__(5215),
-  footnote: __webpack_require__(8574),
   definition: __webpack_require__(856),
   table: __webpack_require__(8029),
   paragraph: __webpack_require__(2431)
@@ -22304,6 +22290,7 @@ proto.inlineTokenizers = {
   escape: __webpack_require__(4833),
   autoLink: __webpack_require__(6507),
   url: __webpack_require__(5044),
+  email: __webpack_require__(1834),
   html: __webpack_require__(3943),
   link: __webpack_require__(8685),
   reference: __webpack_require__(7551),
@@ -22532,6 +22519,57 @@ function autoLink(eat, value, silent) {
 }
 
 
+/***/ }),
+
+/***/ 8086:
+/***/ ((module) => {
+
+"use strict";
+
+
+// A line containing no characters, or a line containing only spaces (U+0020) or
+// tabs (U+0009), is called a blank line.
+// See <https://spec.commonmark.org/0.29/#blank-line>.
+var reBlankLine = /^[ \t]*(\n|$)/
+
+// Note that though blank lines play a special role in lists to determine
+// whether the list is tight or loose
+// (<https://spec.commonmark.org/0.29/#blank-lines>), it’s done by the list
+// tokenizer and this blank line tokenizer does not have to be responsible for
+// that.
+// Therefore, configs such as `blankLine.notInList` do not have to be set here.
+module.exports = blankLine
+
+function blankLine(eat, value, silent) {
+  var match
+  var subvalue = ''
+  var index = 0
+  var length = value.length
+
+  while (index < length) {
+    match = reBlankLine.exec(value.slice(index))
+
+    if (match == null) {
+      break
+    }
+
+    index += match[0].length
+    subvalue += match[0]
+  }
+
+  if (subvalue === '') {
+    return
+  }
+
+  /* istanbul ignore if - never used (yet) */
+  if (silent) {
+    return true
+  }
+
+  eat(subvalue)
+}
+
+
 /***/ }),
 
 /***/ 1153:
@@ -23547,6 +23585,128 @@ function strikethrough(eat, value, silent) {
 }
 
 
+/***/ }),
+
+/***/ 1834:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+var decode = __webpack_require__(7574)
+var decimal = __webpack_require__(6195)
+var alphabetical = __webpack_require__(6260)
+var locate = __webpack_require__(858)
+
+module.exports = email
+email.locator = locate
+email.notInLink = true
+
+var plusSign = 43 // '+'
+var dash = 45 // '-'
+var dot = 46 // '.'
+var atSign = 64 // '@'
+var underscore = 95 // '_'
+
+function email(eat, value, silent) {
+  var self = this
+  var gfm = self.options.gfm
+  var tokenizers = self.inlineTokenizers
+  var index = 0
+  var length = value.length
+  var firstDot = -1
+  var code
+  var content
+  var children
+  var exit
+
+  if (!gfm) {
+    return
+  }
+
+  code = value.charCodeAt(index)
+
+  while (
+    decimal(code) ||
+    alphabetical(code) ||
+    code === plusSign ||
+    code === dash ||
+    code === dot ||
+    code === underscore
+  ) {
+    code = value.charCodeAt(++index)
+  }
+
+  if (index === 0) {
+    return
+  }
+
+  if (code !== atSign) {
+    return
+  }
+
+  index++
+
+  while (index < length) {
+    code = value.charCodeAt(index)
+
+    if (
+      decimal(code) ||
+      alphabetical(code) ||
+      code === dash ||
+      code === dot ||
+      code === underscore
+    ) {
+      index++
+
+      if (firstDot === -1 && code === dot) {
+        firstDot = index
+      }
+
+      continue
+    }
+
+    break
+  }
+
+  if (
+    firstDot === -1 ||
+    firstDot === index ||
+    code === dash ||
+    code === underscore
+  ) {
+    return
+  }
+
+  if (code === dot) {
+    index--
+  }
+
+  content = value.slice(0, index)
+
+  /* istanbul ignore if - never used (yet) */
+  if (silent) {
+    return true
+  }
+
+  exit = self.enterLink()
+
+  // Temporarily remove all tokenizers except text in url.
+  self.inlineTokenizers = {text: tokenizers.text}
+  children = self.tokenizeInline(content, eat.now())
+  self.inlineTokenizers = tokenizers
+
+  exit()
+
+  return eat(content)({
+    type: 'link',
+    title: null,
+    url: 'mailto:' + decode(content, {nonTerminated: false}),
+    children: children
+  })
+}
+
+
 /***/ }),
 
 /***/ 8210:
@@ -23577,7 +23737,7 @@ function emphasis(eat, value, silent) {
   var queue
   var subvalue
   var length
-  var prev
+  var previous
 
   if (character !== asterisk && character !== underscore) {
     return
@@ -23596,14 +23756,14 @@ function emphasis(eat, value, silent) {
   }
 
   while (index < length) {
-    prev = character
+    previous = character
     character = value.charAt(index)
 
-    if (character === marker && (!pedantic || !whitespace(prev))) {
+    if (character === marker && (!pedantic || !whitespace(previous))) {
       character = value.charAt(++index)
 
       if (character !== marker) {
-        if (!trim(queue) || prev === marker) {
+        if (!trim(queue) || previous === marker) {
           return
         }
 
@@ -23683,200 +23843,6 @@ function escape(eat, value, silent) {
 }
 
 
-/***/ }),
-
-/***/ 8574:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-"use strict";
-
-
-var whitespace = __webpack_require__(2139)
-var normalize = __webpack_require__(4405)
-
-module.exports = footnoteDefinition
-footnoteDefinition.notInList = true
-footnoteDefinition.notInBlock = true
-
-var backslash = '\\'
-var lineFeed = '\n'
-var tab = '\t'
-var space = ' '
-var leftSquareBracket = '['
-var rightSquareBracket = ']'
-var caret = '^'
-var colon = ':'
-
-var EXPRESSION_INITIAL_TAB = /^( {4}|\t)?/gm
-
-function footnoteDefinition(eat, value, silent) {
-  var self = this
-  var offsets = self.offset
-  var index
-  var length
-  var subvalue
-  var now
-  var currentLine
-  var content
-  var queue
-  var subqueue
-  var character
-  var identifier
-  var add
-  var exit
-
-  if (!self.options.footnotes) {
-    return
-  }
-
-  index = 0
-  length = value.length
-  subvalue = ''
-  now = eat.now()
-  currentLine = now.line
-
-  while (index < length) {
-    character = value.charAt(index)
-
-    if (!whitespace(character)) {
-      break
-    }
-
-    subvalue += character
-    index++
-  }
-
-  if (
-    value.charAt(index) !== leftSquareBracket ||
-    value.charAt(index + 1) !== caret
-  ) {
-    return
-  }
-
-  subvalue += leftSquareBracket + caret
-  index = subvalue.length
-  queue = ''
-
-  while (index < length) {
-    character = value.charAt(index)
-
-    if (character === rightSquareBracket) {
-      break
-    } else if (character === backslash) {
-      queue += character
-      index++
-      character = value.charAt(index)
-    }
-
-    queue += character
-    index++
-  }
-
-  if (
-    !queue ||
-    value.charAt(index) !== rightSquareBracket ||
-    value.charAt(index + 1) !== colon
-  ) {
-    return
-  }
-
-  if (silent) {
-    return true
-  }
-
-  identifier = queue
-  subvalue += queue + rightSquareBracket + colon
-  index = subvalue.length
-
-  while (index < length) {
-    character = value.charAt(index)
-
-    if (character !== tab && character !== space) {
-      break
-    }
-
-    subvalue += character
-    index++
-  }
-
-  now.column += subvalue.length
-  now.offset += subvalue.length
-  queue = ''
-  content = ''
-  subqueue = ''
-
-  while (index < length) {
-    character = value.charAt(index)
-
-    if (character === lineFeed) {
-      subqueue = character
-      index++
-
-      while (index < length) {
-        character = value.charAt(index)
-
-        if (character !== lineFeed) {
-          break
-        }
-
-        subqueue += character
-        index++
-      }
-
-      queue += subqueue
-      subqueue = ''
-
-      while (index < length) {
-        character = value.charAt(index)
-
-        if (character !== space) {
-          break
-        }
-
-        subqueue += character
-        index++
-      }
-
-      if (subqueue.length === 0) {
-        break
-      }
-
-      queue += subqueue
-    }
-
-    if (queue) {
-      content += queue
-      queue = ''
-    }
-
-    content += character
-    index++
-  }
-
-  subvalue += content
-
-  content = content.replace(EXPRESSION_INITIAL_TAB, function(line) {
-    offsets[currentLine] = (offsets[currentLine] || 0) + line.length
-    currentLine++
-
-    return ''
-  })
-
-  add = eat(subvalue)
-
-  exit = self.enterBlock()
-  content = self.tokenizeBlock(content, now)
-  exit()
-
-  return add({
-    type: 'footnoteDefinition',
-    identifier: normalize(identifier),
-    label: identifier,
-    children: content
-  })
-}
-
-
 /***/ }),
 
 /***/ 2867:
@@ -24156,7 +24122,7 @@ var instructionCloseExpression = /\?>/
 var directiveOpenExpression = /^<![A-Za-z]/
 var directiveCloseExpression = />/
 var cdataOpenExpression = /^<!\[CDATA\[/
-var cdataCloseExpression = /\]\]>/
+var cdataCloseExpression = /]]>/
 var elementCloseExpression = /^$/
 var otherElementOpenExpression = new RegExp(openCloseTag.source + '\\s*$')
 
@@ -24430,20 +24396,6 @@ function link(eat, value, silent) {
       if (depth) {
         depth--
       } else {
-        // Allow white-space between content and url in GFM mode.
-        if (!pedantic) {
-          while (index < length) {
-            character = value.charAt(index + 1)
-
-            if (!whitespace(character)) {
-              break
-            }
-
-            subqueue += character
-            index++
-          }
-        }
-
         if (value.charAt(index + 1) !== leftParenthesis) {
           return
         }
@@ -24735,7 +24687,7 @@ var lowercaseX = 'x'
 
 var tabSize = 4
 var looseListItemExpression = /\n\n(?!\s*$)/
-var taskItemExpression = /^\[([ \t]|x|X)][ \t]/
+var taskItemExpression = /^\[([ X\tx])][ \t]/
 var bulletExpression = /^([ \t]*)([*+-]|\d+[.)])( {1,4}(?! )| |\t|$|(?=\n))([^\n]*)/
 var pedanticBulletExpression = /^([ \t]*)([*+-]|\d+[.)])([ \t]+)/
 var initialIndentExpression = /^( {1,4}|\t)?/gm
@@ -24749,7 +24701,7 @@ function list(eat, value, silent) {
   var index = 0
   var length = value.length
   var start = null
-  var size = 0
+  var size
   var queue
   var ordered
   var character
@@ -24760,7 +24712,7 @@ function list(eat, value, silent) {
   var currentMarker
   var content
   var line
-  var prevEmpty
+  var previousEmpty
   var empty
   var items
   var allLines
@@ -24777,21 +24729,13 @@ function list(eat, value, silent) {
   while (index < length) {
     character = value.charAt(index)
 
-    if (character === tab) {
-      size += tabSize - (size % tabSize)
-    } else if (character === space) {
-      size++
-    } else {
+    if (character !== tab && character !== space) {
       break
     }
 
     index++
   }
 
-  if (size >= tabSize) {
-    return
-  }
-
   character = value.charAt(index)
 
   if (character === asterisk || character === plusSign || character === dash) {
@@ -24821,6 +24765,14 @@ function list(eat, value, silent) {
       return
     }
 
+    /* Slightly abusing `silent` mode, whose goal is to make interrupting
+     * paragraphs work.
+     * Well, that’s exactly what we want to do here: don’t interrupt:
+     * 2. here, because the “list” doesn’t start with `1`. */
+    if (silent && queue !== '1') {
+      return
+    }
+
     start = parseInt(queue, 10)
     marker = character
   }
@@ -24854,7 +24806,6 @@ function list(eat, value, silent) {
       nextIndex = length
     }
 
-    end = index + tabSize
     size = 0
 
     while (index < length) {
@@ -24871,10 +24822,6 @@ function list(eat, value, silent) {
       index++
     }
 
-    if (size >= tabSize) {
-      indented = true
-    }
-
     if (item && size >= item.indent) {
       indented = true
     }
@@ -24975,7 +24922,7 @@ function list(eat, value, silent) {
       }
     }
 
-    prevEmpty = empty
+    previousEmpty = empty
     empty = !prefixed && !trim(content).length
 
     if (indented && item) {
@@ -24999,13 +24946,13 @@ function list(eat, value, silent) {
       allLines = allLines.concat(emptyLines, line)
       emptyLines = []
     } else if (empty) {
-      if (prevEmpty && !commonmark) {
+      if (previousEmpty && !commonmark) {
         break
       }
 
       emptyLines.push(line)
     } else {
-      if (prevEmpty) {
+      if (previousEmpty) {
         break
       }
 
@@ -25164,62 +25111,6 @@ function normalListItem(ctx, value, position) {
 }
 
 
-/***/ }),
-
-/***/ 3885:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-"use strict";
-
-
-var whitespace = __webpack_require__(2139)
-
-module.exports = newline
-
-var lineFeed = '\n'
-
-function newline(eat, value, silent) {
-  var character = value.charAt(0)
-  var length
-  var subvalue
-  var queue
-  var index
-
-  if (character !== lineFeed) {
-    return
-  }
-
-  /* istanbul ignore if - never used (yet) */
-  if (silent) {
-    return true
-  }
-
-  index = 1
-  length = value.length
-  subvalue = character
-  queue = ''
-
-  while (index < length) {
-    character = value.charAt(index)
-
-    if (!whitespace(character)) {
-      break
-    }
-
-    queue += character
-
-    if (character === lineFeed) {
-      subvalue += queue
-      queue = ''
-    }
-
-    index++
-  }
-
-  eat(subvalue)
-}
-
-
 /***/ }),
 
 /***/ 2431:
@@ -25229,7 +25120,6 @@ function newline(eat, value, silent) {
 
 
 var trim = __webpack_require__(3059)
-var decimal = __webpack_require__(6195)
 var trimTrailingLines = __webpack_require__(7257)
 var interrupt = __webpack_require__(6588)
 
@@ -25246,7 +25136,6 @@ function paragraph(eat, value, silent) {
   var self = this
   var settings = self.options
   var commonmark = settings.commonmark
-  var gfm = settings.gfm
   var tokenizers = self.blockTokenizers
   var interruptors = self.interruptParagraph
   var index = value.indexOf(lineFeed)
@@ -25302,17 +25191,6 @@ function paragraph(eat, value, silent) {
       break
     }
 
-    // Break if the following line starts a list, when already in a list, or
-    // when in commonmark, or when in gfm mode and the bullet is *not* numeric.
-    if (
-      tokenizers.list.call(self, eat, subvalue, true) &&
-      (self.inList ||
-        commonmark ||
-        (gfm && !decimal(trim.left(subvalue).charAt(0))))
-    ) {
-      break
-    }
-
     position = index
     index = value.indexOf(lineFeed, index + 1)
 
@@ -25324,12 +25202,6 @@ function paragraph(eat, value, silent) {
 
   subvalue = value.slice(0, index)
 
-  if (trim(subvalue) === '') {
-    eat(subvalue)
-
-    return null
-  }
-
   /* istanbul ignore if - never used (yet) */
   if (silent) {
     return true
@@ -25362,21 +25234,17 @@ reference.locator = locate
 
 var link = 'link'
 var image = 'image'
-var footnote = 'footnote'
 var shortcut = 'shortcut'
 var collapsed = 'collapsed'
 var full = 'full'
-var space = ' '
 var exclamationMark = '!'
 var leftSquareBracket = '['
 var backslash = '\\'
 var rightSquareBracket = ']'
-var caret = '^'
 
 function reference(eat, value, silent) {
   var self = this
   var commonmark = self.options.commonmark
-  var footnotes = self.options.footnotes
   var character = value.charAt(0)
   var index = 0
   var length = value.length
@@ -25408,19 +25276,6 @@ function reference(eat, value, silent) {
   intro += character
   queue = ''
 
-  // Check whether we’re eating a footnote.
-  if (footnotes && value.charAt(index) === caret) {
-    // Exit if `![^` is found, so the `!` will be seen as text after this,
-    // and we’ll enter this function again when `[^` is found.
-    if (type === image) {
-      return
-    }
-
-    intro += caret
-    index++
-    type = footnote
-  }
-
   // Eat the text.
   depth = 0
 
@@ -25477,13 +25332,7 @@ function reference(eat, value, silent) {
 
   character = value.charAt(index)
 
-  // Inline footnotes cannot have a label.
-  // If footnotes are enabled, link labels cannot start with a caret.
-  if (
-    type !== footnote &&
-    character === leftSquareBracket &&
-    (!footnotes || value.charAt(index + 1) !== caret)
-  ) {
+  if (character === leftSquareBracket) {
     identifier = ''
     queue += character
     index++
@@ -25540,13 +25389,6 @@ function reference(eat, value, silent) {
     return true
   }
 
-  if (type === footnote && content.indexOf(space) !== -1) {
-    return eat(subvalue)({
-      type: footnote,
-      children: this.tokenizeInline(content, eat.now())
-    })
-  }
-
   now = eat.now()
   now.column += intro.length
   now.offset += intro.length
@@ -25555,18 +25397,15 @@ function reference(eat, value, silent) {
   node = {
     type: type + 'Reference',
     identifier: normalize(identifier),
-    label: identifier
-  }
-
-  if (type === link || type === image) {
-    node.referenceType = referenceType
+    label: identifier,
+    referenceType: referenceType
   }
 
   if (type === link) {
     exit = self.enterLink()
     node.children = self.tokenizeInline(content, now)
     exit()
-  } else if (type === image) {
+  } else {
     node.alt = self.decode.raw(self.unescape(content), now) || null
   }
 
@@ -25603,7 +25442,7 @@ function strong(eat, value, silent) {
   var queue
   var subvalue
   var length
-  var prev
+  var previous
 
   if (
     (character !== asterisk && character !== underscore) ||
@@ -25625,13 +25464,13 @@ function strong(eat, value, silent) {
   }
 
   while (index < length) {
-    prev = character
+    previous = character
     character = value.charAt(index)
 
     if (
       character === marker &&
       value.charAt(index + 1) === marker &&
-      (!pedantic || !whitespace(prev))
+      (!pedantic || !whitespace(previous))
     ) {
       character = value.charAt(index + 2)
 
@@ -25858,7 +25697,7 @@ function table(eat, value, silent) {
 
             if (queue.length > 1) {
               if (character) {
-                subvalue += queue.slice(0, queue.length - 1)
+                subvalue += queue.slice(0, -1)
                 queue = queue.charAt(queue.length - 1)
               } else {
                 subvalue += queue
@@ -26058,7 +25897,10 @@ function thematicBreak(eat, value, silent) {
 "use strict";
 
 
+var ccount = __webpack_require__(932)
 var decode = __webpack_require__(7574)
+var decimal = __webpack_require__(6195)
+var alphabetical = __webpack_require__(6260)
 var whitespace = __webpack_require__(2139)
 var locate = __webpack_require__(1020)
 
@@ -26066,148 +25908,202 @@ module.exports = url
 url.locator = locate
 url.notInLink = true
 
-var quotationMark = '"'
-var apostrophe = "'"
-var leftParenthesis = '('
-var rightParenthesis = ')'
-var comma = ','
-var dot = '.'
-var colon = ':'
-var semicolon = ';'
-var lessThan = '<'
-var atSign = '@'
-var leftSquareBracket = '['
-var rightSquareBracket = ']'
-
-var http = 'http://'
-var https = 'https://'
-var mailto = 'mailto:'
-
-var protocols = [http, https, mailto]
+var exclamationMark = 33 // '!'
+var ampersand = 38 // '&'
+var rightParenthesis = 41 // ')'
+var asterisk = 42 // '*'
+var comma = 44 // ','
+var dash = 45 // '-'
+var dot = 46 // '.'
+var colon = 58 // ':'
+var semicolon = 59 // ';'
+var questionMark = 63 // '?'
+var lessThan = 60 // '<'
+var underscore = 95 // '_'
+var tilde = 126 // '~'
 
-var protocolsLength = protocols.length
+var leftParenthesisCharacter = '('
+var rightParenthesisCharacter = ')'
 
 function url(eat, value, silent) {
   var self = this
-  var subvalue
-  var content
-  var character
+  var gfm = self.options.gfm
+  var tokenizers = self.inlineTokenizers
+  var length = value.length
+  var previousDot = -1
+  var protocolless = false
+  var dots
+  var lastTwoPartsStart
+  var start
   var index
-  var position
-  var protocol
-  var match
-  var length
-  var queue
-  var parenCount
-  var nextCharacter
-  var tokenizers
+  var pathStart
+  var path
+  var code
+  var end
+  var leftCount
+  var rightCount
+  var content
+  var children
+  var url
   var exit
 
-  if (!self.options.gfm) {
+  if (!gfm) {
     return
   }
 
-  subvalue = ''
-  index = -1
+  // `WWW.` doesn’t work.
+  if (value.slice(0, 4) === 'www.') {
+    protocolless = true
+    index = 4
+  } else if (value.slice(0, 7).toLowerCase() === 'http://') {
+    index = 7
+  } else if (value.slice(0, 8).toLowerCase() === 'https://') {
+    index = 8
+  } else {
+    return
+  }
 
-  while (++index < protocolsLength) {
-    protocol = protocols[index]
-    match = value.slice(0, protocol.length)
+  // Act as if the starting boundary is a dot.
+  previousDot = index - 1
 
-    if (match.toLowerCase() === protocol) {
-      subvalue = match
-      break
+  // Parse a valid domain.
+  start = index
+  dots = []
+
+  while (index < length) {
+    code = value.charCodeAt(index)
+
+    if (code === dot) {
+      // Dots may not appear after each other.
+      if (previousDot === index - 1) {
+        break
+      }
+
+      dots.push(index)
+      previousDot = index
+      index++
+      continue
+    }
+
+    if (
+      decimal(code) ||
+      alphabetical(code) ||
+      code === dash ||
+      code === underscore
+    ) {
+      index++
+      continue
     }
+
+    break
   }
 
-  if (!subvalue) {
+  // Ignore a final dot:
+  if (code === dot) {
+    dots.pop()
+    index--
+  }
+
+  // If there are not dots, exit.
+  if (dots[0] === undefined) {
     return
   }
 
-  index = subvalue.length
-  length = value.length
-  queue = ''
-  parenCount = 0
+  // If there is an underscore in the last two domain parts, exit:
+  // `www.example.c_m` and `www.ex_ample.com` are not OK, but
+  // `www.sub_domain.example.com` is.
+  lastTwoPartsStart = dots.length < 2 ? start : dots[dots.length - 2] + 1
+
+  if (value.slice(lastTwoPartsStart, index).indexOf('_') !== -1) {
+    return
+  }
 
+  /* istanbul ignore if - never used (yet) */
+  if (silent) {
+    return true
+  }
+
+  end = index
+  pathStart = index
+
+  // Parse a path.
   while (index < length) {
-    character = value.charAt(index)
+    code = value.charCodeAt(index)
 
-    if (whitespace(character) || character === lessThan) {
+    if (whitespace(code) || code === lessThan) {
       break
     }
 
+    index++
+
     if (
-      character === dot ||
-      character === comma ||
-      character === colon ||
-      character === semicolon ||
-      character === quotationMark ||
-      character === apostrophe ||
-      character === rightParenthesis ||
-      character === rightSquareBracket
+      code === exclamationMark ||
+      code === asterisk ||
+      code === comma ||
+      code === dot ||
+      code === colon ||
+      code === questionMark ||
+      code === underscore ||
+      code === tilde
     ) {
-      nextCharacter = value.charAt(index + 1)
-
-      if (!nextCharacter || whitespace(nextCharacter)) {
-        break
-      }
+      // Empty
+    } else {
+      end = index
     }
+  }
 
-    if (character === leftParenthesis || character === leftSquareBracket) {
-      parenCount++
-    }
+  index = end
 
-    if (character === rightParenthesis || character === rightSquareBracket) {
-      parenCount--
+  // If the path ends in a closing paren, and the count of closing parens is
+  // higher than the opening count, then remove the supefluous closing parens.
+  if (value.charCodeAt(index - 1) === rightParenthesis) {
+    path = value.slice(pathStart, index)
+    leftCount = ccount(path, leftParenthesisCharacter)
+    rightCount = ccount(path, rightParenthesisCharacter)
 
-      if (parenCount < 0) {
-        break
-      }
+    while (rightCount > leftCount) {
+      index = pathStart + path.lastIndexOf(rightParenthesisCharacter)
+      path = value.slice(pathStart, index)
+      rightCount--
     }
-
-    queue += character
-    index++
   }
 
-  if (!queue) {
-    return
-  }
+  if (value.charCodeAt(index - 1) === semicolon) {
+    // GitHub doesn’t document this, but final semicolons aren’t paret of the
+    // URL either.
+    index--
 
-  subvalue += queue
-  content = subvalue
+    // // If the path ends in what looks like an entity, it’s not part of the path.
+    if (alphabetical(value.charCodeAt(index - 1))) {
+      end = index - 2
 
-  if (protocol === mailto) {
-    position = queue.indexOf(atSign)
+      while (alphabetical(value.charCodeAt(end))) {
+        end--
+      }
 
-    if (position === -1 || position === length - 1) {
-      return
+      if (value.charCodeAt(end) === ampersand) {
+        index = end
+      }
     }
-
-    content = content.slice(mailto.length)
   }
 
-  /* istanbul ignore if - never used (yet) */
-  if (silent) {
-    return true
+  content = value.slice(0, index)
+  url = decode(content, {nonTerminated: false})
+
+  if (protocolless) {
+    url = 'http://' + url
   }
 
   exit = self.enterLink()
 
   // Temporarily remove all tokenizers except text in url.
-  tokenizers = self.inlineTokenizers
   self.inlineTokenizers = {text: tokenizers.text}
-
-  content = self.tokenizeInline(content, eat.now())
-
+  children = self.tokenizeInline(content, eat.now())
   self.inlineTokenizers = tokenizers
+
   exit()
 
-  return eat(subvalue)({
-    type: 'link',
-    title: null,
-    url: decode(subvalue, {nonTerminated: false}),
-    children: content
-  })
+  return eat(content)({type: 'link', title: null, url: url, children: children})
 }
 
 
@@ -26265,11 +26161,15 @@ function factory(type) {
         name = methods[index]
         method = tokenizers[name]
 
+        // Previously, we had constructs such as footnotes and YAML that used
+        // these properties.
+        // Those are now external (plus there are userland extensions), that may
+        // still use them.
         if (
           method &&
           /* istanbul ignore next */ (!method.onlyAtStart || self.atStart) &&
-          (!method.notInList || !self.inList) &&
-          (!method.notInBlock || !self.inBlock) &&
+          /* istanbul ignore next */ (!method.notInList || !self.inList) &&
+          /* istanbul ignore next */ (!method.notInBlock || !self.inBlock) &&
           (!method.notInLink || !self.inLink)
         ) {
           valueLength = value.length
@@ -26328,7 +26228,7 @@ function factory(type) {
 
       // Done.  Called when the last character is eaten to retrieve the range’s
       // offsets.
-      return function() {
+      return function () {
         var last = line + 1
 
         while (pos < last) {
@@ -26379,10 +26279,10 @@ function factory(type) {
 
       // Add the position to a node.
       function update(node, indent) {
-        var prev = node.position
-        var start = prev ? prev.start : before
+        var previous = node.position
+        var start = previous ? previous.start : before
         var combined = []
-        var n = prev && prev.end.line
+        var n = previous && previous.end.line
         var l = before.line
 
         node.position = new Position(start)
@@ -26392,8 +26292,8 @@ function factory(type) {
         // because some information, the indent between `n` and `l` wasn’t
         // tracked.  Luckily, that space is (should be?) empty, so we can
         // safely check for it now.
-        if (prev && indent && prev.indent) {
-          combined = prev.indent
+        if (previous && indent && previous.indent) {
+          combined = previous.indent
 
           if (n < l) {
             while (++n < l) {
@@ -26416,21 +26316,21 @@ function factory(type) {
     // possible.
     function add(node, parent) {
       var children = parent ? parent.children : tokens
-      var prev = children[children.length - 1]
+      var previous = children[children.length - 1]
       var fn
 
       if (
-        prev &&
-        node.type === prev.type &&
+        previous &&
+        node.type === previous.type &&
         (node.type === 'text' || node.type === 'blockquote') &&
-        mergeable(prev) &&
+        mergeable(previous) &&
         mergeable(node)
       ) {
         fn = node.type === 'text' ? mergeText : mergeBlockquote
-        node = fn.call(self, prev, node)
+        node = fn.call(self, previous, node)
       }
 
-      if (node !== prev) {
+      if (node !== previous) {
         children.push(node)
       }
 
@@ -26515,21 +26415,21 @@ function mergeable(node) {
 }
 
 // Merge two text nodes: `node` into `prev`.
-function mergeText(prev, node) {
-  prev.value += node.value
+function mergeText(previous, node) {
+  previous.value += node.value
 
-  return prev
+  return previous
 }
 
 // Merge two blockquotes: `node` into `prev`, unless in CommonMark or gfm modes.
-function mergeBlockquote(prev, node) {
+function mergeBlockquote(previous, node) {
   if (this.options.commonmark || this.options.gfm) {
     return node
   }
 
-  prev.children = prev.children.concat(node.children)
+  previous.children = previous.children.concat(node.children)
 
-  return prev
+  return previous
 }
 
 
@@ -26551,26 +26451,26 @@ function factory(ctx, key) {
 
   // De-escape a string using the expression at `key` in `ctx`.
   function unescape(value) {
-    var prev = 0
+    var previous = 0
     var index = value.indexOf(backslash)
     var escape = ctx[key]
     var queue = []
     var character
 
     while (index !== -1) {
-      queue.push(value.slice(prev, index))
-      prev = index + 1
-      character = value.charAt(prev)
+      queue.push(value.slice(previous, index))
+      previous = index + 1
+      character = value.charAt(previous)
 
       // If the following character is not a valid escape, add the slash.
       if (!character || escape.indexOf(character) === -1) {
         queue.push(backslash)
       }
 
-      index = value.indexOf(backslash, prev + 1)
+      index = value.indexOf(backslash, previous + 1)
     }
 
-    queue.push(value.slice(prev))
+    queue.push(value.slice(previous))
 
     return queue.join('')
   }
@@ -26600,6 +26500,7 @@ function indentation(value) {
   var character = value.charAt(index)
   var stops = {}
   var size
+  var lastIndent = 0
 
   while (character === tab || character === space) {
     size = character === tab ? tabSize : spaceSize
@@ -26610,7 +26511,10 @@ function indentation(value) {
       indent = Math.floor(indent / size) * size
     }
 
-    stops[indent] = index
+    while (lastIndent < indent) {
+      stops[++lastIndent] = index
+    }
+
     character = value.charAt(++index)
   }
 
@@ -26670,7 +26574,7 @@ exports._ = new RegExp(
 
 module.exports = interrupt
 
-function interrupt(interruptors, tokenizers, ctx, params) {
+function interrupt(interruptors, tokenizers, ctx, parameters) {
   var length = interruptors.length
   var index = -1
   var interruptor
@@ -26694,7 +26598,7 @@ function interrupt(interruptors, tokenizers, ctx, params) {
       continue
     }
 
-    if (tokenizers[interruptor[0]].apply(ctx, params)) {
+    if (tokenizers[interruptor[0]].apply(ctx, parameters)) {
       return true
     }
   }
@@ -26736,7 +26640,6 @@ var getIndent = __webpack_require__(2299)
 
 module.exports = indentation
 
-var tab = '\t'
 var lineFeed = '\n'
 var space = ' '
 var exclamationMark = '!'
@@ -26751,7 +26654,6 @@ function indentation(value, maximum) {
   var index
   var indentation
   var stops
-  var padding
 
   values.unshift(repeat(space, maximum) + exclamationMark)
 
@@ -26786,18 +26688,7 @@ function indentation(value, maximum) {
         index--
       }
 
-      if (
-        trim(values[position]).length !== 0 &&
-        minIndent &&
-        index !== minIndent
-      ) {
-        padding = tab
-      } else {
-        padding = ''
-      }
-
-      values[position] =
-        padding + values[position].slice(index in stops ? stops[index] + 1 : 0)
+      values[position] = values[position].slice(stops[index] + 1)
     }
   }
 
@@ -26862,8 +26753,8 @@ function bridge(destination, options) {
   function transformer(node, file, next) {
     destination.run(mdast2hast(node, options), file, done)
 
-    function done(err) {
-      next(err)
+    function done(error) {
+      next(error)
     }
   }
 }
@@ -28166,7 +28057,7 @@ function enter(compiler, node) {
 "use strict";
 
 
-var decode = __webpack_require__(4595)
+var decode = __webpack_require__(7574)
 
 module.exports = length
 
@@ -28241,7 +28132,7 @@ function label(node) {
 
 /***/ }),
 
-/***/ 1809:
+/***/ 7468:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 "use strict";
@@ -28335,7 +28226,7 @@ function lineBreak() {
 
 var streak = __webpack_require__(2491)
 var repeat = __webpack_require__(6464)
-var pad = __webpack_require__(1809)
+var pad = __webpack_require__(7468)
 
 module.exports = code
 
@@ -28879,7 +28770,7 @@ function link(node) {
 
 
 var repeat = __webpack_require__(6464)
-var pad = __webpack_require__(1809)
+var pad = __webpack_require__(7468)
 
 module.exports = listItem
 
@@ -29175,503 +29066,6 @@ function thematic() {
 }
 
 
-/***/ }),
-
-/***/ 7468:
-/***/ ((module) => {
-
-"use strict";
-
-
-/* eslint-env browser */
-
-var el
-
-var semicolon = 59 //  ';'
-
-module.exports = decodeEntity
-
-function decodeEntity(characters) {
-  var entity = '&' + characters + ';'
-  var char
-
-  el = el || document.createElement('i')
-  el.innerHTML = entity
-  char = el.textContent
-
-  // Some entities do not require the closing semicolon (`&not` - for instance),
-  // which leads to situations where parsing the assumed entity of &notit; will
-  // result in the string `¬it;`.  When we encounter a trailing semicolon after
-  // parsing and the entity to decode was not a semicolon (`&semi;`), we can
-  // assume that the matching was incomplete
-  if (char.charCodeAt(char.length - 1) === semicolon && characters !== 'semi') {
-    return false
-  }
-
-  // If the decoded string is equal to the input, the entity was not valid
-  return char === entity ? false : char
-}
-
-
-/***/ }),
-
-/***/ 4595:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-"use strict";
-
-
-var legacy = __webpack_require__(7452)
-var invalid = __webpack_require__(3580)
-var decimal = __webpack_require__(6195)
-var hexadecimal = __webpack_require__(9480)
-var alphanumerical = __webpack_require__(7961)
-var decodeEntity = __webpack_require__(7468)
-
-module.exports = parseEntities
-
-var own = {}.hasOwnProperty
-var fromCharCode = String.fromCharCode
-var noop = Function.prototype
-
-// Default settings.
-var defaults = {
-  warning: null,
-  reference: null,
-  text: null,
-  warningContext: null,
-  referenceContext: null,
-  textContext: null,
-  position: {},
-  additional: null,
-  attribute: false,
-  nonTerminated: true
-}
-
-// Characters.
-var tab = 9 // '\t'
-var lineFeed = 10 // '\n'
-var formFeed = 12 // '\f'
-var space = 32 // ' '
-var ampersand = 38 // '&'
-var semicolon = 59 // ';'
-var lessThan = 60 // '<'
-var equalsTo = 61 // '='
-var numberSign = 35 // '#'
-var uppercaseX = 88 // 'X'
-var lowercaseX = 120 // 'x'
-var replacementCharacter = 65533 // '�'
-
-// Reference types.
-var name = 'named'
-var hexa = 'hexadecimal'
-var deci = 'decimal'
-
-// Map of bases.
-var bases = {}
-
-bases[hexa] = 16
-bases[deci] = 10
-
-// Map of types to tests.
-// Each type of character reference accepts different characters.
-// This test is used to detect whether a reference has ended (as the semicolon
-// is not strictly needed).
-var tests = {}
-
-tests[name] = alphanumerical
-tests[deci] = decimal
-tests[hexa] = hexadecimal
-
-// Warning types.
-var namedNotTerminated = 1
-var numericNotTerminated = 2
-var namedEmpty = 3
-var numericEmpty = 4
-var namedUnknown = 5
-var numericDisallowed = 6
-var numericProhibited = 7
-
-// Warning messages.
-var messages = {}
-
-messages[namedNotTerminated] =
-  'Named character references must be terminated by a semicolon'
-messages[numericNotTerminated] =
-  'Numeric character references must be terminated by a semicolon'
-messages[namedEmpty] = 'Named character references cannot be empty'
-messages[numericEmpty] = 'Numeric character references cannot be empty'
-messages[namedUnknown] = 'Named character references must be known'
-messages[numericDisallowed] =
-  'Numeric character references cannot be disallowed'
-messages[numericProhibited] =
-  'Numeric character references cannot be outside the permissible Unicode range'
-
-// Wrap to ensure clean parameters are given to `parse`.
-function parseEntities(value, options) {
-  var settings = {}
-  var option
-  var key
-
-  if (!options) {
-    options = {}
-  }
-
-  for (key in defaults) {
-    option = options[key]
-    settings[key] =
-      option === null || option === undefined ? defaults[key] : option
-  }
-
-  if (settings.position.indent || settings.position.start) {
-    settings.indent = settings.position.indent || []
-    settings.position = settings.position.start
-  }
-
-  return parse(value, settings)
-}
-
-// Parse entities.
-// eslint-disable-next-line complexity
-function parse(value, settings) {
-  var additional = settings.additional
-  var nonTerminated = settings.nonTerminated
-  var handleText = settings.text
-  var handleReference = settings.reference
-  var handleWarning = settings.warning
-  var textContext = settings.textContext
-  var referenceContext = settings.referenceContext
-  var warningContext = settings.warningContext
-  var pos = settings.position
-  var indent = settings.indent || []
-  var length = value.length
-  var index = 0
-  var lines = -1
-  var column = pos.column || 1
-  var line = pos.line || 1
-  var queue = ''
-  var result = []
-  var entityCharacters
-  var namedEntity
-  var terminated
-  var characters
-  var character
-  var reference
-  var following
-  var warning
-  var reason
-  var output
-  var entity
-  var begin
-  var start
-  var type
-  var test
-  var prev
-  var next
-  var diff
-  var end
-
-  if (typeof additional === 'string') {
-    additional = additional.charCodeAt(0)
-  }
-
-  // Cache the current point.
-  prev = now()
-
-  // Wrap `handleWarning`.
-  warning = handleWarning ? parseError : noop
-
-  // Ensure the algorithm walks over the first character and the end
-  // (inclusive).
-  index--
-  length++
-
-  while (++index < length) {
-    // If the previous character was a newline.
-    if (character === lineFeed) {
-      column = indent[lines] || 1
-    }
-
-    character = value.charCodeAt(index)
-
-    if (character === ampersand) {
-      following = value.charCodeAt(index + 1)
-
-      // The behaviour depends on the identity of the next character.
-      if (
-        following === tab ||
-        following === lineFeed ||
-        following === formFeed ||
-        following === space ||
-        following === ampersand ||
-        following === lessThan ||
-        following !== following ||
-        (additional && following === additional)
-      ) {
-        // Not a character reference.
-        // No characters are consumed, and nothing is returned.
-        // This is not an error, either.
-        queue += fromCharCode(character)
-        column++
-
-        continue
-      }
-
-      start = index + 1
-      begin = start
-      end = start
-
-      if (following === numberSign) {
-        // Numerical entity.
-        end = ++begin
-
-        // The behaviour further depends on the next character.
-        following = value.charCodeAt(end)
-
-        if (following === uppercaseX || following === lowercaseX) {
-          // ASCII hex digits.
-          type = hexa
-          end = ++begin
-        } else {
-          // ASCII digits.
-          type = deci
-        }
-      } else {
-        // Named entity.
-        type = name
-      }
-
-      entityCharacters = ''
-      entity = ''
-      characters = ''
-      test = tests[type]
-      end--
-
-      while (++end < length) {
-        following = value.charCodeAt(end)
-
-        if (!test(following)) {
-          break
-        }
-
-        characters += fromCharCode(following)
-
-        // Check if we can match a legacy named reference.
-        // If so, we cache that as the last viable named reference.
-        // This ensures we do not need to walk backwards later.
-        if (type === name && own.call(legacy, characters)) {
-          entityCharacters = characters
-          entity = legacy[characters]
-        }
-      }
-
-      terminated = value.charCodeAt(end) === semicolon
-
-      if (terminated) {
-        end++
-
-        namedEntity = type === name ? decodeEntity(characters) : false
-
-        if (namedEntity) {
-          entityCharacters = characters
-          entity = namedEntity
-        }
-      }
-
-      diff = 1 + end - start
-
-      if (!terminated && !nonTerminated) {
-        // Empty.
-      } else if (!characters) {
-        // An empty (possible) entity is valid, unless it’s numeric (thus an
-        // ampersand followed by an octothorp).
-        if (type !== name) {
-          warning(numericEmpty, diff)
-        }
-      } else if (type === name) {
-        // An ampersand followed by anything unknown, and not terminated, is
-        // invalid.
-        if (terminated && !entity) {
-          warning(namedUnknown, 1)
-        } else {
-          // If theres something after an entity name which is not known, cap
-          // the reference.
-          if (entityCharacters !== characters) {
-            end = begin + entityCharacters.length
-            diff = 1 + end - begin
-            terminated = false
-          }
-
-          // If the reference is not terminated, warn.
-          if (!terminated) {
-            reason = entityCharacters ? namedNotTerminated : namedEmpty
-
-            if (settings.attribute) {
-              following = value.charCodeAt(end)
-
-              if (following === equalsTo) {
-                warning(reason, diff)
-                entity = null
-              } else if (alphanumerical(following)) {
-                entity = null
-              } else {
-                warning(reason, diff)
-              }
-            } else {
-              warning(reason, diff)
-            }
-          }
-        }
-
-        reference = entity
-      } else {
-        if (!terminated) {
-          // All non-terminated numeric entities are not rendered, and trigger a
-          // warning.
-          warning(numericNotTerminated, diff)
-        }
-
-        // When terminated and number, parse as either hexadecimal or decimal.
-        reference = parseInt(characters, bases[type])
-
-        // Trigger a warning when the parsed number is prohibited, and replace
-        // with replacement character.
-        if (prohibited(reference)) {
-          warning(numericProhibited, diff)
-          reference = fromCharCode(replacementCharacter)
-        } else if (reference in invalid) {
-          // Trigger a warning when the parsed number is disallowed, and replace
-          // by an alternative.
-          warning(numericDisallowed, diff)
-          reference = invalid[reference]
-        } else {
-          // Parse the number.
-          output = ''
-
-          // Trigger a warning when the parsed number should not be used.
-          if (disallowed(reference)) {
-            warning(numericDisallowed, diff)
-          }
-
-          // Stringify the number.
-          if (reference > 0xffff) {
-            reference -= 0x10000
-            output += fromCharCode((reference >>> (10 & 0x3ff)) | 0xd800)
-            reference = 0xdc00 | (reference & 0x3ff)
-          }
-
-          reference = output + fromCharCode(reference)
-        }
-      }
-
-      // Found it!
-      // First eat the queued characters as normal text, then eat an entity.
-      if (reference) {
-        flush()
-
-        prev = now()
-        index = end - 1
-        column += end - start + 1
-        result.push(reference)
-        next = now()
-        next.offset++
-
-        if (handleReference) {
-          handleReference.call(
-            referenceContext,
-            reference,
-            {start: prev, end: next},
-            value.slice(start - 1, end)
-          )
-        }
-
-        prev = next
-      } else {
-        // If we could not find a reference, queue the checked characters (as
-        // normal characters), and move the pointer to their end.
-        // This is possible because we can be certain neither newlines nor
-        // ampersands are included.
-        characters = value.slice(start - 1, end)
-        queue += characters
-        column += characters.length
-        index = end - 1
-      }
-    } else {
-      // Handle anything other than an ampersand, including newlines and EOF.
-      if (
-        character === 10 // Line feed
-      ) {
-        line++
-        lines++
-        column = 0
-      }
-
-      if (character === character) {
-        queue += fromCharCode(character)
-        column++
-      } else {
-        flush()
-      }
-    }
-  }
-
-  // Return the reduced nodes.
-  return result.join('')
-
-  // Get current position.
-  function now() {
-    return {
-      line: line,
-      column: column,
-      offset: index + (pos.offset || 0)
-    }
-  }
-
-  // “Throw” a parse-error: a warning.
-  function parseError(code, offset) {
-    var position = now()
-
-    position.column += offset
-    position.offset += offset
-
-    handleWarning.call(warningContext, messages[code], position, code)
-  }
-
-  // Flush `queue` (normal text).
-  // Macro invoked before each entity and at the end of `value`.
-  // Does nothing when `queue` is empty.
-  function flush() {
-    if (queue) {
-      result.push(queue)
-
-      if (handleText) {
-        handleText.call(textContext, queue, {start: prev, end: now()})
-      }
-
-      queue = ''
-    }
-  }
-}
-
-// Check if `character` is outside the permissible unicode range.
-function prohibited(code) {
-  return (code >= 0xd800 && code <= 0xdfff) || code > 0x10ffff
-}
-
-// Check if `character` is disallowed.
-function disallowed(code) {
-  return (
-    (code >= 0x0001 && code <= 0x0008) ||
-    code === 0x000b ||
-    (code >= 0x000d && code <= 0x001f) ||
-    (code >= 0x007f && code <= 0x009f) ||
-    (code >= 0xfdd0 && code <= 0xfdef) ||
-    (code & 0xffff) === 0xffff ||
-    (code & 0xffff) === 0xfffe
-  )
-}
-
-
 /***/ }),
 
 /***/ 7089:
@@ -30232,24 +29626,6 @@ module.exports = function () {
 };
 
 
-/***/ }),
-
-/***/ 6221:
-/***/ ((module) => {
-
-"use strict";
-
-
-module.exports = trimLines
-
-var ws = /[ \t]*\n+[ \t]*/g
-var newline = '\n'
-
-function trimLines(value) {
-  return String(value).replace(ws, newline)
-}
-
-
 /***/ }),
 
 /***/ 7257:
@@ -30519,11 +29895,12 @@ function unherit(Super) {
 "use strict";
 
 
-var extend = __webpack_require__(4470)
 var bail = __webpack_require__(8841)
-var vfile = __webpack_require__(939)
-var trough = __webpack_require__(8281)
+var buffer = __webpack_require__(8738)
+var extend = __webpack_require__(4470)
 var plain = __webpack_require__(8980)
+var trough = __webpack_require__(8281)
+var vfile = __webpack_require__(939)
 
 // Expose a frozen processor.
 module.exports = unified().freeze()
@@ -30544,9 +29921,9 @@ function pipelineParse(p, ctx) {
 function pipelineRun(p, ctx, next) {
   p.run(ctx.tree, ctx.file, done)
 
-  function done(err, tree, file) {
-    if (err) {
-      next(err)
+  function done(error, tree, file) {
+    if (error) {
+      next(error)
     } else {
       ctx.tree = tree
       ctx.file = file
@@ -30556,7 +29933,19 @@ function pipelineRun(p, ctx, next) {
 }
 
 function pipelineStringify(p, ctx) {
-  ctx.file.contents = p.stringify(ctx.tree, ctx.file)
+  var result = p.stringify(ctx.tree, ctx.file)
+
+  if (result === undefined || result === null) {
+    // Empty.
+  } else if (typeof result === 'string' || buffer(result)) {
+    if ('value' in ctx.file) {
+      ctx.file.value = result
+    }
+
+    ctx.file.contents = result
+  } else {
+    ctx.file.result = result
+  }
 }
 
 // Function to create the first processor.
@@ -30564,8 +29953,8 @@ function unified() {
   var attachers = []
   var transformers = trough()
   var namespace = {}
-  var frozen = false
   var freezeIndex = -1
+  var frozen
 
   // Data management.
   processor.data = data
@@ -30591,10 +29980,9 @@ function unified() {
   // Create a new processor based on the processor in the current scope.
   function processor() {
     var destination = unified()
-    var length = attachers.length
     var index = -1
 
-    while (++index < length) {
+    while (++index < attachers.length) {
       destination.use.apply(null, attachers[index])
     }
 
@@ -30612,8 +30000,6 @@ function unified() {
   // In essence, always invoke this when exporting a processor.
   function freeze() {
     var values
-    var plugin
-    var options
     var transformer
 
     if (frozen) {
@@ -30622,19 +30008,16 @@ function unified() {
 
     while (++freezeIndex < attachers.length) {
       values = attachers[freezeIndex]
-      plugin = values[0]
-      options = values[1]
-      transformer = null
 
-      if (options === false) {
+      if (values[1] === false) {
         continue
       }
 
-      if (options === true) {
+      if (values[1] === true) {
         values[1] = undefined
       }
 
-      transformer = plugin.apply(processor, values.slice(1))
+      transformer = values[0].apply(processor, values.slice(1))
 
       if (typeof transformer === 'function') {
         transformers.use(transformer)
@@ -30654,9 +30037,7 @@ function unified() {
       // Set `key`.
       if (arguments.length === 2) {
         assertUnfrozen('data', frozen)
-
         namespace[key] = value
-
         return processor
       }
 
@@ -30730,16 +30111,12 @@ function unified() {
     }
 
     function addList(plugins) {
-      var length
-      var index
+      var index = -1
 
       if (plugins === null || plugins === undefined) {
         // Empty.
       } else if (typeof plugins === 'object' && 'length' in plugins) {
-        length = plugins.length
-        index = -1
-
-        while (++index < length) {
+        while (++index < plugins.length) {
           add(plugins[index])
         }
       } else {
@@ -30752,7 +30129,7 @@ function unified() {
 
       if (entry) {
         if (plain(entry[1]) && plain(value)) {
-          value = extend(entry[1], value)
+          value = extend(true, entry[1], value)
         }
 
         entry[1] = value
@@ -30763,15 +30140,11 @@ function unified() {
   }
 
   function find(plugin) {
-    var length = attachers.length
     var index = -1
-    var entry
 
-    while (++index < length) {
-      entry = attachers[index]
-
-      if (entry[0] === plugin) {
-        return entry
+    while (++index < attachers.length) {
+      if (attachers[index][0] === plugin) {
+        return attachers[index]
       }
     }
   }
@@ -30813,10 +30186,10 @@ function unified() {
     function executor(resolve, reject) {
       transformers.run(node, vfile(file), done)
 
-      function done(err, tree, file) {
+      function done(error, tree, file) {
         tree = tree || node
-        if (err) {
-          reject(err)
+        if (error) {
+          reject(error)
         } else if (resolve) {
           resolve(tree)
         } else {
@@ -30829,8 +30202,8 @@ function unified() {
   // Run transforms on a unist node representation of a file (in string or
   // vfile representation), sync.
   function runSync(node, file) {
-    var complete = false
     var result
+    var complete
 
     run(node, file, done)
 
@@ -30838,10 +30211,10 @@ function unified() {
 
     return result
 
-    function done(err, tree) {
+    function done(error, tree) {
       complete = true
-      bail(err)
       result = tree
+      bail(error)
     }
   }
 
@@ -30883,9 +30256,9 @@ function unified() {
 
       pipeline.run(processor, {file: file}, done)
 
-      function done(err) {
-        if (err) {
-          reject(err)
+      function done(error) {
+        if (error) {
+          reject(error)
         } else if (resolve) {
           resolve(file)
         } else {
@@ -30897,8 +30270,8 @@ function unified() {
 
   // Process the given document (in string or vfile representation), sync.
   function processSync(doc) {
-    var complete = false
     var file
+    var complete
 
     freeze()
     assertParser('processSync', processor.Parser)
@@ -30911,9 +30284,9 @@ function unified() {
 
     return file
 
-    function done(err) {
+    function done(error) {
       complete = true
-      bail(err)
+      bail(error)
     }
   }
 }
@@ -31055,15 +30428,16 @@ function flatMap(ast, fn) {
 module.exports = generated
 
 function generated(node) {
-  var position = optional(optional(node).position)
-  var start = optional(position.start)
-  var end = optional(position.end)
-
-  return !start.line || !start.column || !end.line || !end.column
-}
-
-function optional(value) {
-  return value && typeof value === 'object' ? value : {}
+  return (
+    !node ||
+    !node.position ||
+    !node.position.start ||
+    !node.position.start.line ||
+    !node.position.start.column ||
+    !node.position.end ||
+    !node.position.end.line ||
+    !node.position.end.column
+  )
 }
 
 
@@ -31225,6 +30599,203 @@ function soft(node) {
 }
 
 
+/***/ }),
+
+/***/ 7627:
+/***/ ((module) => {
+
+"use strict";
+
+
+module.exports = convert
+
+function convert(test) {
+  if (test == null) {
+    return ok
+  }
+
+  if (typeof test === 'string') {
+    return typeFactory(test)
+  }
+
+  if (typeof test === 'object') {
+    return 'length' in test ? anyFactory(test) : allFactory(test)
+  }
+
+  if (typeof test === 'function') {
+    return test
+  }
+
+  throw new Error('Expected function, string, or object as test')
+}
+
+// Utility assert each property in `test` is represented in `node`, and each
+// values are strictly equal.
+function allFactory(test) {
+  return all
+
+  function all(node) {
+    var key
+
+    for (key in test) {
+      if (node[key] !== test[key]) return false
+    }
+
+    return true
+  }
+}
+
+function anyFactory(tests) {
+  var checks = []
+  var index = -1
+
+  while (++index < tests.length) {
+    checks[index] = convert(tests[index])
+  }
+
+  return any
+
+  function any() {
+    var index = -1
+
+    while (++index < checks.length) {
+      if (checks[index].apply(this, arguments)) {
+        return true
+      }
+    }
+
+    return false
+  }
+}
+
+// Utility to convert a string into a function which checks a given node’s type
+// for said string.
+function typeFactory(test) {
+  return type
+
+  function type(node) {
+    return Boolean(node && node.type === test)
+  }
+}
+
+// Utility to return true.
+function ok() {
+  return true
+}
+
+
+/***/ }),
+
+/***/ 1733:
+/***/ ((module) => {
+
+module.exports = identity
+function identity(d) {
+  return d
+}
+
+
+/***/ }),
+
+/***/ 5195:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+module.exports = visitParents
+
+var convert = __webpack_require__(7627)
+var color = __webpack_require__(1733)
+
+var CONTINUE = true
+var SKIP = 'skip'
+var EXIT = false
+
+visitParents.CONTINUE = CONTINUE
+visitParents.SKIP = SKIP
+visitParents.EXIT = EXIT
+
+function visitParents(tree, test, visitor, reverse) {
+  var step
+  var is
+
+  if (typeof test === 'function' && typeof visitor !== 'function') {
+    reverse = visitor
+    visitor = test
+    test = null
+  }
+
+  is = convert(test)
+  step = reverse ? -1 : 1
+
+  factory(tree, null, [])()
+
+  function factory(node, index, parents) {
+    var value = typeof node === 'object' && node !== null ? node : {}
+    var name
+
+    if (typeof value.type === 'string') {
+      name =
+        typeof value.tagName === 'string'
+          ? value.tagName
+          : typeof value.name === 'string'
+          ? value.name
+          : undefined
+
+      visit.displayName =
+        'node (' + color(value.type + (name ? '<' + name + '>' : '')) + ')'
+    }
+
+    return visit
+
+    function visit() {
+      var grandparents = parents.concat(node)
+      var result = []
+      var subresult
+      var offset
+
+      if (!test || is(node, index, parents[parents.length - 1] || null)) {
+        result = toResult(visitor(node, parents))
+
+        if (result[0] === EXIT) {
+          return result
+        }
+      }
+
+      if (node.children && result[0] !== SKIP) {
+        offset = (reverse ? node.children.length : -1) + step
+
+        while (offset > -1 && offset < node.children.length) {
+          subresult = factory(node.children[offset], offset, grandparents)()
+
+          if (subresult[0] === EXIT) {
+            return subresult
+          }
+
+          offset =
+            typeof subresult[1] === 'number' ? subresult[1] : offset + step
+        }
+      }
+
+      return result
+    }
+  }
+}
+
+function toResult(value) {
+  if (value !== null && typeof value === 'object' && 'length' in value) {
+    return value
+  }
+
+  if (typeof value === 'number') {
+    return [CONTINUE, value]
+  }
+
+  return [value]
+}
+
+
 /***/ }),
 
 /***/ 750:
@@ -31235,7 +30806,7 @@ function soft(node) {
 
 module.exports = visit
 
-var visitParents = __webpack_require__(9294)
+var visitParents = __webpack_require__(5195)
 
 var CONTINUE = visitParents.CONTINUE
 var SKIP = visitParents.SKIP
@@ -31417,74 +30988,54 @@ function toResult(value) {
 module.exports = factory
 
 function factory(file) {
-  var contents = indices(String(file))
+  var value = String(file)
+  var indices = []
+  var search = /\r?\n|\r/g
 
-  return {
-    toPosition: offsetToPositionFactory(contents),
-    toOffset: positionToOffsetFactory(contents)
+  while (search.exec(value)) {
+    indices.push(search.lastIndex)
   }
-}
 
-// Factory to get the line and column-based `position` for `offset` in the bound
-// indices.
-function offsetToPositionFactory(indices) {
-  return offsetToPosition
+  indices.push(value.length + 1)
 
-  // Get the line and column-based `position` for `offset` in the bound indices.
-  function offsetToPosition(offset) {
-    var index = -1
-    var length = indices.length
+  return {
+    toPoint: offsetToPoint,
+    toPosition: offsetToPoint,
+    toOffset: pointToOffset
+  }
 
-    if (offset < 0) {
-      return {}
-    }
+  // Get the line and column-based `point` for `offset` in the bound indices.
+  function offsetToPoint(offset) {
+    var index = -1
 
-    while (++index < length) {
-      if (indices[index] > offset) {
-        return {
-          line: index + 1,
-          column: offset - (indices[index - 1] || 0) + 1,
-          offset: offset
+    if (offset > -1 && offset < indices[indices.length - 1]) {
+      while (++index < indices.length) {
+        if (indices[index] > offset) {
+          return {
+            line: index + 1,
+            column: offset - (indices[index - 1] || 0) + 1,
+            offset: offset
+          }
         }
       }
     }
 
     return {}
   }
-}
 
-// Factory to get the `offset` for a line and column-based `position` in the
-// bound indices.
-function positionToOffsetFactory(indices) {
-  return positionToOffset
-
-  // Get the `offset` for a line and column-based `position` in the bound
+  // Get the `offset` for a line and column-based `point` in the bound
   // indices.
-  function positionToOffset(position) {
-    var line = position && position.line
-    var column = position && position.column
+  function pointToOffset(point) {
+    var line = point && point.line
+    var column = point && point.column
+    var offset
 
     if (!isNaN(line) && !isNaN(column) && line - 1 in indices) {
-      return (indices[line - 2] || 0) + column - 1 || 0
+      offset = (indices[line - 2] || 0) + column - 1 || 0
     }
 
-    return -1
-  }
-}
-
-// Get indices of line-breaks in `value`.
-function indices(value) {
-  var result = []
-  var index = value.indexOf('\n')
-
-  while (index !== -1) {
-    result.push(index + 1)
-    index = value.indexOf('\n', index + 1)
+    return offset > -1 && offset < indices[indices.length - 1] ? offset : -1
   }
-
-  result.push(value.length + 1)
-
-  return result
 }
 
 
@@ -34976,11 +34527,12 @@ function plain(text) {
   var _setup6 = (0,_babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(_setup5, 2);
   text = _setup6[0];
   opts = _setup6[1];
-  return htmlProcessor(opts).use(rehypeReact, {
+  var proc = htmlProcessor(opts).use(rehypeReact, {
     createElement: React.createElement,
     Fragment: React.Fragment,
     components: components
-  }).processSync(text).contents;
+  });
+  return proc.processSync(text).result;
 }
 
 /**