@readme/markdown 6.58.1 → 6.59.0

package/dist/main.js

@@ -8633,12 +8633,11 @@ function Heading(_ref) {
   }
   return React.createElement(tag, attrs, children);
 }
-function CreateHeading(level, anchors, _ref2) {
+function CreateHeading(level, _ref2) {
   var showAnchorIcons = _ref2.showAnchorIcons;
   // eslint-disable-next-line react/display-name
   return function (props) {
     return /*#__PURE__*/React.createElement(Heading, _extends({}, props, {
-      anchors: anchors,
       level: level,
       showAnchorIcons: showAnchorIcons,
       tag: "h".concat(level)
@@ -8647,7 +8646,6 @@ function CreateHeading(level, anchors, _ref2) {
 }
 Heading.propTypes = {
   align: PropTypes.oneOf(['left', 'center', 'right', '']),
-  anchors: PropTypes.object,
   children: PropTypes.array.isRequired,
   id: PropTypes.string.isRequired,
   level: PropTypes.number,
@@ -8660,9 +8658,7 @@ Heading.defaultProps = {
   level: 2,
   showAnchorIcons: true
 };
-module.exports = function (level, anchors, opts) {
-  return CreateHeading(level, anchors, opts);
-};
+module.exports = CreateHeading;
 
 /***/ }),
 
@@ -26257,6 +26253,532 @@ module.exports = function () {
 };
 module.exports.tableFlattening = transformer;
 
+/***/ }),
+
+/***/ 8192:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "singleCodeTabs": () => (/* reexport */ single_code_tabs)
+});
+
+;// CONCATENATED MODULE: ./node_modules/unist-util-visit/node_modules/unist-util-is/index.js
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('unist').Parent} Parent
+ *
+ * @typedef {string} Type
+ * @typedef {Object<string, unknown>} Props
+ *
+ * @typedef {null|undefined|Type|Props|TestFunctionAnything|Array.<Type|Props|TestFunctionAnything>} Test
+ */
+
+/**
+ * Check if a node passes a test
+ *
+ * @callback TestFunctionAnything
+ * @param {Node} node
+ * @param {number|null|undefined} [index]
+ * @param {Parent|null|undefined} [parent]
+ * @returns {boolean|void}
+ */
+
+/**
+ * Check if a node passes a certain node test
+ *
+ * @template {Node} X
+ * @callback TestFunctionPredicate
+ * @param {Node} node
+ * @param {number|null|undefined} [index]
+ * @param {Parent|null|undefined} [parent]
+ * @returns {node is X}
+ */
+
+/**
+ * @callback AssertAnything
+ * @param {unknown} [node]
+ * @param {number|null|undefined} [index]
+ * @param {Parent|null|undefined} [parent]
+ * @returns {boolean}
+ */
+
+/**
+ * Check if a node passes a certain node test
+ *
+ * @template {Node} Y
+ * @callback AssertPredicate
+ * @param {unknown} [node]
+ * @param {number|null|undefined} [index]
+ * @param {Parent|null|undefined} [parent]
+ * @returns {node is Y}
+ */
+
+const is =
+  /**
+   * Check if a node passes a test.
+   * When a `parent` node is known the `index` of node should also be given.
+   *
+   * @type {(
+   *   (<T extends Node>(node: unknown, test: T['type']|Partial<T>|TestFunctionPredicate<T>|Array.<T['type']|Partial<T>|TestFunctionPredicate<T>>, index?: number|null|undefined, parent?: Parent|null|undefined, context?: unknown) => node is T) &
+   *   ((node?: unknown, test?: Test, index?: number|null|undefined, parent?: Parent|null|undefined, context?: unknown) => boolean)
+   * )}
+   */
+  (
+    /**
+     * Check if a node passes a test.
+     * When a `parent` node is known the `index` of node should also be given.
+     *
+     * @param {unknown} [node] Node to check
+     * @param {Test} [test]
+     * When nullish, checks if `node` is a `Node`.
+     * When `string`, works like passing `function (node) {return node.type === test}`.
+     * When `function` checks if function passed the node is true.
+     * When `object`, checks that all keys in test are in node, and that they have (strictly) equal values.
+     * When `array`, checks any one of the subtests pass.
+     * @param {number|null|undefined} [index] Position of `node` in `parent`
+     * @param {Parent|null|undefined} [parent] Parent of `node`
+     * @param {unknown} [context] Context object to invoke `test` with
+     * @returns {boolean} Whether test passed and `node` is a `Node` (object with `type` set to non-empty `string`).
+     */
+    // eslint-disable-next-line max-params
+    function is(node, test, index, parent, context) {
+      const check = convert(test)
+
+      if (
+        index !== undefined &&
+        index !== null &&
+        (typeof index !== 'number' ||
+          index < 0 ||
+          index === Number.POSITIVE_INFINITY)
+      ) {
+        throw new Error('Expected positive finite index')
+      }
+
+      if (
+        parent !== undefined &&
+        parent !== null &&
+        (!is(parent) || !parent.children)
+      ) {
+        throw new Error('Expected parent node')
+      }
+
+      if (
+        (parent === undefined || parent === null) !==
+        (index === undefined || index === null)
+      ) {
+        throw new Error('Expected both parent and index')
+      }
+
+      // @ts-expect-error Looks like a node.
+      return node && node.type && typeof node.type === 'string'
+        ? Boolean(check.call(context, node, index, parent))
+        : false
+    }
+  )
+
+const convert =
+  /**
+   * @type {(
+   *   (<T extends Node>(test: T['type']|Partial<T>|TestFunctionPredicate<T>) => AssertPredicate<T>) &
+   *   ((test?: Test) => AssertAnything)
+   * )}
+   */
+  (
+    /**
+     * Generate an assertion from a check.
+     * @param {Test} [test]
+     * When nullish, checks if `node` is a `Node`.
+     * When `string`, works like passing `function (node) {return node.type === test}`.
+     * When `function` checks if function passed the node is true.
+     * When `object`, checks that all keys in test are in node, and that they have (strictly) equal values.
+     * When `array`, checks any one of the subtests pass.
+     * @returns {AssertAnything}
+     */
+    function (test) {
+      if (test === undefined || test === null) {
+        return ok
+      }
+
+      if (typeof test === 'string') {
+        return typeFactory(test)
+      }
+
+      if (typeof test === 'object') {
+        return Array.isArray(test) ? anyFactory(test) : propsFactory(test)
+      }
+
+      if (typeof test === 'function') {
+        return castFactory(test)
+      }
+
+      throw new Error('Expected function, string, or object as test')
+    }
+  )
+/**
+ * @param {Array.<Type|Props|TestFunctionAnything>} tests
+ * @returns {AssertAnything}
+ */
+function anyFactory(tests) {
+  /** @type {Array.<AssertAnything>} */
+  const checks = []
+  let index = -1
+
+  while (++index < tests.length) {
+    checks[index] = convert(tests[index])
+  }
+
+  return castFactory(any)
+
+  /**
+   * @this {unknown}
+   * @param {unknown[]} parameters
+   * @returns {boolean}
+   */
+  function any(...parameters) {
+    let index = -1
+
+    while (++index < checks.length) {
+      if (checks[index].call(this, ...parameters)) return true
+    }
+
+    return false
+  }
+}
+
+/**
+ * Utility to assert each property in `test` is represented in `node`, and each
+ * values are strictly equal.
+ *
+ * @param {Props} check
+ * @returns {AssertAnything}
+ */
+function propsFactory(check) {
+  return castFactory(all)
+
+  /**
+   * @param {Node} node
+   * @returns {boolean}
+   */
+  function all(node) {
+    /** @type {string} */
+    let key
+
+    for (key in check) {
+      // @ts-expect-error: hush, it sure works as an index.
+      if (node[key] !== check[key]) return false
+    }
+
+    return true
+  }
+}
+
+/**
+ * Utility to convert a string into a function which checks a given node’s type
+ * for said string.
+ *
+ * @param {Type} check
+ * @returns {AssertAnything}
+ */
+function typeFactory(check) {
+  return castFactory(type)
+
+  /**
+   * @param {Node} node
+   */
+  function type(node) {
+    return node && node.type === check
+  }
+}
+
+/**
+ * Utility to convert a string into a function which checks a given node’s type
+ * for said string.
+ * @param {TestFunctionAnything} check
+ * @returns {AssertAnything}
+ */
+function castFactory(check) {
+  return assertion
+
+  /**
+   * @this {unknown}
+   * @param {Array.<unknown>} parameters
+   * @returns {boolean}
+   */
+  function assertion(...parameters) {
+    // @ts-expect-error: spreading is fine.
+    return Boolean(check.call(this, ...parameters))
+  }
+}
+
+// Utility to return true.
+function ok() {
+  return true
+}
+
+;// CONCATENATED MODULE: ./node_modules/unist-util-visit/node_modules/unist-util-visit-parents/color.browser.js
+/**
+ * @param {string} d
+ * @returns {string}
+ */
+function color(d) {
+  return d
+}
+
+;// CONCATENATED MODULE: ./node_modules/unist-util-visit/node_modules/unist-util-visit-parents/index.js
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('unist').Parent} Parent
+ * @typedef {import('unist-util-is').Test} Test
+ * @typedef {import('./complex-types.js').Action} Action
+ * @typedef {import('./complex-types.js').Index} Index
+ * @typedef {import('./complex-types.js').ActionTuple} ActionTuple
+ * @typedef {import('./complex-types.js').VisitorResult} VisitorResult
+ * @typedef {import('./complex-types.js').Visitor} Visitor
+ */
+
+
+
+
+/**
+ * Continue traversing as normal
+ */
+const CONTINUE = true
+/**
+ * Do not traverse this node’s children
+ */
+const SKIP = 'skip'
+/**
+ * Stop traversing immediately
+ */
+const EXIT = false
+
+/**
+ * Visit children of tree which pass test.
+ *
+ * @param tree
+ *   Tree to walk
+ * @param [test]
+ *   `unist-util-is`-compatible test
+ * @param visitor
+ *   Function called for nodes that pass `test`.
+ * @param [reverse=false]
+ *   Traverse in reverse preorder (NRL) instead of preorder (NLR) (default).
+ */
+const visitParents =
+  /**
+   * @type {(
+   *   (<Tree extends Node, Check extends Test>(tree: Tree, test: Check, visitor: import('./complex-types.js').BuildVisitor<Tree, Check>, reverse?: boolean) => void) &
+   *   (<Tree extends Node>(tree: Tree, visitor: import('./complex-types.js').BuildVisitor<Tree>, reverse?: boolean) => void)
+   * )}
+   */
+  (
+    /**
+     * @param {Node} tree
+     * @param {Test} test
+     * @param {import('./complex-types.js').Visitor<Node>} visitor
+     * @param {boolean} [reverse=false]
+     */
+    function (tree, test, visitor, reverse) {
+      if (typeof test === 'function' && typeof visitor !== 'function') {
+        reverse = visitor
+        // @ts-expect-error no visitor given, so `visitor` is test.
+        visitor = test
+        test = null
+      }
+
+      const is = convert(test)
+      const step = reverse ? -1 : 1
+
+      factory(tree, null, [])()
+
+      /**
+       * @param {Node} node
+       * @param {number?} index
+       * @param {Array<Parent>} parents
+       */
+      function factory(node, index, parents) {
+        /** @type {Record<string, unknown>} */
+        // @ts-expect-error: hush
+        const value = typeof node === 'object' && node !== null ? node : {}
+        /** @type {string|undefined} */
+        let name
+
+        if (typeof value.type === 'string') {
+          name =
+            typeof value.tagName === 'string'
+              ? value.tagName
+              : typeof value.name === 'string'
+              ? value.name
+              : undefined
+
+          Object.defineProperty(visit, 'name', {
+            value:
+              'node (' +
+              color(value.type + (name ? '<' + name + '>' : '')) +
+              ')'
+          })
+        }
+
+        return visit
+
+        function visit() {
+          /** @type {ActionTuple} */
+          let result = []
+          /** @type {ActionTuple} */
+          let subresult
+          /** @type {number} */
+          let offset
+          /** @type {Array<Parent>} */
+          let grandparents
+
+          if (!test || is(node, index, parents[parents.length - 1] || null)) {
+            result = toResult(visitor(node, parents))
+
+            if (result[0] === EXIT) {
+              return result
+            }
+          }
+
+          // @ts-expect-error looks like a parent.
+          if (node.children && result[0] !== SKIP) {
+            // @ts-expect-error looks like a parent.
+            offset = (reverse ? node.children.length : -1) + step
+            // @ts-expect-error looks like a parent.
+            grandparents = parents.concat(node)
+
+            // @ts-expect-error looks like a parent.
+            while (offset > -1 && offset < node.children.length) {
+              // @ts-expect-error looks like a parent.
+              subresult = factory(node.children[offset], offset, grandparents)()
+
+              if (subresult[0] === EXIT) {
+                return subresult
+              }
+
+              offset =
+                typeof subresult[1] === 'number' ? subresult[1] : offset + step
+            }
+          }
+
+          return result
+        }
+      }
+    }
+  )
+
+/**
+ * @param {VisitorResult} value
+ * @returns {ActionTuple}
+ */
+function toResult(value) {
+  if (Array.isArray(value)) {
+    return value
+  }
+
+  if (typeof value === 'number') {
+    return [CONTINUE, value]
+  }
+
+  return [value]
+}
+
+;// CONCATENATED MODULE: ./node_modules/unist-util-visit/index.js
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('unist').Parent} Parent
+ * @typedef {import('unist-util-is').Test} Test
+ * @typedef {import('unist-util-visit-parents').VisitorResult} VisitorResult
+ * @typedef {import('./complex-types.js').Visitor} Visitor
+ */
+
+
+
+/**
+ * Visit children of tree which pass test.
+ *
+ * @param tree
+ *   Tree to walk
+ * @param [test]
+ *   `unist-util-is`-compatible test
+ * @param visitor
+ *   Function called for nodes that pass `test`.
+ * @param reverse
+ *   Traverse in reverse preorder (NRL) instead of preorder (NLR) (default).
+ */
+const visit =
+  /**
+   * @type {(
+   *   (<Tree extends Node, Check extends Test>(tree: Tree, test: Check, visitor: import('./complex-types.js').BuildVisitor<Tree, Check>, reverse?: boolean) => void) &
+   *   (<Tree extends Node>(tree: Tree, visitor: import('./complex-types.js').BuildVisitor<Tree>, reverse?: boolean) => void)
+   * )}
+   */
+  (
+    /**
+     * @param {Node} tree
+     * @param {Test} test
+     * @param {import('./complex-types.js').Visitor} visitor
+     * @param {boolean} [reverse]
+     */
+    function (tree, test, visitor, reverse) {
+      if (typeof test === 'function' && typeof visitor !== 'function') {
+        reverse = visitor
+        visitor = test
+        test = null
+      }
+
+      visitParents(tree, test, overload, reverse)
+
+      /**
+       * @param {Node} node
+       * @param {Array<Parent>} parents
+       */
+      function overload(node, parents) {
+        const parent = parents[parents.length - 1]
+        return visitor(
+          node,
+          parent ? parent.children.indexOf(node) : null,
+          parent
+        )
+      }
+    }
+  )
+
+
+
+;// CONCATENATED MODULE: ./processor/transform/single-code-tabs.js
+
+var singleCodeTabs = function singleCodeTabs() {
+  return function (tree) {
+    return visit(tree, function (node, index, parent) {
+      if (node.type === 'code' && (node.lang || node.meta) && parent.type !== 'code-tabs') {
+        node.data = {
+          hName: 'code',
+          hProperties: {
+            meta: node.meta,
+            lang: node.lang
+          }
+        };
+        parent.children[index] = {
+          type: 'code-tabs',
+          className: 'tabs',
+          data: {
+            hName: 'code-tabs'
+          },
+          children: [node]
+        };
+      }
+    });
+  };
+};
+/* harmony default export */ const single_code_tabs = (singleCodeTabs);
+;// CONCATENATED MODULE: ./processor/transform/index.js
+
+
 /***/ }),
 
 /***/ 8229:
@@ -28343,7 +28865,7 @@ function parse(selector, defaultTagName) {
 
 var Parser = __webpack_require__(6425)
 var pos = __webpack_require__(7361)
-var visit = __webpack_require__(2854)
+var visit = __webpack_require__(2409)
 var fromParse5 = __webpack_require__(7721)
 var toParse5 = __webpack_require__(8335)
 var voids = __webpack_require__(9878)
@@ -28678,6 +29200,240 @@ function createParse5Location(node) {
 }
 
 
+/***/ }),
+
+/***/ 8442:
+/***/ ((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
+}
+
+
+/***/ }),
+
+/***/ 5962:
+/***/ ((module) => {
+
+module.exports = identity
+function identity(d) {
+  return d
+}
+
+
+/***/ }),
+
+/***/ 1106:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+module.exports = visitParents
+
+var convert = __webpack_require__(8442)
+var color = __webpack_require__(5962)
+
+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]
+}
+
+
+/***/ }),
+
+/***/ 2409:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+module.exports = visit
+
+var visitParents = __webpack_require__(1106)
+
+var CONTINUE = visitParents.CONTINUE
+var SKIP = visitParents.SKIP
+var EXIT = visitParents.EXIT
+
+visit.CONTINUE = CONTINUE
+visit.SKIP = SKIP
+visit.EXIT = EXIT
+
+function visit(tree, test, visitor, reverse) {
+  if (typeof test === 'function' && typeof visitor !== 'function') {
+    reverse = visitor
+    visitor = test
+    test = null
+  }
+
+  visitParents(tree, test, overload, reverse)
+
+  function overload(node, parents) {
+    var parent = parents[parents.length - 1]
+    var index = parent ? parent.children.indexOf(node) : null
+    return visitor(node, index, parent)
+  }
+}
+
+
 /***/ }),
 
 /***/ 773:
@@ -31482,7 +32238,7 @@ function toAlignment(value) {
 "use strict";
 
 
-var visit = __webpack_require__(2854)
+var visit = __webpack_require__(8212)
 
 module.exports = compact
 
@@ -31543,6 +32299,240 @@ function mergeable(node, commonmark) {
 }
 
 
+/***/ }),
+
+/***/ 8081:
+/***/ ((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
+}
+
+
+/***/ }),
+
+/***/ 7260:
+/***/ ((module) => {
+
+module.exports = identity
+function identity(d) {
+  return d
+}
+
+
+/***/ }),
+
+/***/ 8261:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+module.exports = visitParents
+
+var convert = __webpack_require__(8081)
+var color = __webpack_require__(7260)
+
+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]
+}
+
+
+/***/ }),
+
+/***/ 8212:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+module.exports = visit
+
+var visitParents = __webpack_require__(8261)
+
+var CONTINUE = visitParents.CONTINUE
+var SKIP = visitParents.SKIP
+var EXIT = visitParents.EXIT
+
+visit.CONTINUE = CONTINUE
+visit.SKIP = SKIP
+visit.EXIT = EXIT
+
+function visit(tree, test, visitor, reverse) {
+  if (typeof test === 'function' && typeof visitor !== 'function') {
+    reverse = visitor
+    visitor = test
+    test = null
+  }
+
+  visitParents(tree, test, overload, reverse)
+
+  function overload(node, parents) {
+    var parent = parents[parents.length - 1]
+    var index = parent ? parent.children.indexOf(node) : null
+    return visitor(node, index, parent)
+  }
+}
+
+
 /***/ }),
 
 /***/ 6630:
@@ -31551,7 +32541,7 @@ function mergeable(node, commonmark) {
 "use strict";
 
 
-var visit = __webpack_require__(2854)
+var visit = __webpack_require__(959)
 
 module.exports = getDefinitionFactory
 
@@ -31602,6 +32592,240 @@ function normalise(identifier) {
 }
 
 
+/***/ }),
+
+/***/ 9626:
+/***/ ((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
+}
+
+
+/***/ }),
+
+/***/ 6702:
+/***/ ((module) => {
+
+module.exports = identity
+function identity(d) {
+  return d
+}
+
+
+/***/ }),
+
+/***/ 9692:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+module.exports = visitParents
+
+var convert = __webpack_require__(9626)
+var color = __webpack_require__(6702)
+
+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]
+}
+
+
+/***/ }),
+
+/***/ 959:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+module.exports = visit
+
+var visitParents = __webpack_require__(9692)
+
+var CONTINUE = visitParents.CONTINUE
+var SKIP = visitParents.SKIP
+var EXIT = visitParents.EXIT
+
+visit.CONTINUE = CONTINUE
+visit.SKIP = SKIP
+visit.EXIT = EXIT
+
+function visit(tree, test, visitor, reverse) {
+  if (typeof test === 'function' && typeof visitor !== 'function') {
+    reverse = visitor
+    visitor = test
+    test = null
+  }
+
+  visitParents(tree, test, overload, reverse)
+
+  function overload(node, parents) {
+    var parent = parents[parents.length - 1]
+    var index = parent ? parent.children.indexOf(node) : null
+    return visitor(node, index, parent)
+  }
+}
+
+
 /***/ }),
 
 /***/ 5288:
@@ -32400,7 +33624,7 @@ function thematicBreak(h, node) {
 module.exports = toHast
 
 var u = __webpack_require__(914)
-var visit = __webpack_require__(2854)
+var visit = __webpack_require__(8681)
 var position = __webpack_require__(7361)
 var generated = __webpack_require__(1744)
 var definitions = __webpack_require__(6630)
@@ -32661,6 +33885,240 @@ function wrap(nodes, loose) {
 }
 
 
+/***/ }),
+
+/***/ 8189:
+/***/ ((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
+}
+
+
+/***/ }),
+
+/***/ 9007:
+/***/ ((module) => {
+
+module.exports = identity
+function identity(d) {
+  return d
+}
+
+
+/***/ }),
+
+/***/ 9255:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+module.exports = visitParents
+
+var convert = __webpack_require__(8189)
+var color = __webpack_require__(9007)
+
+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]
+}
+
+
+/***/ }),
+
+/***/ 8681:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+module.exports = visit
+
+var visitParents = __webpack_require__(9255)
+
+var CONTINUE = visitParents.CONTINUE
+var SKIP = visitParents.SKIP
+var EXIT = visitParents.EXIT
+
+visit.CONTINUE = CONTINUE
+visit.SKIP = SKIP
+visit.EXIT = EXIT
+
+function visit(tree, test, visitor, reverse) {
+  if (typeof test === 'function' && typeof visitor !== 'function') {
+    reverse = visitor
+    visitor = test
+    test = null
+  }
+
+  visitParents(tree, test, overload, reverse)
+
+  function overload(node, parents) {
+    var parent = parents[parents.length - 1]
+    var index = parent ? parent.children.indexOf(node) : null
+    return visitor(node, index, parent)
+  }
+}
+
+
 /***/ }),
 
 /***/ 4999:
@@ -32901,7 +34359,7 @@ function toc(node, options) {
 module.exports = search
 
 var toString = __webpack_require__(8161)
-var visit = __webpack_require__(2854)
+var visit = __webpack_require__(4290)
 var convert = __webpack_require__(6351)
 var slugs = __webpack_require__(9671)()
 var toExpression = __webpack_require__(6039)
@@ -33101,6 +34559,155 @@ function ok() {
 }
 
 
+/***/ }),
+
+/***/ 1674:
+/***/ ((module) => {
+
+module.exports = identity
+function identity(d) {
+  return d
+}
+
+
+/***/ }),
+
+/***/ 3623:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+module.exports = visitParents
+
+var convert = __webpack_require__(6351)
+var color = __webpack_require__(1674)
+
+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]
+}
+
+
+/***/ }),
+
+/***/ 4290:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+module.exports = visit
+
+var visitParents = __webpack_require__(3623)
+
+var CONTINUE = visitParents.CONTINUE
+var SKIP = visitParents.SKIP
+var EXIT = visitParents.EXIT
+
+visit.CONTINUE = CONTINUE
+visit.SKIP = SKIP
+visit.EXIT = EXIT
+
+function visit(tree, test, visitor, reverse) {
+  if (typeof test === 'function' && typeof visitor !== 'function') {
+    reverse = visitor
+    visitor = test
+    test = null
+  }
+
+  visitParents(tree, test, overload, reverse)
+
+  function overload(node, parents) {
+    var parent = parents[parents.length - 1]
+    var index = parent ? parent.children.indexOf(node) : null
+    return visitor(node, index, parent)
+  }
+}
+
+
 /***/ }),
 
 /***/ 729:
@@ -41419,7 +43026,7 @@ function mutate(options) {
 
 
 var toString = __webpack_require__(4999)
-var visit = __webpack_require__(2854)
+var visit = __webpack_require__(4195)
 var slugs = __webpack_require__(9671)()
 
 module.exports = slug
@@ -41447,6 +43054,240 @@ function transformer(ast) {
 }
 
 
+/***/ }),
+
+/***/ 5721:
+/***/ ((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
+}
+
+
+/***/ }),
+
+/***/ 2583:
+/***/ ((module) => {
+
+module.exports = identity
+function identity(d) {
+  return d
+}
+
+
+/***/ }),
+
+/***/ 6751:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+module.exports = visitParents
+
+var convert = __webpack_require__(5721)
+var color = __webpack_require__(2583)
+
+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]
+}
+
+
+/***/ }),
+
+/***/ 4195:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+module.exports = visit
+
+var visitParents = __webpack_require__(6751)
+
+var CONTINUE = visitParents.CONTINUE
+var SKIP = visitParents.SKIP
+var EXIT = visitParents.EXIT
+
+visit.CONTINUE = CONTINUE
+visit.SKIP = SKIP
+visit.EXIT = EXIT
+
+function visit(tree, test, visitor, reverse) {
+  if (typeof test === 'function' && typeof visitor !== 'function') {
+    reverse = visitor
+    visitor = test
+    test = null
+  }
+
+  visitParents(tree, test, overload, reverse)
+
+  function overload(node, parents) {
+    var parent = parents[parents.length - 1]
+    var index = parent ? parent.children.indexOf(node) : null
+    return visitor(node, index, parent)
+  }
+}
+
+
 /***/ }),
 
 /***/ 3734:
@@ -45703,267 +47544,6 @@ function toResult(value) {
 }
 
 
-/***/ }),
-
-/***/ 2854:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-"use strict";
-
-
-module.exports = visit
-
-var visitParents = __webpack_require__(9858)
-
-var CONTINUE = visitParents.CONTINUE
-var SKIP = visitParents.SKIP
-var EXIT = visitParents.EXIT
-
-visit.CONTINUE = CONTINUE
-visit.SKIP = SKIP
-visit.EXIT = EXIT
-
-function visit(tree, test, visitor, reverse) {
-  if (typeof test === 'function' && typeof visitor !== 'function') {
-    reverse = visitor
-    visitor = test
-    test = null
-  }
-
-  visitParents(tree, test, overload, reverse)
-
-  function overload(node, parents) {
-    var parent = parents[parents.length - 1]
-    var index = parent ? parent.children.indexOf(node) : null
-    return visitor(node, index, parent)
-  }
-}
-
-
-/***/ }),
-
-/***/ 350:
-/***/ ((module) => {
-
-"use strict";
-
-
-module.exports = convert
-
-function convert(test) {
-  if (typeof test === 'string') {
-    return typeFactory(test)
-  }
-
-  if (test === null || test === undefined) {
-    return ok
-  }
-
-  if (typeof test === 'object') {
-    return ('length' in test ? anyFactory : matchesFactory)(test)
-  }
-
-  if (typeof test === 'function') {
-    return test
-  }
-
-  throw new Error('Expected function, string, or object as test')
-}
-
-function convertAll(tests) {
-  var results = []
-  var length = tests.length
-  var index = -1
-
-  while (++index < length) {
-    results[index] = convert(tests[index])
-  }
-
-  return results
-}
-
-// Utility assert each property in `test` is represented in `node`, and each
-// values are strictly equal.
-function matchesFactory(test) {
-  return matches
-
-  function matches(node) {
-    var key
-
-    for (key in test) {
-      if (node[key] !== test[key]) {
-        return false
-      }
-    }
-
-    return true
-  }
-}
-
-function anyFactory(tests) {
-  var checks = convertAll(tests)
-  var length = checks.length
-
-  return matches
-
-  function matches() {
-    var index = -1
-
-    while (++index < 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
-}
-
-
-/***/ }),
-
-/***/ 9824:
-/***/ ((module) => {
-
-module.exports = identity
-function identity(d) {
-  return d
-}
-
-
-/***/ }),
-
-/***/ 9858:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-"use strict";
-
-
-module.exports = visitParents
-
-var convert = __webpack_require__(350)
-var color = __webpack_require__(9824)
-
-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 is
-
-  if (func(test) && !func(visitor)) {
-    reverse = visitor
-    visitor = test
-    test = null
-  }
-
-  is = convert(test)
-
-  one(tree, null, [])()
-
-  function one(child, index, parents) {
-    var value = object(child) ? child : {}
-    var name
-
-    if (string(value.type)) {
-      name = string(value.tagName)
-        ? value.tagName
-        : string(value.name)
-        ? value.name
-        : undefined
-
-      node.displayName =
-        'node (' + color(value.type + (name ? '<' + name + '>' : '')) + ')'
-    }
-
-    return node
-
-    function node() {
-      var result = []
-      var subresult
-
-      if (!test || is(child, index, parents[parents.length - 1] || null)) {
-        result = toResult(visitor(child, parents))
-
-        if (result[0] === EXIT) {
-          return result
-        }
-      }
-
-      if (!child.children || result[0] === SKIP) {
-        return result
-      }
-
-      subresult = toResult(children(child.children, parents.concat(child)))
-      return subresult[0] === EXIT ? subresult : result
-    }
-  }
-
-  // Visit children in `parent`.
-  function children(children, parents) {
-    var min = -1
-    var step = reverse ? -1 : 1
-    var index = (reverse ? children.length : min) + step
-    var child
-    var result
-
-    while (index > min && index < children.length) {
-      child = children[index]
-      result = one(child, index, parents)()
-
-      if (result[0] === EXIT) {
-        return result
-      }
-
-      index = typeof result[1] === 'number' ? result[1] : index + step
-    }
-  }
-}
-
-function toResult(value) {
-  if (object(value) && 'length' in value) {
-    return value
-  }
-
-  if (typeof value === 'number') {
-    return [CONTINUE, value]
-  }
-
-  return [value]
-}
-
-function func(d) {
-  return typeof d === 'function'
-}
-
-function string(d) {
-  return typeof d === 'string'
-}
-
-function object(d) {
-  return typeof d === 'object' && d !== null
-}
-
-
 /***/ }),
 
 /***/ 4787:
@@ -48892,6 +50472,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__),
 /* harmony export */   "hast": () => (/* binding */ hast),
 /* harmony export */   "html": () => (/* binding */ html),
+/* harmony export */   "htmlProcessor": () => (/* binding */ htmlProcessor),
 /* harmony export */   "md": () => (/* binding */ md),
 /* harmony export */   "mdast": () => (/* binding */ mdast),
 /* harmony export */   "plain": () => (/* binding */ plain),
@@ -48944,6 +50525,7 @@ var _require5 = __webpack_require__(6284),
 var toPlainText = __webpack_require__(4792);
 var sectionAnchorId = __webpack_require__(9620);
 var tableFlattening = __webpack_require__(4625);
+var transformers = Object.values(__webpack_require__(8192));
 var createSchema = __webpack_require__(8229);
 var GlossaryItem = Components.GlossaryItem,
   Code = Components.Code,
@@ -48992,7 +50574,7 @@ var utils = {
 };
 
 /**
- * Core markdown text processor
+ * Core markdown to mdast processor
  */
 function processor() {
   var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
@@ -49004,7 +50586,39 @@ function processor() {
   return unified().use(remarkParse, opts.markdownOptions).use(remarkFrontmatter, ['yaml', 'toml']).data('settings', opts.settings).data('compatibilityMode', opts.compatibilityMode).data('alwaysThrow', opts.alwaysThrow).use(!opts.correctnewlines ? remarkBreaks : function () {}).use(CustomParsers.map(function (parser) {
     var _parser$sanitize;
     return ((_parser$sanitize = parser.sanitize) === null || _parser$sanitize === void 0 ? void 0 : _parser$sanitize.call(parser, sanitize)) || parser;
-  })).use(remarkSlug).use(remarkDisableTokenizers, opts.disableTokenizers).use(remarkRehype, {
+  })).use(transformers).use(remarkSlug).use(remarkDisableTokenizers, opts.disableTokenizers);
+}
+
+/**
+ * Full markdown to html processor
+ */
+function htmlProcessor() {
+  var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var _setup3 = setup('', opts);
+  var _setup4 = (0,_babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(_setup3, 2);
+  opts = _setup4[1];
+  var _opts2 = opts,
+    sanitize = _opts2.sanitize;
+
+  /*
+   * This is kinda complicated: "markdown" within ReadMe is
+   * often more than just markdown. It can also include HTML,
+   * as well as custom syntax constructs such as <<variables>>,
+   * and other special features.
+   *
+   * We use the Unified text processor to parse and transform
+   * Markdown to various output formats, such as a React component
+   * tree. (See https://github.com/unifiedjs/unified for more.)
+   *
+   * The order for processing ReadMe-flavored markdown is as follows:
+   * - parse markdown
+   * - parse custom syntaxes add-ons using custom compilers
+   * - convert from a remark mdast (markdown ast) to a rehype hast (hypertext ast)
+   * - extract any raw HTML elements
+   * - sanitize and remove any disallowed attributes
+   * - output the hast to a React vdom with our custom components
+   */
+  return processor(opts).use(remarkRehype, {
     allowDangerousHtml: true
   }).use(rehypeRaw).use(rehypeSanitize, sanitize);
 }
@@ -49012,11 +50626,11 @@ function plain(text) {
   var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   var components = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   if (!text) return null;
-  var _setup3 = setup(text, opts);
-  var _setup4 = (0,_babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(_setup3, 2);
-  text = _setup4[0];
-  opts = _setup4[1];
-  return processor(opts).use(rehypeReact, {
+  var _setup5 = setup(text, opts);
+  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, {
     createElement: React.createElement,
     Fragment: React.Fragment,
     components: components
@@ -49033,16 +50647,16 @@ var PinWrap = function PinWrap(_ref) {
     className: "pin"
   }, children);
 }; // @todo: move this to it's own component
-var count = {};
+
 function reactProcessor() {
   var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
   var components = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  var _setup5 = setup('', opts);
-  var _setup6 = (0,_babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(_setup5, 2);
-  opts = _setup6[1];
-  var _opts2 = opts,
-    sanitize = _opts2.sanitize;
-  return processor(_objectSpread({
+  var _setup7 = setup('', opts);
+  var _setup8 = (0,_babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(_setup7, 2);
+  opts = _setup8[1];
+  var _opts3 = opts,
+    sanitize = _opts3.sanitize;
+  return htmlProcessor(_objectSpread({
     sanitize: sanitize
   }, opts)).use(sectionAnchorId).use(rehypeReact, {
     createElement: React.createElement,
@@ -49057,12 +50671,12 @@ function reactProcessor() {
       'rdme-pin': PinWrap,
       table: Table,
       a: Anchor,
-      h1: Heading(1, count, opts),
-      h2: Heading(2, count, opts),
-      h3: Heading(3, count, opts),
-      h4: Heading(4, count, opts),
-      h5: Heading(5, count, opts),
-      h6: Heading(6, count, opts),
+      h1: Heading(1, opts),
+      h2: Heading(2, opts),
+      h3: Heading(3, opts),
+      h4: Heading(4, opts),
+      h5: Heading(5, opts),
+      h6: Heading(6, opts),
       code: Code(opts),
       img: Image(opts),
       style: Style(opts)
@@ -49073,14 +50687,14 @@ function react(content) {
   var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   var components = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   if (!content) return null;else if (typeof content === 'string') {
-    var _setup7 = setup(content, opts);
-    var _setup8 = (0,_babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(_setup7, 2);
-    content = _setup8[0];
-    opts = _setup8[1];
-  } else {
-    var _setup9 = setup('', opts);
+    var _setup9 = setup(content, opts);
     var _setup10 = (0,_babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(_setup9, 2);
+    content = _setup10[0];
     opts = _setup10[1];
+  } else {
+    var _setup11 = setup('', opts);
+    var _setup12 = (0,_babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(_setup11, 2);
+    opts = _setup12[1];
   }
   var proc = reactProcessor(opts, components);
   if (typeof content === 'string') content = proc.parse(content);
@@ -49089,10 +50703,10 @@ function react(content) {
 function reactTOC(tree) {
   var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   if (!tree) return null;
-  var _setup11 = setup('', opts);
-  var _setup12 = (0,_babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(_setup11, 2);
-  opts = _setup12[1];
-  var proc = processor(opts).use(rehypeReact, {
+  var _setup13 = setup('', opts);
+  var _setup14 = (0,_babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(_setup13, 2);
+  opts = _setup14[1];
+  var proc = htmlProcessor(opts).use(rehypeReact, {
     createElement: React.createElement,
     components: {
       p: React.Fragment,
@@ -49123,11 +50737,11 @@ function reactTOC(tree) {
 function html(text) {
   var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   if (!text) return null;
-  var _setup13 = setup(text, opts);
-  var _setup14 = (0,_babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(_setup13, 2);
-  text = _setup14[0];
-  opts = _setup14[1];
-  return processor(opts).use(rehypeStringify).processSync(text).contents;
+  var _setup15 = setup(text, opts);
+  var _setup16 = (0,_babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(_setup15, 2);
+  text = _setup16[0];
+  opts = _setup16[1];
+  return htmlProcessor(opts).use(rehypeStringify).processSync(text).contents;
 }
 
 /**
@@ -49136,11 +50750,11 @@ function html(text) {
 function hast(text) {
   var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   if (!text) return null;
-  var _setup15 = setup(text, opts);
-  var _setup16 = (0,_babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(_setup15, 2);
-  text = _setup16[0];
-  opts = _setup16[1];
-  var rdmd = processor(opts).use(tableFlattening);
+  var _setup17 = setup(text, opts);
+  var _setup18 = (0,_babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(_setup17, 2);
+  text = _setup18[0];
+  opts = _setup18[1];
+  var rdmd = htmlProcessor(opts).use(tableFlattening);
   var node = rdmd.parse(text);
   return rdmd.runSync(node);
 }
@@ -49151,11 +50765,12 @@ function hast(text) {
 function mdast(text) {
   var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   if (!text) return null;
-  var _setup17 = setup(text, opts);
-  var _setup18 = (0,_babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(_setup17, 2);
-  text = _setup18[0];
-  opts = _setup18[1];
-  return processor(opts).parse(text);
+  var _setup19 = setup(text, opts);
+  var _setup20 = (0,_babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(_setup19, 2);
+  text = _setup20[0];
+  opts = _setup20[1];
+  var rdmd = processor(opts);
+  return rdmd.runSync(rdmd.parse(text));
 }
 
 /**
@@ -49164,9 +50779,9 @@ function mdast(text) {
 function astToPlainText(node) {
   var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   if (!node) return '';
-  var _setup19 = setup('', opts);
-  var _setup20 = (0,_babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(_setup19, 2);
-  opts = _setup20[1];
+  var _setup21 = setup('', opts);
+  var _setup22 = (0,_babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(_setup21, 2);
+  opts = _setup22[1];
   return processor(opts).use(toPlainText).stringify(node);
 }
 
@@ -49176,9 +50791,9 @@ function astToPlainText(node) {
 function md(tree) {
   var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   if (!tree) return null;
-  var _setup21 = setup('', opts);
-  var _setup22 = (0,_babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(_setup21, 2);
-  opts = _setup22[1];
+  var _setup23 = setup('', opts);
+  var _setup24 = (0,_babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(_setup23, 2);
+  opts = _setup24[1];
   return processor(opts).use(remarkStringify, opts.markdownOptions).use(customCompilers).stringify(tree);
 }
 var ReadMeMarkdown = function ReadMeMarkdown(text) {