@readme/markdown 6.67.0 → 6.68.0-beta.2

package/dist/main.js

@@ -8507,6 +8507,7 @@ var options = {
   },
   lazyImages: true,
   normalize: true,
+  reusableContent: {},
   safeMode: false,
   settings: {
     position: false
@@ -8785,61 +8786,95 @@ module.exports = function ImageCompiler() {
 
 /***/ }),
 
-/***/ 9647:
+/***/ 8457:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
+// ESM COMPAT FLAG
 __webpack_require__.r(__webpack_exports__);
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   "breakCompiler": () => (/* reexport default from dynamic */ _break__WEBPACK_IMPORTED_MODULE_0___default.a),
-/* harmony export */   "codeTabsCompiler": () => (/* reexport default from dynamic */ _code_tabs__WEBPACK_IMPORTED_MODULE_1___default.a),
-/* harmony export */   "divCompiler": () => (/* reexport default from dynamic */ _div__WEBPACK_IMPORTED_MODULE_2___default.a),
-/* harmony export */   "escapeCompiler": () => (/* reexport default from dynamic */ _escape__WEBPACK_IMPORTED_MODULE_3___default.a),
-/* harmony export */   "figureCompiler": () => (/* reexport default from dynamic */ _figure__WEBPACK_IMPORTED_MODULE_4___default.a),
-/* harmony export */   "htmlBlockCompiler": () => (/* reexport default from dynamic */ _html_block__WEBPACK_IMPORTED_MODULE_5___default.a),
-/* harmony export */   "iconCompiler": () => (/* reexport default from dynamic */ _i__WEBPACK_IMPORTED_MODULE_6___default.a),
-/* harmony export */   "imageCompiler": () => (/* reexport default from dynamic */ _image__WEBPACK_IMPORTED_MODULE_7___default.a),
-/* harmony export */   "rdmeCalloutCompiler": () => (/* reexport default from dynamic */ _callout__WEBPACK_IMPORTED_MODULE_8___default.a),
-/* harmony export */   "rdmeEmbedCompiler": () => (/* reexport default from dynamic */ _embed__WEBPACK_IMPORTED_MODULE_9___default.a),
-/* harmony export */   "rdmeGlossaryCompiler": () => (/* reexport default from dynamic */ _glossary__WEBPACK_IMPORTED_MODULE_10___default.a),
-/* harmony export */   "rdmePinCompiler": () => (/* reexport default from dynamic */ _pin__WEBPACK_IMPORTED_MODULE_11___default.a),
-/* harmony export */   "rdmeVarCompiler": () => (/* reexport default from dynamic */ _var__WEBPACK_IMPORTED_MODULE_12___default.a),
-/* harmony export */   "tableCompiler": () => (/* reexport default from dynamic */ _table__WEBPACK_IMPORTED_MODULE_13___default.a),
-/* harmony export */   "tableHeadCompiler": () => (/* reexport default from dynamic */ _table_head__WEBPACK_IMPORTED_MODULE_14___default.a),
-/* harmony export */   "yamlCompiler": () => (/* reexport default from dynamic */ _yaml__WEBPACK_IMPORTED_MODULE_15___default.a)
-/* harmony export */ });
-/* harmony import */ var _break__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3688);
-/* harmony import */ var _break__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_break__WEBPACK_IMPORTED_MODULE_0__);
-/* harmony import */ var _code_tabs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(4079);
-/* harmony import */ var _code_tabs__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_code_tabs__WEBPACK_IMPORTED_MODULE_1__);
-/* harmony import */ var _div__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(58);
-/* harmony import */ var _div__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_div__WEBPACK_IMPORTED_MODULE_2__);
-/* harmony import */ var _escape__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(8418);
-/* harmony import */ var _escape__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_escape__WEBPACK_IMPORTED_MODULE_3__);
-/* harmony import */ var _figure__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(8705);
-/* harmony import */ var _figure__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_figure__WEBPACK_IMPORTED_MODULE_4__);
-/* harmony import */ var _html_block__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(3551);
-/* harmony import */ var _html_block__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(_html_block__WEBPACK_IMPORTED_MODULE_5__);
-/* harmony import */ var _i__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(4258);
-/* harmony import */ var _i__WEBPACK_IMPORTED_MODULE_6___default = /*#__PURE__*/__webpack_require__.n(_i__WEBPACK_IMPORTED_MODULE_6__);
-/* harmony import */ var _image__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(3356);
-/* harmony import */ var _image__WEBPACK_IMPORTED_MODULE_7___default = /*#__PURE__*/__webpack_require__.n(_image__WEBPACK_IMPORTED_MODULE_7__);
-/* harmony import */ var _callout__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(5733);
-/* harmony import */ var _callout__WEBPACK_IMPORTED_MODULE_8___default = /*#__PURE__*/__webpack_require__.n(_callout__WEBPACK_IMPORTED_MODULE_8__);
-/* harmony import */ var _embed__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(4338);
-/* harmony import */ var _embed__WEBPACK_IMPORTED_MODULE_9___default = /*#__PURE__*/__webpack_require__.n(_embed__WEBPACK_IMPORTED_MODULE_9__);
-/* harmony import */ var _glossary__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(2459);
-/* harmony import */ var _glossary__WEBPACK_IMPORTED_MODULE_10___default = /*#__PURE__*/__webpack_require__.n(_glossary__WEBPACK_IMPORTED_MODULE_10__);
-/* harmony import */ var _pin__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(2151);
-/* harmony import */ var _pin__WEBPACK_IMPORTED_MODULE_11___default = /*#__PURE__*/__webpack_require__.n(_pin__WEBPACK_IMPORTED_MODULE_11__);
-/* harmony import */ var _var__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(1067);
-/* harmony import */ var _var__WEBPACK_IMPORTED_MODULE_12___default = /*#__PURE__*/__webpack_require__.n(_var__WEBPACK_IMPORTED_MODULE_12__);
-/* harmony import */ var _table__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(4669);
-/* harmony import */ var _table__WEBPACK_IMPORTED_MODULE_13___default = /*#__PURE__*/__webpack_require__.n(_table__WEBPACK_IMPORTED_MODULE_13__);
-/* harmony import */ var _table_head__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(186);
-/* harmony import */ var _table_head__WEBPACK_IMPORTED_MODULE_14___default = /*#__PURE__*/__webpack_require__.n(_table_head__WEBPACK_IMPORTED_MODULE_14__);
-/* harmony import */ var _yaml__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(1773);
-/* harmony import */ var _yaml__WEBPACK_IMPORTED_MODULE_15___default = /*#__PURE__*/__webpack_require__.n(_yaml__WEBPACK_IMPORTED_MODULE_15__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "breakCompiler": () => (/* reexport */ (break_default())),
+  "codeTabsCompiler": () => (/* reexport */ (code_tabs_default())),
+  "divCompiler": () => (/* reexport */ (div_default())),
+  "escapeCompiler": () => (/* reexport */ (escape_default())),
+  "figureCompiler": () => (/* reexport */ (figure_default())),
+  "htmlBlockCompiler": () => (/* reexport */ (html_block_default())),
+  "iconCompiler": () => (/* reexport */ (i_default())),
+  "imageCompiler": () => (/* reexport */ (image_default())),
+  "rdmeCalloutCompiler": () => (/* reexport */ (callout_default())),
+  "rdmeEmbedCompiler": () => (/* reexport */ (embed_default())),
+  "rdmeGlossaryCompiler": () => (/* reexport */ (glossary_default())),
+  "rdmePinCompiler": () => (/* reexport */ (pin_default())),
+  "rdmeVarCompiler": () => (/* reexport */ (var_default())),
+  "reusableContentCompiler": () => (/* reexport */ ReusableContentCompiler),
+  "tableCompiler": () => (/* reexport */ (table_default())),
+  "tableHeadCompiler": () => (/* reexport */ (table_head_default())),
+  "yamlCompiler": () => (/* reexport */ (yaml_default()))
+});
+
+// EXTERNAL MODULE: ./processor/compile/break.js
+var compile_break = __webpack_require__(3688);
+var break_default = /*#__PURE__*/__webpack_require__.n(compile_break);
+// EXTERNAL MODULE: ./processor/compile/code-tabs.js
+var code_tabs = __webpack_require__(4079);
+var code_tabs_default = /*#__PURE__*/__webpack_require__.n(code_tabs);
+// EXTERNAL MODULE: ./processor/compile/div.js
+var div = __webpack_require__(58);
+var div_default = /*#__PURE__*/__webpack_require__.n(div);
+// EXTERNAL MODULE: ./processor/compile/escape.js
+var compile_escape = __webpack_require__(8418);
+var escape_default = /*#__PURE__*/__webpack_require__.n(compile_escape);
+// EXTERNAL MODULE: ./processor/compile/figure.js
+var figure = __webpack_require__(8705);
+var figure_default = /*#__PURE__*/__webpack_require__.n(figure);
+// EXTERNAL MODULE: ./processor/compile/html-block.js
+var html_block = __webpack_require__(3551);
+var html_block_default = /*#__PURE__*/__webpack_require__.n(html_block);
+// EXTERNAL MODULE: ./processor/compile/i.js
+var i = __webpack_require__(4258);
+var i_default = /*#__PURE__*/__webpack_require__.n(i);
+// EXTERNAL MODULE: ./processor/compile/image.js
+var compile_image = __webpack_require__(3356);
+var image_default = /*#__PURE__*/__webpack_require__.n(compile_image);
+// EXTERNAL MODULE: ./processor/compile/callout.js
+var callout = __webpack_require__(5733);
+var callout_default = /*#__PURE__*/__webpack_require__.n(callout);
+// EXTERNAL MODULE: ./processor/compile/embed.js
+var compile_embed = __webpack_require__(4338);
+var embed_default = /*#__PURE__*/__webpack_require__.n(compile_embed);
+// EXTERNAL MODULE: ./processor/compile/glossary.js
+var glossary = __webpack_require__(2459);
+var glossary_default = /*#__PURE__*/__webpack_require__.n(glossary);
+// EXTERNAL MODULE: ./processor/compile/pin.js
+var pin = __webpack_require__(2151);
+var pin_default = /*#__PURE__*/__webpack_require__.n(pin);
+// EXTERNAL MODULE: ./processor/compile/var.js
+var compile_var = __webpack_require__(1067);
+var var_default = /*#__PURE__*/__webpack_require__.n(compile_var);
+// EXTERNAL MODULE: ./processor/transform/reusable-content.js + 2 modules
+var reusable_content = __webpack_require__(6462);
+;// CONCATENATED MODULE: ./processor/compile/reusable-content.js
+
+function ReusableContentCompiler() {
+  var Compiler = this.Compiler;
+  var visitors = Compiler.prototype.visitors;
+  visitors[reusable_content/* type */.dt] = function (node) {
+    return "<".concat(reusable_content/* tag */._q, " name=\"").concat(node.name, "\" />");
+  };
+}
+// EXTERNAL MODULE: ./processor/compile/table.js
+var table = __webpack_require__(4669);
+var table_default = /*#__PURE__*/__webpack_require__.n(table);
+// EXTERNAL MODULE: ./processor/compile/table-head.js
+var table_head = __webpack_require__(186);
+var table_head_default = /*#__PURE__*/__webpack_require__.n(table_head);
+// EXTERNAL MODULE: ./processor/compile/yaml.js
+var yaml = __webpack_require__(1773);
+var yaml_default = /*#__PURE__*/__webpack_require__.n(yaml);
+;// CONCATENATED MODULE: ./processor/compile/index.js
+
 
 
 
@@ -8992,7 +9027,7 @@ module.exports.sanitize = function (sanitizeSchema) {
 
 /***/ }),
 
-/***/ 8160:
+/***/ 6284:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -9006,8 +9041,31 @@ __webpack_require__.d(__webpack_exports__, {
   "sanitize": () => (/* binding */ sanitize)
 });
 
-// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js + 3 modules
-var toConsumableArray = __webpack_require__(2982);
+// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js
+var arrayLikeToArray = __webpack_require__(907);
+;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js
+
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) return (0,arrayLikeToArray/* default */.Z)(arr);
+}
+;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArray.js
+function _iterableToArray(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js
+var unsupportedIterableToArray = __webpack_require__(181);
+;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js
+
+
+
+
+function _toConsumableArray(arr) {
+  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || (0,unsupportedIterableToArray/* default */.Z)(arr) || _nonIterableSpread();
+}
 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js + 3 modules
 var slicedToArray = __webpack_require__(1037);
 ;// CONCATENATED MODULE: ./node_modules/emoji-regex/index.mjs
@@ -9159,7 +9217,7 @@ function blockquoteReadme(eat, value, silent) {
       }
     };
     var _exit = self.enterBlock();
-    var _children = [].concat((0,toConsumableArray/* default */.Z)(self.tokenizeBlock(title, now)), (0,toConsumableArray/* default */.Z)(self.tokenizeBlock(body, now)));
+    var _children = [].concat(_toConsumableArray(self.tokenizeBlock(title, now)), _toConsumableArray(self.tokenizeBlock(body, now)));
     _exit();
     return add({
       type: 'rdme-callout',
@@ -9433,8 +9491,8 @@ var magic_block_parser_default = /*#__PURE__*/__webpack_require__.n(magic_block_
 // EXTERNAL MODULE: ./processor/parse/flavored/code-tabs.js
 var code_tabs = __webpack_require__(5289);
 var code_tabs_default = /*#__PURE__*/__webpack_require__.n(code_tabs);
-// EXTERNAL MODULE: ./processor/parse/flavored/callout.js + 1 modules
-var callout = __webpack_require__(8160);
+// EXTERNAL MODULE: ./processor/parse/flavored/callout.js + 5 modules
+var callout = __webpack_require__(6284);
 // EXTERNAL MODULE: ./processor/parse/flavored/embed.js
 var flavored_embed = __webpack_require__(1559);
 var embed_default = /*#__PURE__*/__webpack_require__.n(flavored_embed);
@@ -10107,7 +10165,7 @@ module.exports.tableFlattening = transformer;
 
 /***/ }),
 
-/***/ 3628:
+/***/ 2692:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -10120,728 +10178,326 @@ __webpack_require__.d(__webpack_exports__, {
   "remarkTransformers": () => (/* binding */ remarkTransformers)
 });
 
-;// 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
- */
+// EXTERNAL MODULE: ./processor/transform/reusable-content.js + 2 modules
+var reusable_content = __webpack_require__(6462);
+// EXTERNAL MODULE: ./node_modules/unist-util-visit/index.js
+var unist_util_visit = __webpack_require__(6393);
+;// CONCATENATED MODULE: ./processor/transform/single-code-tabs.js
 
-/**
- * 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}
- */
+var singleCodeTabs = function singleCodeTabs() {
+  return function (tree) {
+    (0,unist_util_visit/* visit */.Vn)(tree, function (node, index, parent) {
+      if (node.type === 'code' && (node.lang || node.meta) && parent.type !== 'code-tabs') {
+        Object.assign(node, {
+          className: 'tab-panel',
+          data: {
+            hName: 'code',
+            hProperties: {
+              meta: node.meta,
+              lang: node.lang
+            }
+          }
+        });
+        parent.children[index] = {
+          type: 'code-tabs',
+          className: 'tabs',
+          data: {
+            hName: 'div',
+            hProperties: {
+              className: ['code-tabs']
+            }
+          },
+          children: [node]
+        };
+      }
+    });
+    return tree;
+  };
+};
+/* harmony default export */ const single_code_tabs = (singleCodeTabs);
+// EXTERNAL MODULE: ./node_modules/unist-util-visit/node_modules/unist-util-visit-parents/index.js + 2 modules
+var unist_util_visit_parents = __webpack_require__(5605);
+;// CONCATENATED MODULE: ./processor/transform/table-cell-inline-code.js
+
+var rxEscapedPipe = /\\\|/g;
 
 /**
- * Check if a node passes a certain node test
+ * HAST Transformer that finds all inline code nodes within table cells and
+ * unescapes any escaped pipe chars so that the editor outputs them without
+ * escape chars.
  *
- * @template {Node} X
- * @callback TestFunctionPredicate
- * @param {Node} node
- * @param {number|null|undefined} [index]
- * @param {Parent|null|undefined} [parent]
- * @returns {node is X}
+ * This appears to be a bug with remark-parse < ~8
  */
+var tableCellInlineCode = function tableCellInlineCode() {
+  return function (tree) {
+    (0,unist_util_visit/* visit */.Vn)(tree, [{
+      tagName: 'th'
+    }, {
+      tagName: 'td'
+    }], function (tableCellNode) {
+      (0,unist_util_visit/* visit */.Vn)(tableCellNode, {
+        tagName: 'code'
+      }, function (inlineCodeNode) {
+        var textNode = inlineCodeNode.children[0];
+        if (textNode && rxEscapedPipe.test(textNode.value)) {
+          textNode.value = textNode.value.replace(rxEscapedPipe, '|');
+        }
+      });
+      return unist_util_visit_parents/* SKIP */.AM;
+    });
+  };
+};
+/* harmony default export */ const table_cell_inline_code = (tableCellInlineCode);
+;// CONCATENATED MODULE: ./processor/transform/index.js
 
-/**
- * @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)
+var remarkTransformers = [single_code_tabs, reusable_content/* default */.ZP];
+var rehypeTransformers = [table_cell_inline_code];
 
-      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')
-      }
+/***/ 6462:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
-      if (
-        (parent === undefined || parent === null) !==
-        (index === undefined || index === null)
-      ) {
-        throw new Error('Expected both parent and index')
-      }
+"use strict";
 
-      // @ts-expect-error Looks like a node.
-      return node && node.type && typeof node.type === 'string'
-        ? Boolean(check.call(context, node, index, parent))
-        : false
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "ZP": () => (/* binding */ reusable_content),
+  "_q": () => (/* binding */ tag),
+  "dt": () => (/* binding */ type)
+});
+
+// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/typeof.js
+var esm_typeof = __webpack_require__(1002);
+;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+  return _setPrototypeOf(o, p);
+}
+;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/inherits.js
+
+function _inherits(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      writable: true,
+      configurable: true
     }
-  )
+  });
+  Object.defineProperty(subClass, "prototype", {
+    writable: false
+  });
+  if (superClass) _setPrototypeOf(subClass, superClass);
+}
+// EXTERNAL MODULE: ./node_modules/unist-util-visit/index.js
+var unist_util_visit = __webpack_require__(6393);
+;// CONCATENATED MODULE: ./processor/transform/reusable-content.js
 
-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)
-      }
+function _wrapRegExp() { _wrapRegExp = function _wrapRegExp(re, groups) { return new BabelRegExp(re, void 0, groups); }; var _super = RegExp.prototype, _groups = new WeakMap(); function BabelRegExp(re, flags, groups) { var _this = new RegExp(re, flags); return _groups.set(_this, groups || _groups.get(re)), _setPrototypeOf(_this, BabelRegExp.prototype); } function buildGroups(result, re) { var g = _groups.get(re); return Object.keys(g).reduce(function (groups, name) { var i = g[name]; if ("number" == typeof i) groups[name] = result[i];else { for (var k = 0; void 0 === result[i[k]] && k + 1 < i.length;) { k++; } groups[name] = result[i[k]]; } return groups; }, Object.create(null)); } return _inherits(BabelRegExp, RegExp), BabelRegExp.prototype.exec = function (str) { var result = _super.exec.call(this, str); return result && (result.groups = buildGroups(result, this)), result; }, BabelRegExp.prototype[Symbol.replace] = function (str, substitution) { if ("string" == typeof substitution) { var groups = _groups.get(this); return _super[Symbol.replace].call(this, str, substitution.replace(/\$<([^>]+)>/g, function (_, name) { return "$" + groups[name]; })); } if ("function" == typeof substitution) { var _this = this; return _super[Symbol.replace].call(this, str, function () { var args = arguments; return "object" != (0,esm_typeof/* default */.Z)(args[args.length - 1]) && (args = [].slice.call(args)).push(buildGroups(args, _this)), substitution.apply(this, args); }); } return _super[Symbol.replace].call(this, str, substitution); }, _wrapRegExp.apply(this, arguments); }
 
-      if (typeof test === 'function') {
-        return castFactory(test)
-      }
+var type = 'reusable-content';
+var tag = 'RMReusableContent';
+var regexp = /*#__PURE__*/_wrapRegExp(/^\s*<RMReusableContent name="(.*)" \/>\s*$/, {
+  name: 1
+});
+var reusableContentTransformer = function reusableContentTransformer() {
+  var reusableContent = this.data('reusableContent');
+  return function (tree) {
+    (0,unist_util_visit/* visit */.Vn)(tree, 'html', function (node, index, parent) {
+      var result = regexp.exec(node.value);
+      if (!result || !result.groups.name) return;
+      var name = result.groups.name;
+      var block = {
+        type: type,
+        name: name,
+        children: name in reusableContent ? reusableContent[name] : []
+      };
+      parent.children[index] = block;
+    });
+    return tree;
+  };
+};
+/* harmony default export */ const reusable_content = (reusableContentTransformer);
 
-      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])
+/***/ 8229:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var _require = __webpack_require__(2781),
+  defaultSchema = _require.defaultSchema;
+var createSchema = function createSchema() {
+  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    safeMode = _ref.safeMode;
+  var schema = JSON.parse(JSON.stringify(defaultSchema));
+
+  // Sanitization Schema Defaults
+  schema.clobberPrefix = '';
+  schema.tagNames.push('span');
+  schema.attributes['*'].push('class', 'className', 'align');
+  if (!safeMode) {
+    schema.attributes['*'].push('style');
   }
+  schema.tagNames.push('rdme-pin');
+  schema.tagNames.push('rdme-embed');
+  schema.attributes['rdme-embed'] = ['url', 'provider', 'html', 'title', 'href', 'iframe', 'width', 'height', 'image', 'favicon', 'align'];
+  schema.attributes.a = ['href', 'title', 'class', 'className', 'download'];
+  schema.tagNames.push('figure');
+  schema.tagNames.push('figcaption');
+  schema.tagNames.push('input'); // allow GitHub-style todo lists
+  schema.ancestors.input = ['li'];
+  schema.tagNames.push('colgroup'); // wat
+  schema.tagNames.push('col');
+  return schema;
+};
+module.exports = createSchema;
 
-  return castFactory(any)
+/***/ }),
 
-  /**
-   * @this {unknown}
-   * @param {unknown[]} parameters
-   * @returns {boolean}
-   */
-  function any(...parameters) {
-    let index = -1
+/***/ 8841:
+/***/ ((module) => {
 
-    while (++index < checks.length) {
-      if (checks[index].call(this, ...parameters)) return true
-    }
+"use strict";
 
-    return false
+
+module.exports = bail
+
+function bail(err) {
+  if (err) {
+    throw err
   }
 }
 
-/**
- * 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
-    }
+/***/ 1073:
+/***/ ((module) => {
 
-    return true
+module.exports = {
+	trueFunc: function trueFunc(){
+		return true;
+	},
+	falseFunc: function falseFunc(){
+		return false;
+	}
+};
+
+/***/ }),
+
+/***/ 932:
+/***/ ((module) => {
+
+"use strict";
+
+
+module.exports = ccount
+
+function ccount(value, character) {
+  var val = String(value)
+  var count = 0
+  var index
+
+  if (typeof character !== 'string' || character.length !== 1) {
+    throw new Error('Expected character')
   }
-}
 
-/**
- * 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)
+  index = val.indexOf(character)
 
-  /**
-   * @param {Node} node
-   */
-  function type(node) {
-    return node && node.type === check
+  while (index !== -1) {
+    count++
+    index = val.indexOf(character, index + 1)
   }
+
+  return count
 }
 
-/**
- * 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))
-  }
+/***/ }),
+
+/***/ 6313:
+/***/ ((module) => {
+
+var clone = (function() {
+'use strict';
+
+function _instanceof(obj, type) {
+  return type != null && obj instanceof type;
 }
 
-// Utility to return true.
-function ok() {
-  return true
+var nativeMap;
+try {
+  nativeMap = Map;
+} catch(_) {
+  // maybe a reference error because no `Map`. Give it a dummy value that no
+  // value will ever be an instanceof.
+  nativeMap = function() {};
 }
 
-;// 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
+var nativeSet;
+try {
+  nativeSet = Set;
+} catch(_) {
+  nativeSet = function() {};
+}
+
+var nativePromise;
+try {
+  nativePromise = Promise;
+} catch(_) {
+  nativePromise = function() {};
 }
 
-;// 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
- */
+ * Clones (copies) an Object using deep copying.
+ *
+ * This function supports circular references by default, but if you are certain
+ * there are no circular references in your object, you can save some CPU time
+ * by calling clone(obj, false).
+ *
+ * Caution: if `circular` is false and `parent` contains circular references,
+ * your program may enter an infinite loop and crash.
+ *
+ * @param `parent` - the object to be cloned
+ * @param `circular` - set to true if the object to be cloned may contain
+ *    circular references. (optional - true by default)
+ * @param `depth` - set to a number if the object is only to be cloned to
+ *    a particular depth. (optional - defaults to Infinity)
+ * @param `prototype` - sets the prototype to be used when cloning an object.
+ *    (optional - defaults to parent prototype).
+ * @param `includeNonEnumerable` - set to true if the non-enumerable properties
+ *    should be cloned as well. Non-enumerable properties on the prototype
+ *    chain will be ignored. (optional - false by default)
+*/
+function clone(parent, circular, depth, prototype, includeNonEnumerable) {
+  if (typeof circular === 'object') {
+    depth = circular.depth;
+    prototype = circular.prototype;
+    includeNonEnumerable = circular.includeNonEnumerable;
+    circular = circular.circular;
+  }
+  // maintain two arrays for circular references, where corresponding parents
+  // and children have the same index
+  var allParents = [];
+  var allChildren = [];
 
+  var useBuffer = typeof Buffer != 'undefined';
 
+  if (typeof circular == 'undefined')
+    circular = true;
 
-
-/**
- * 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) {
-    visit(tree, function (node, index, parent) {
-      if (node.type === 'code' && (node.lang || node.meta) && parent.type !== 'code-tabs') {
-        Object.assign(node, {
-          className: 'tab-panel',
-          data: {
-            hName: 'code',
-            hProperties: {
-              meta: node.meta,
-              lang: node.lang
-            }
-          }
-        });
-        parent.children[index] = {
-          type: 'code-tabs',
-          className: 'tabs',
-          data: {
-            hName: 'div',
-            hProperties: {
-              className: ['code-tabs']
-            }
-          },
-          children: [node]
-        };
-      }
-    });
-    return tree;
-  };
-};
-/* harmony default export */ const single_code_tabs = (singleCodeTabs);
-;// CONCATENATED MODULE: ./processor/transform/table-cell-inline-code.js
-
-var rxEscapedPipe = /\\\|/g;
-
-/**
- * HAST Transformer that finds all inline code nodes within table cells and
- * unescapes any escaped pipe chars so that the editor outputs them without
- * escape chars.
- *
- * This appears to be a bug with remark-parse < ~8
- */
-var tableCellInlineCode = function tableCellInlineCode() {
-  return function (tree) {
-    visit(tree, [{
-      tagName: 'th'
-    }, {
-      tagName: 'td'
-    }], function (tableCellNode) {
-      visit(tableCellNode, {
-        tagName: 'code'
-      }, function (inlineCodeNode) {
-        var textNode = inlineCodeNode.children[0];
-        if (textNode && rxEscapedPipe.test(textNode.value)) {
-          textNode.value = textNode.value.replace(rxEscapedPipe, '|');
-        }
-      });
-      return SKIP;
-    });
-  };
-};
-/* harmony default export */ const table_cell_inline_code = (tableCellInlineCode);
-;// CONCATENATED MODULE: ./processor/transform/index.js
-
-
-var remarkTransformers = [single_code_tabs];
-var rehypeTransformers = [table_cell_inline_code];
-
-/***/ }),
-
-/***/ 8229:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-var _require = __webpack_require__(2781),
-  defaultSchema = _require.defaultSchema;
-var createSchema = function createSchema() {
-  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
-    safeMode = _ref.safeMode;
-  var schema = JSON.parse(JSON.stringify(defaultSchema));
-
-  // Sanitization Schema Defaults
-  schema.clobberPrefix = '';
-  schema.tagNames.push('span');
-  schema.attributes['*'].push('class', 'className', 'align');
-  if (!safeMode) {
-    schema.attributes['*'].push('style');
-  }
-  schema.tagNames.push('rdme-pin');
-  schema.tagNames.push('rdme-embed');
-  schema.attributes['rdme-embed'] = ['url', 'provider', 'html', 'title', 'href', 'iframe', 'width', 'height', 'image', 'favicon', 'align'];
-  schema.attributes.a = ['href', 'title', 'class', 'className', 'download'];
-  schema.tagNames.push('figure');
-  schema.tagNames.push('figcaption');
-  schema.tagNames.push('input'); // allow GitHub-style todo lists
-  schema.ancestors.input = ['li'];
-  schema.tagNames.push('colgroup'); // wat
-  schema.tagNames.push('col');
-  return schema;
-};
-module.exports = createSchema;
-
-/***/ }),
-
-/***/ 8841:
-/***/ ((module) => {
-
-"use strict";
-
-
-module.exports = bail
-
-function bail(err) {
-  if (err) {
-    throw err
-  }
-}
-
-
-/***/ }),
-
-/***/ 1073:
-/***/ ((module) => {
-
-module.exports = {
-	trueFunc: function trueFunc(){
-		return true;
-	},
-	falseFunc: function falseFunc(){
-		return false;
-	}
-};
-
-/***/ }),
-
-/***/ 932:
-/***/ ((module) => {
-
-"use strict";
-
-
-module.exports = ccount
-
-function ccount(value, character) {
-  var val = String(value)
-  var count = 0
-  var index
-
-  if (typeof character !== 'string' || character.length !== 1) {
-    throw new Error('Expected character')
-  }
-
-  index = val.indexOf(character)
-
-  while (index !== -1) {
-    count++
-    index = val.indexOf(character, index + 1)
-  }
-
-  return count
-}
-
-
-/***/ }),
-
-/***/ 6313:
-/***/ ((module) => {
-
-var clone = (function() {
-'use strict';
-
-function _instanceof(obj, type) {
-  return type != null && obj instanceof type;
-}
-
-var nativeMap;
-try {
-  nativeMap = Map;
-} catch(_) {
-  // maybe a reference error because no `Map`. Give it a dummy value that no
-  // value will ever be an instanceof.
-  nativeMap = function() {};
-}
-
-var nativeSet;
-try {
-  nativeSet = Set;
-} catch(_) {
-  nativeSet = function() {};
-}
-
-var nativePromise;
-try {
-  nativePromise = Promise;
-} catch(_) {
-  nativePromise = function() {};
-}
-
-/**
- * Clones (copies) an Object using deep copying.
- *
- * This function supports circular references by default, but if you are certain
- * there are no circular references in your object, you can save some CPU time
- * by calling clone(obj, false).
- *
- * Caution: if `circular` is false and `parent` contains circular references,
- * your program may enter an infinite loop and crash.
- *
- * @param `parent` - the object to be cloned
- * @param `circular` - set to true if the object to be cloned may contain
- *    circular references. (optional - true by default)
- * @param `depth` - set to a number if the object is only to be cloned to
- *    a particular depth. (optional - defaults to Infinity)
- * @param `prototype` - sets the prototype to be used when cloning an object.
- *    (optional - defaults to parent prototype).
- * @param `includeNonEnumerable` - set to true if the non-enumerable properties
- *    should be cloned as well. Non-enumerable properties on the prototype
- *    chain will be ignored. (optional - false by default)
-*/
-function clone(parent, circular, depth, prototype, includeNonEnumerable) {
-  if (typeof circular === 'object') {
-    depth = circular.depth;
-    prototype = circular.prototype;
-    includeNonEnumerable = circular.includeNonEnumerable;
-    circular = circular.circular;
-  }
-  // maintain two arrays for circular references, where corresponding parents
-  // and children have the same index
-  var allParents = [];
-  var allChildren = [];
-
-  var useBuffer = typeof Buffer != 'undefined';
-
-  if (typeof circular == 'undefined')
-    circular = true;
-
-  if (typeof depth == 'undefined')
-    depth = Infinity;
+  if (typeof depth == 'undefined')
+    depth = Infinity;
 
   // recurse this function so we don't reset allParents and allChildren
   function _clone(parent, depth) {
@@ -32497,72 +32153,34 @@ function _iterableToArrayLimit(arr, i) {
       _d = !1;
     try {
       if (_x = (_i = _i.call(arr)).next, 0 === i) {
-        if (Object(_i) !== _i) return;
-        _n = !1;
-      } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0);
-    } catch (err) {
-      _d = !0, _e = err;
-    } finally {
-      try {
-        if (!_n && null != _i["return"] && (_r = _i["return"](), Object(_r) !== _r)) return;
-      } finally {
-        if (_d) throw _e;
-      }
-    }
-    return _arr;
-  }
-}
-// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js
-var unsupportedIterableToArray = __webpack_require__(181);
-;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableRest.js
-function _nonIterableRest() {
-  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js
-
-
-
-
-function _slicedToArray(arr, i) {
-  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || (0,unsupportedIterableToArray/* default */.Z)(arr, i) || _nonIterableRest();
-}
-
-/***/ }),
-
-/***/ 2982:
-/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
-
-"use strict";
-
-// EXPORTS
-__webpack_require__.d(__webpack_exports__, {
-  "Z": () => (/* binding */ _toConsumableArray)
-});
-
-// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js
-var arrayLikeToArray = __webpack_require__(907);
-;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js
-
-function _arrayWithoutHoles(arr) {
-  if (Array.isArray(arr)) return (0,arrayLikeToArray/* default */.Z)(arr);
-}
-;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArray.js
-function _iterableToArray(iter) {
-  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+        if (Object(_i) !== _i) return;
+        _n = !1;
+      } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0);
+    } catch (err) {
+      _d = !0, _e = err;
+    } finally {
+      try {
+        if (!_n && null != _i["return"] && (_r = _i["return"](), Object(_r) !== _r)) return;
+      } finally {
+        if (_d) throw _e;
+      }
+    }
+    return _arr;
+  }
 }
 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js
 var unsupportedIterableToArray = __webpack_require__(181);
-;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js
-function _nonIterableSpread() {
-  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableRest.js
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
-;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js
+;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js
 
 
 
 
-function _toConsumableArray(arr) {
-  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || (0,unsupportedIterableToArray/* default */.Z)(arr) || _nonIterableSpread();
+function _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || (0,unsupportedIterableToArray/* default */.Z)(arr, i) || _nonIterableRest();
 }
 
 /***/ }),
@@ -33121,1201 +32739,1710 @@ class WalkIterator {
     /** @type {number} */
     var nodeIndex
 
-    if (start >= end) return this
+    if (start >= end) return this
+
+    if (this.typeIndex) {
+      nodeIndex = this.typeIndex.nodes
+      index = this.typeIndex.index(child)
+      this.delayed.push(delay)
+    } else {
+      this.state.iterator(this.query, child, start, this.parent, this.state)
+    }
+
+    // Stop if we’re looking for one node and it’s already found.
+    if (this.state.one && this.state.found) return this
+
+    return this.each(start + 1, end)
+
+    /**
+     * @this {WalkIterator}
+     */
+    function delay() {
+      this.state.typeIndex = index
+      this.state.nodeIndex = nodeIndex
+      this.state.typeCount = this.typeIndex.count(child)
+      this.state.nodeCount = this.typeIndex.nodes
+      this.state.iterator(this.query, child, start, this.parent, this.state)
+    }
+  }
+
+  /**
+   * Done!
+   * @returns {this}
+   */
+  done() {
+    var index = -1
+
+    while (++index < this.delayed.length) {
+      this.delayed[index].call(this)
+      if (this.state.one && this.state.found) break
+    }
+
+    return this
+  }
+
+  /**
+   * @param {number|null|undefined} [start]
+   * @param {number|null|undefined} [end]
+   * @returns {[number, number]}
+   */
+  defaults(start, end) {
+    if (start === null || start === undefined || start < 0) start = 0
+    if (end === null || end === undefined || end > this.parent.children.length)
+      end = this.parent.children.length
+    return [start, end]
+  }
+}
+
+class TypeIndex {
+  constructor() {
+    /** @type {Object.<string, number>} */
+    this.counts = {}
+    /** @type {number} */
+    this.nodes = 0
+  }
+
+  /**
+   * @param {Node} node
+   * @returns {number}
+   */
+  index(node) {
+    var type = node.type
+
+    this.nodes++
+
+    if (!nest_own.call(this.counts, type)) this.counts[type] = 0
+
+    // Note: `++` is intended to be postfixed!
+    return this.counts[type]++
+  }
+
+  /**
+   * @param {Node} node
+   * @returns {number|undefined}
+   */
+  count(node) {
+    return this.counts[node.type]
+  }
+}
+
+;// CONCATENATED MODULE: ./node_modules/unist-util-select/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} [index]
+ * @param {Parent} [parent]
+ * @returns {boolean|void}
+ */
+
+/**
+ * Check if a node passes a certain node test
+ *
+ * @template {Node} X
+ * @callback TestFunctionPredicate
+ * @param {Node} node
+ * @param {number} [index]
+ * @param {Parent} [parent]
+ * @returns {node is X}
+ */
+
+/**
+ * @callback AssertAnything
+ * @param {unknown} [node]
+ * @param {number} [index]
+ * @param {Parent} [parent]
+ * @returns {boolean}
+ */
+
+/**
+ * Check if a node passes a certain node test
+ *
+ * @template {Node} Y
+ * @callback AssertPredicate
+ * @param {unknown} [node]
+ * @param {number} [index]
+ * @param {Parent} [parent]
+ * @returns {node is Y}
+ */
+
+var 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, parent?: Parent, context?: unknown) => node is T) &
+   *   ((node?: unknown, test?: Test, index?: number, parent?: Parent, 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} [index] Position of `node` in `parent`
+     * @param {Parent} [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) {
+      var 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-ignore Looks like a node.
+      return node && node.type && typeof node.type === 'string'
+        ? Boolean(check.call(context, node, index, parent))
+        : false
+    }
+  )
+
+var 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') {
+        // @ts-ignore looks like a list of tests / partial test object.
+        return 'length' in test ? anyFactory(test) : propsFactory(test)
+      }
+
+      if (typeof test === 'function') {
+        return castFactory(test)
+      }
 
-    if (this.typeIndex) {
-      nodeIndex = this.typeIndex.nodes
-      index = this.typeIndex.index(child)
-      this.delayed.push(delay)
-    } else {
-      this.state.iterator(this.query, child, start, this.parent, this.state)
+      throw new Error('Expected function, string, or object as test')
     }
+  )
+/**
+ * @param {Array.<Type|Props|TestFunctionAnything>} tests
+ * @returns {AssertAnything}
+ */
+function anyFactory(tests) {
+  /** @type {Array.<AssertAnything>} */
+  var checks = []
+  var index = -1
 
-    // Stop if we’re looking for one node and it’s already found.
-    if (this.state.one && this.state.found) return this
+  while (++index < tests.length) {
+    checks[index] = convert(tests[index])
+  }
 
-    return this.each(start + 1, end)
+  return castFactory(any)
 
-    /**
-     * @this {WalkIterator}
-     */
-    function delay() {
-      this.state.typeIndex = index
-      this.state.nodeIndex = nodeIndex
-      this.state.typeCount = this.typeIndex.count(child)
-      this.state.nodeCount = this.typeIndex.nodes
-      this.state.iterator(this.query, child, start, this.parent, this.state)
+  /**
+   * @this {unknown}
+   * @param {unknown[]} parameters
+   * @returns {boolean}
+   */
+  function any(...parameters) {
+    var index = -1
+
+    while (++index < checks.length) {
+      if (checks[index].call(this, ...parameters)) return true
     }
   }
+}
+
+/**
+ * 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)
 
   /**
-   * Done!
-   * @returns {this}
+   * @param {Node} node
+   * @returns {boolean}
    */
-  done() {
-    var index = -1
+  function all(node) {
+    /** @type {string} */
+    var key
 
-    while (++index < this.delayed.length) {
-      this.delayed[index].call(this)
-      if (this.state.one && this.state.found) break
+    for (key in check) {
+      if (node[key] !== check[key]) return
     }
 
-    return this
+    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 {number|null|undefined} [start]
-   * @param {number|null|undefined} [end]
-   * @returns {[number, number]}
+   * @param {Node} node
    */
-  defaults(start, end) {
-    if (start === null || start === undefined || start < 0) start = 0
-    if (end === null || end === undefined || end > this.parent.children.length)
-      end = this.parent.children.length
-    return [start, end]
+  function type(node) {
+    return node && node.type === check
   }
 }
 
-class TypeIndex {
-  constructor() {
-    /** @type {Object.<string, number>} */
-    this.counts = {}
-    /** @type {number} */
-    this.nodes = 0
-  }
+/**
+ * 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
 
   /**
-   * @param {Node} node
-   * @returns {number}
+   * @this {unknown}
+   * @param {Array.<unknown>} parameters
+   * @returns {boolean}
    */
-  index(node) {
-    var type = node.type
+  function assertion(...parameters) {
+    return Boolean(check.call(this, ...parameters))
+  }
+}
 
-    this.nodes++
+// Utility to return true.
+function ok() {
+  return true
+}
 
-    if (!nest_own.call(this.counts, type)) this.counts[type] = 0
+;// CONCATENATED MODULE: ./node_modules/unist-util-select/lib/pseudo.js
+/**
+ * @typedef {import('./types.js').Rule} Rule
+ * @typedef {import('./types.js').RulePseudo} RulePseudo
+ * @typedef {import('./types.js').RulePseudoNth} RulePseudoNth
+ * @typedef {import('./types.js').RulePseudoSelector} RulePseudoSelector
+ * @typedef {import('./types.js').Parent} Parent
+ * @typedef {import('./types.js').Selector} Selector
+ * @typedef {import('./types.js').Selectors} Selectors
+ * @typedef {import('./types.js').SelectState} SelectState
+ * @typedef {import('./types.js').Node} Node
+ */
 
-    // Note: `++` is intended to be postfixed!
-    return this.counts[type]++
+
+
+
+
+var pseudo_is = convert()
+
+var pseudo_handle = zwitch('name', {
+  unknown: unknownPseudo,
+  invalid: invalidPseudo,
+  handlers: {
+    any: matches,
+    blank: empty,
+    empty,
+    'first-child': firstChild,
+    'first-of-type': firstOfType,
+    has: hasSelector,
+    'last-child': lastChild,
+    'last-of-type': lastOfType,
+    matches,
+    not,
+    'nth-child': nthChild,
+    'nth-last-child': nthLastChild,
+    'nth-of-type': nthOfType,
+    'nth-last-of-type': nthLastOfType,
+    'only-child': onlyChild,
+    'only-of-type': onlyOfType,
+    root: pseudo_root,
+    scope
   }
+})
 
-  /**
-   * @param {Node} node
-   * @returns {number|undefined}
-   */
-  count(node) {
-    return this.counts[node.type]
+pseudo.needsIndex = [
+  'first-child',
+  'first-of-type',
+  'last-child',
+  'last-of-type',
+  'nth-child',
+  'nth-last-child',
+  'nth-of-type',
+  'nth-last-of-type',
+  'only-child',
+  'only-of-type'
+]
+
+/**
+ * @param {Rule} query
+ * @param {Node} node
+ * @param {number|null} index
+ * @param {Parent|null} parent
+ * @param {SelectState} state
+ * @returns {boolean}
+ */
+function pseudo(query, node, index, parent, state) {
+  var pseudos = query.pseudos
+  var offset = -1
+
+  while (++offset < pseudos.length) {
+    if (!pseudo_handle(pseudos[offset], node, index, parent, state)) return false
   }
+
+  return true
 }
 
-;// CONCATENATED MODULE: ./node_modules/unist-util-select/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
+ * @param {RulePseudoSelector} query
+ * @param {Node} node
+ * @param {number|null} _1
+ * @param {Parent|null} _2
+ * @param {SelectState} state
+ * @returns {boolean}
+ */
+function matches(query, node, _1, _2, state) {
+  var shallow = state.shallow
+  var one = state.one
+  /** @type {boolean} */
+  var result
+
+  state.one = true
+  state.shallow = true
+
+  result = state.any(query.value, node, state)[0] === node
+
+  state.shallow = shallow
+  state.one = one
+
+  return result
+}
+
+/**
+ * @param {RulePseudoSelector} query
+ * @param {Node} node
+ * @param {number|null} index
+ * @param {Parent|null} parent
+ * @param {SelectState} state
+ * @returns {boolean}
+ */
+function not(query, node, index, parent, state) {
+  return !matches(query, node, index, parent, state)
+}
+
+/**
+ * @param {RulePseudo} _1
+ * @param {Node} node
+ * @param {number|null} _2
+ * @param {Parent|null} parent
+ * @returns {boolean}
  */
+function pseudo_root(_1, node, _2, parent) {
+  return pseudo_is(node) && !parent
+}
 
 /**
- * Check if a node passes a test
- *
- * @callback TestFunctionAnything
+ * @param {RulePseudo} _1
  * @param {Node} node
- * @param {number} [index]
- * @param {Parent} [parent]
- * @returns {boolean|void}
+ * @param {number|null} _2
+ * @param {Parent|null} _3
+ * @param {SelectState} state
+ * @returns {boolean}
  */
+function scope(_1, node, _2, _3, state) {
+  return pseudo_is(node) && state.scopeNodes.includes(node)
+}
 
 /**
- * Check if a node passes a certain node test
- *
- * @template {Node} X
- * @callback TestFunctionPredicate
+ * @param {RulePseudo} _1
  * @param {Node} node
- * @param {number} [index]
- * @param {Parent} [parent]
- * @returns {node is X}
+ * @returns {boolean}
  */
+function empty(_1, node) {
+  return util_parent(node) ? node.children.length === 0 : !('value' in node)
+}
 
 /**
- * @callback AssertAnything
- * @param {unknown} [node]
- * @param {number} [index]
- * @param {Parent} [parent]
+ * @param {RulePseudo} query
+ * @param {Node} _1
+ * @param {number|null} _2
+ * @param {Parent|null} _3
+ * @param {SelectState} state
  * @returns {boolean}
  */
+function firstChild(query, _1, _2, _3, state) {
+  assertDeep(state, query)
+  return state.nodeIndex === 0 // Specifically `0`, not falsey.
+}
 
 /**
- * Check if a node passes a certain node test
- *
- * @template {Node} Y
- * @callback AssertPredicate
- * @param {unknown} [node]
- * @param {number} [index]
- * @param {Parent} [parent]
- * @returns {node is Y}
+ * @param {RulePseudo} query
+ * @param {Node} _1
+ * @param {number|null} _2
+ * @param {Parent|null} _3
+ * @param {SelectState} state
+ * @returns {boolean}
  */
+function lastChild(query, _1, _2, _3, state) {
+  assertDeep(state, query)
+  return state.nodeIndex === state.nodeCount - 1
+}
 
-var 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, parent?: Parent, context?: unknown) => node is T) &
-   *   ((node?: unknown, test?: Test, index?: number, parent?: Parent, 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} [index] Position of `node` in `parent`
-     * @param {Parent} [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) {
-      var check = convert(test)
+/**
+ * @param {RulePseudo} query
+ * @param {Node} _1
+ * @param {number|null} _2
+ * @param {Parent|null} _3
+ * @param {SelectState} state
+ * @returns {boolean}
+ */
+function onlyChild(query, _1, _2, _3, state) {
+  assertDeep(state, query)
+  return state.nodeCount === 1
+}
 
-      if (
-        index !== undefined &&
-        index !== null &&
-        (typeof index !== 'number' ||
-          index < 0 ||
-          index === Number.POSITIVE_INFINITY)
-      ) {
-        throw new Error('Expected positive finite index')
-      }
+/**
+ * @param {RulePseudoNth} query
+ * @param {Node} _1
+ * @param {number|null} _2
+ * @param {Parent|null} _3
+ * @param {SelectState} state
+ * @returns {boolean}
+ */
+function nthChild(query, _1, _2, _3, state) {
+  assertDeep(state, query)
+  return query.value(state.nodeIndex)
+}
 
-      if (
-        parent !== undefined &&
-        parent !== null &&
-        (!is(parent) || !parent.children)
-      ) {
-        throw new Error('Expected parent node')
-      }
+/**
+ * @param {RulePseudoNth} query
+ * @param {Node} _1
+ * @param {number|null} _2
+ * @param {Parent|null} _3
+ * @param {SelectState} state
+ * @returns {boolean}
+ */
+function nthLastChild(query, _1, _2, _3, state) {
+  assertDeep(state, query)
+  return query.value(state.nodeCount - state.nodeIndex - 1)
+}
 
-      if (
-        (parent === undefined || parent === null) !==
-        (index === undefined || index === null)
-      ) {
-        throw new Error('Expected both parent and index')
-      }
+/**
+ * @param {RulePseudoNth} query
+ * @param {Node} _1
+ * @param {number|null} _2
+ * @param {Parent|null} _3
+ * @param {SelectState} state
+ * @returns {boolean}
+ */
+function nthOfType(query, _1, _2, _3, state) {
+  assertDeep(state, query)
+  return query.value(state.typeIndex)
+}
 
-      // @ts-ignore Looks like a node.
-      return node && node.type && typeof node.type === 'string'
-        ? Boolean(check.call(context, node, index, parent))
-        : false
-    }
-  )
+/**
+ * @param {RulePseudoNth} query
+ * @param {Node} _1
+ * @param {number|null} _2
+ * @param {Parent|null} _3
+ * @param {SelectState} state
+ * @returns {boolean}
+ */
+function nthLastOfType(query, _1, _2, _3, state) {
+  assertDeep(state, query)
+  return query.value(state.typeCount - 1 - state.typeIndex)
+}
 
-var 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
-      }
+/**
+ * @param {RulePseudo} query
+ * @param {Node} _1
+ * @param {number|null} _2
+ * @param {Parent|null} _3
+ * @param {SelectState} state
+ * @returns {boolean}
+ */
+function firstOfType(query, _1, _2, _3, state) {
+  assertDeep(state, query)
+  return state.typeIndex === 0
+}
 
-      if (typeof test === 'string') {
-        return typeFactory(test)
-      }
+/**
+ * @param {RulePseudo} query
+ * @param {Node} _1
+ * @param {number|null} _2
+ * @param {Parent|null} _3
+ * @param {SelectState} state
+ * @returns {boolean}
+ */
+function lastOfType(query, _1, _2, _3, state) {
+  assertDeep(state, query)
+  return state.typeIndex === state.typeCount - 1
+}
 
-      if (typeof test === 'object') {
-        // @ts-ignore looks like a list of tests / partial test object.
-        return 'length' in test ? anyFactory(test) : propsFactory(test)
-      }
+/**
+ * @param {RulePseudo} query
+ * @param {Node} _1
+ * @param {number|null} _2
+ * @param {Parent|null} _3
+ * @param {SelectState} state
+ * @returns {boolean}
+ */
+function onlyOfType(query, _1, _2, _3, state) {
+  assertDeep(state, query)
+  return state.typeCount === 1
+}
 
-      if (typeof test === 'function') {
-        return castFactory(test)
-      }
+// Shouldn’t be invoked, parser gives correct data.
+/* c8 ignore next 3 */
+function invalidPseudo() {
+  throw new Error('Invalid pseudo-selector')
+}
 
-      throw new Error('Expected function, string, or object as test')
-    }
-  )
 /**
- * @param {Array.<Type|Props|TestFunctionAnything>} tests
- * @returns {AssertAnything}
+ * @param {RulePseudo} query
+ * @returns {boolean}
  */
-function anyFactory(tests) {
-  /** @type {Array.<AssertAnything>} */
-  var checks = []
-  var index = -1
-
-  while (++index < tests.length) {
-    checks[index] = convert(tests[index])
+function unknownPseudo(query) {
+  if (query.name) {
+    throw new Error('Unknown pseudo-selector `' + query.name + '`')
   }
 
-  return castFactory(any)
-
-  /**
-   * @this {unknown}
-   * @param {unknown[]} parameters
-   * @returns {boolean}
-   */
-  function any(...parameters) {
-    var index = -1
-
-    while (++index < checks.length) {
-      if (checks[index].call(this, ...parameters)) return true
-    }
-  }
+  throw new Error('Unexpected pseudo-element or empty pseudo-class')
 }
 
 /**
- * Utility to assert each property in `test` is represented in `node`, and each
- * values are strictly equal.
- *
- * @param {Props} check
- * @returns {AssertAnything}
+ * @param {SelectState} state
+ * @param {RulePseudo|RulePseudoNth} query
  */
-function propsFactory(check) {
-  return castFactory(all)
-
-  /**
-   * @param {Node} node
-   * @returns {boolean}
-   */
-  function all(node) {
-    /** @type {string} */
-    var key
-
-    for (key in check) {
-      if (node[key] !== check[key]) return
-    }
-
-    return true
+function assertDeep(state, query) {
+  if (state.shallow) {
+    throw new Error('Cannot use `:' + query.name + '` without parent')
   }
 }
 
 /**
- * Utility to convert a string into a function which checks a given node’s type
- * for said string.
- *
- * @param {Type} check
- * @returns {AssertAnything}
+ * @param {RulePseudoSelector} query
+ * @param {Node} node
+ * @param {number|null} _1
+ * @param {Parent|null} _2
+ * @param {SelectState} state
+ * @returns {boolean}
  */
-function typeFactory(check) {
-  return castFactory(type)
+function hasSelector(query, node, _1, _2, state) {
+  var shallow = state.shallow
+  var one = state.one
+  var scopeNodes = state.scopeNodes
+  var value = appendScope(query.value)
+  var anything = state.any
+  /** @type {boolean} */
+  var result
 
-  /**
-   * @param {Node} node
-   */
-  function type(node) {
-    return node && node.type === check
-  }
+  state.shallow = false
+  state.one = true
+  state.scopeNodes = [node]
+
+  result = Boolean(anything(value, node, state)[0])
+
+  state.shallow = shallow
+  state.one = one
+  state.scopeNodes = scopeNodes
+
+  return result
 }
 
 /**
- * Utility to convert a string into a function which checks a given node’s type
- * for said string.
- * @param {TestFunctionAnything} check
- * @returns {AssertAnything}
+ * @param {Selector} value
  */
-function castFactory(check) {
-  return assertion
+function appendScope(value) {
+  /** @type {Selectors} */
+  var selector =
+    value.type === 'ruleSet' ? {type: 'selectors', selectors: [value]} : value
+  var index = -1
+  /** @type {Rule} */
+  var rule
 
-  /**
-   * @this {unknown}
-   * @param {Array.<unknown>} parameters
-   * @returns {boolean}
-   */
-  function assertion(...parameters) {
-    return Boolean(check.call(this, ...parameters))
+  while (++index < selector.selectors.length) {
+    rule = selector.selectors[index].rule
+    rule.nestingOperator = null
+
+    // Needed if new pseudo’s are added that accepts commas (such as
+    // `:lang(en, nl)`)
+    /* c8 ignore else */
+    if (
+      !rule.pseudos ||
+      rule.pseudos.length !== 1 ||
+      rule.pseudos[0].name !== 'scope'
+    ) {
+      selector.selectors[index] = {
+        type: 'ruleSet',
+        rule: {
+          type: 'rule',
+          rule,
+          // @ts-ignore pseudos are fine w/ just a name!
+          pseudos: [{name: 'scope'}]
+        }
+      }
+    }
   }
-}
 
-// Utility to return true.
-function ok() {
-  return true
+  return selector
 }
 
-;// CONCATENATED MODULE: ./node_modules/unist-util-select/lib/pseudo.js
+;// CONCATENATED MODULE: ./node_modules/unist-util-select/lib/attribute.js
 /**
  * @typedef {import('./types.js').Rule} Rule
- * @typedef {import('./types.js').RulePseudo} RulePseudo
- * @typedef {import('./types.js').RulePseudoNth} RulePseudoNth
- * @typedef {import('./types.js').RulePseudoSelector} RulePseudoSelector
- * @typedef {import('./types.js').Parent} Parent
- * @typedef {import('./types.js').Selector} Selector
- * @typedef {import('./types.js').Selectors} Selectors
- * @typedef {import('./types.js').SelectState} SelectState
+ * @typedef {import('./types.js').RuleAttr} RuleAttr
  * @typedef {import('./types.js').Node} Node
  */
 
 
 
-
-
-var pseudo_is = convert()
-
-var pseudo_handle = zwitch('name', {
-  unknown: unknownPseudo,
-  invalid: invalidPseudo,
+var attribute_handle = zwitch('operator', {
+  unknown: unknownOperator,
+  invalid: exists,
   handlers: {
-    any: matches,
-    blank: empty,
-    empty,
-    'first-child': firstChild,
-    'first-of-type': firstOfType,
-    has: hasSelector,
-    'last-child': lastChild,
-    'last-of-type': lastOfType,
-    matches,
-    not,
-    'nth-child': nthChild,
-    'nth-last-child': nthLastChild,
-    'nth-of-type': nthOfType,
-    'nth-last-of-type': nthLastOfType,
-    'only-child': onlyChild,
-    'only-of-type': onlyOfType,
-    root: pseudo_root,
-    scope
+    '=': exact,
+    '^=': begins,
+    '$=': ends,
+    '*=': containsString,
+    '~=': containsArray
   }
 })
 
-pseudo.needsIndex = [
-  'first-child',
-  'first-of-type',
-  'last-child',
-  'last-of-type',
-  'nth-child',
-  'nth-last-child',
-  'nth-of-type',
-  'nth-last-of-type',
-  'only-child',
-  'only-of-type'
-]
-
 /**
  * @param {Rule} query
  * @param {Node} node
- * @param {number|null} index
- * @param {Parent|null} parent
- * @param {SelectState} state
- * @returns {boolean}
  */
-function pseudo(query, node, index, parent, state) {
-  var pseudos = query.pseudos
-  var offset = -1
+function attribute(query, node) {
+  var index = -1
 
-  while (++offset < pseudos.length) {
-    if (!pseudo_handle(pseudos[offset], node, index, parent, state)) return false
+  while (++index < query.attrs.length) {
+    if (!attribute_handle(query.attrs[index], node)) return false
   }
 
   return true
 }
 
 /**
- * @param {RulePseudoSelector} query
+ * `[attr]`
+ *
+ * @param {RuleAttr} query
  * @param {Node} node
- * @param {number|null} _1
- * @param {Parent|null} _2
- * @param {SelectState} state
- * @returns {boolean}
  */
-function matches(query, node, _1, _2, state) {
-  var shallow = state.shallow
-  var one = state.one
-  /** @type {boolean} */
-  var result
+function exists(query, node) {
+  return node[query.name] !== null && node[query.name] !== undefined
+}
 
-  state.one = true
-  state.shallow = true
+/**
+ * `[attr=value]`
+ *
+ * @param {RuleAttr} query
+ * @param {Node} node
+ */
+function exact(query, node) {
+  return exists(query, node) && String(node[query.name]) === query.value
+}
 
-  result = state.any(query.value, node, state)[0] === node
+/**
+ * `[attr~=value]`
+ *
+ * @param {RuleAttr} query
+ * @param {Node} node
+ */
+function containsArray(query, node) {
+  var value = node[query.name]
 
-  state.shallow = shallow
-  state.one = one
+  if (value === null || value === undefined) return false
+
+  // If this is an array, and the query is contained in it, return true.
+  // Coverage comment in place because TS turns `Array.isArray(unknown)`
+  // into `Array.<any>` instead of `Array.<unknown>`.
+  // type-coverage:ignore-next-line
+  if (Array.isArray(value) && value.includes(query.value)) {
+    return true
+  }
 
-  return result
+  // For all other values, return whether this is an exact match.
+  return String(value) === query.value
 }
 
 /**
- * @param {RulePseudoSelector} query
+ * `[attr^=value]`
+ *
+ * @param {RuleAttr} query
  * @param {Node} node
- * @param {number|null} index
- * @param {Parent|null} parent
- * @param {SelectState} state
- * @returns {boolean}
  */
-function not(query, node, index, parent, state) {
-  return !matches(query, node, index, parent, state)
-}
+function begins(query, node) {
+  var value = node[query.name]
 
-/**
- * @param {RulePseudo} _1
- * @param {Node} node
- * @param {number|null} _2
- * @param {Parent|null} parent
- * @returns {boolean}
- */
-function pseudo_root(_1, node, _2, parent) {
-  return pseudo_is(node) && !parent
+  return (
+    typeof value === 'string' &&
+    value.slice(0, query.value.length) === query.value
+  )
 }
 
 /**
- * @param {RulePseudo} _1
+ * `[attr$=value]`
+ *
+ * @param {RuleAttr} query
  * @param {Node} node
- * @param {number|null} _2
- * @param {Parent|null} _3
- * @param {SelectState} state
- * @returns {boolean}
  */
-function scope(_1, node, _2, _3, state) {
-  return pseudo_is(node) && state.scopeNodes.includes(node)
+function ends(query, node) {
+  var value = node[query.name]
+
+  return (
+    typeof value === 'string' &&
+    value.slice(-query.value.length) === query.value
+  )
 }
 
 /**
- * @param {RulePseudo} _1
+ * `[attr*=value]`
+ *
+ * @param {RuleAttr} query
  * @param {Node} node
- * @returns {boolean}
  */
-function empty(_1, node) {
-  return util_parent(node) ? node.children.length === 0 : !('value' in node)
+function containsString(query, node) {
+  var value = node[query.name]
+  return typeof value === 'string' && value.includes(query.value)
 }
 
+// Shouldn’t be invoked, Parser throws an error instead.
+/* c8 ignore next 6 */
 /**
- * @param {RulePseudo} query
- * @param {Node} _1
- * @param {number|null} _2
- * @param {Parent|null} _3
- * @param {SelectState} state
- * @returns {boolean}
+ * @param {{[x: string]: unknown, type: string}} query
  */
-function firstChild(query, _1, _2, _3, state) {
-  assertDeep(state, query)
-  return state.nodeIndex === 0 // Specifically `0`, not falsey.
+function unknownOperator(query) {
+  throw new Error('Unknown operator `' + query.operator + '`')
 }
 
+;// CONCATENATED MODULE: ./node_modules/unist-util-select/lib/name.js
 /**
- * @param {RulePseudo} query
- * @param {Node} _1
- * @param {number|null} _2
- * @param {Parent|null} _3
- * @param {SelectState} state
- * @returns {boolean}
+ * @typedef {import('./types.js').Rule} Rule
+ * @typedef {import('./types.js').Node} Node
  */
-function lastChild(query, _1, _2, _3, state) {
-  assertDeep(state, query)
-  return state.nodeIndex === state.nodeCount - 1
-}
 
 /**
- * @param {RulePseudo} query
- * @param {Node} _1
- * @param {number|null} _2
- * @param {Parent|null} _3
- * @param {SelectState} state
- * @returns {boolean}
+ * @param {Rule} query
+ * @param {Node} node
  */
-function onlyChild(query, _1, _2, _3, state) {
-  assertDeep(state, query)
-  return state.nodeCount === 1
+function name_name(query, node) {
+  return query.tagName === '*' || query.tagName === node.type
 }
 
+;// CONCATENATED MODULE: ./node_modules/unist-util-select/lib/test.js
 /**
- * @param {RulePseudoNth} query
- * @param {Node} _1
- * @param {number|null} _2
- * @param {Parent|null} _3
- * @param {SelectState} state
- * @returns {boolean}
+ * @typedef {import('./types.js').Rule} Rule
+ * @typedef {import('./types.js').Node} Node
+ * @typedef {import('./types.js').Parent} Parent
+ * @typedef {import('./types.js').SelectState} SelectState
  */
-function nthChild(query, _1, _2, _3, state) {
-  assertDeep(state, query)
-  return query.value(state.nodeIndex)
-}
+
+
+
+
 
 /**
- * @param {RulePseudoNth} query
- * @param {Node} _1
- * @param {number|null} _2
- * @param {Parent|null} _3
+ * @param {Rule} query
+ * @param {Node} node
+ * @param {number|null} index
+ * @param {Parent|null} parent
  * @param {SelectState} state
  * @returns {boolean}
  */
-function nthLastChild(query, _1, _2, _3, state) {
-  assertDeep(state, query)
-  return query.value(state.nodeCount - state.nodeIndex - 1)
+function test(query, node, index, parent, state) {
+  if (query.id) throw new Error('Invalid selector: id')
+  if (query.classNames) throw new Error('Invalid selector: class')
+
+  return Boolean(
+    node &&
+      (!query.tagName || name_name(query, node)) &&
+      (!query.attrs || attribute(query, node)) &&
+      (!query.pseudos || pseudo(query, node, index, parent, state))
+  )
 }
 
+;// CONCATENATED MODULE: ./node_modules/unist-util-select/lib/any.js
 /**
- * @param {RulePseudoNth} query
- * @param {Node} _1
- * @param {number|null} _2
- * @param {Parent|null} _3
- * @param {SelectState} state
- * @returns {boolean}
+ * @typedef {import('./types.js').Selector} Selector
+ * @typedef {import('./types.js').Selectors} Selectors
+ * @typedef {import('./types.js').Rule} Rule
+ * @typedef {import('./types.js').RuleSet} RuleSet
+ * @typedef {import('./types.js').RulePseudo} RulePseudo
+ * @typedef {import('./types.js').Query} Query
+ * @typedef {import('./types.js').Node} Node
+ * @typedef {import('./types.js').Parent} Parent
+ * @typedef {import('./types.js').SelectIterator} SelectIterator
+ * @typedef {import('./types.js').SelectState} SelectState
  */
-function nthOfType(query, _1, _2, _3, state) {
-  assertDeep(state, query)
-  return query.value(state.typeIndex)
-}
+
+
+
+
+
+
+
+var type = zwitch('type', {
+  unknown: unknownType,
+  invalid: invalidType,
+  handlers: {selectors, ruleSet, rule}
+})
 
 /**
- * @param {RulePseudoNth} query
- * @param {Node} _1
- * @param {number|null} _2
- * @param {Parent|null} _3
+ * @param {Selectors|RuleSet|Rule} query
+ * @param {Node} node
  * @param {SelectState} state
- * @returns {boolean}
  */
-function nthLastOfType(query, _1, _2, _3, state) {
-  assertDeep(state, query)
-  return query.value(state.typeCount - 1 - state.typeIndex)
+function any(query, node, state) {
+  // @ts-ignore zwitch types are off.
+  return query && node ? type(query, node, state) : []
 }
 
 /**
- * @param {RulePseudo} query
- * @param {Node} _1
- * @param {number|null} _2
- * @param {Parent|null} _3
+ * @param {Selectors} query
+ * @param {Node} node
  * @param {SelectState} state
- * @returns {boolean}
  */
-function firstOfType(query, _1, _2, _3, state) {
-  assertDeep(state, query)
-  return state.typeIndex === 0
+function selectors(query, node, state) {
+  var collect = collector(state.one)
+  var index = -1
+
+  while (++index < query.selectors.length) {
+    collect(ruleSet(query.selectors[index], node, state))
+  }
+
+  return collect.result
 }
 
 /**
- * @param {RulePseudo} query
- * @param {Node} _1
- * @param {number|null} _2
- * @param {Parent|null} _3
+ * @param {RuleSet} query
+ * @param {Node} node
  * @param {SelectState} state
- * @returns {boolean}
  */
-function lastOfType(query, _1, _2, _3, state) {
-  assertDeep(state, query)
-  return state.typeIndex === state.typeCount - 1
+function ruleSet(query, node, state) {
+  return rule(query.rule, node, state)
 }
 
 /**
- * @param {RulePseudo} query
- * @param {Node} _1
- * @param {number|null} _2
- * @param {Parent|null} _3
+ * @param {Rule} query
+ * @param {Node} tree
  * @param {SelectState} state
- * @returns {boolean}
  */
-function onlyOfType(query, _1, _2, _3, state) {
-  assertDeep(state, query)
-  return state.typeCount === 1
-}
+function rule(query, tree, state) {
+  var collect = collector(state.one)
 
-// Shouldn’t be invoked, parser gives correct data.
-/* c8 ignore next 3 */
-function invalidPseudo() {
-  throw new Error('Invalid pseudo-selector')
+  if (state.shallow && query.rule) {
+    throw new Error('Expected selector without nesting')
+  }
+
+  nest(
+    query,
+    tree,
+    0,
+    null,
+    configure(query, {
+      scopeNodes: root(tree) ? tree.children : [tree],
+      index: false,
+      iterator,
+      one: state.one,
+      shallow: state.shallow,
+      any: state.any
+    })
+  )
+
+  return collect.result
+
+  /** @type {SelectIterator} */
+  function iterator(query, node, index, parent, state) {
+    if (test(query, node, index, parent, state)) {
+      if ('rule' in query) {
+        nest(query.rule, node, index, parent, configure(query.rule, state))
+      } else {
+        collect(node)
+        state.found = true
+      }
+    }
+  }
 }
 
 /**
- * @param {RulePseudo} query
- * @returns {boolean}
+ * @template {SelectState} S
+ * @param {Rule} query
+ * @param {S} state
+ * @returns {S}
  */
-function unknownPseudo(query) {
-  if (query.name) {
-    throw new Error('Unknown pseudo-selector `' + query.name + '`')
+function configure(query, state) {
+  var pseudos = query.pseudos || []
+  var index = -1
+
+  while (++index < pseudos.length) {
+    if (pseudo.needsIndex.includes(pseudos[index].name)) {
+      state.index = true
+      break
+    }
   }
 
-  throw new Error('Unexpected pseudo-element or empty pseudo-class')
+  return state
 }
 
+// Shouldn’t be invoked, all data is handled.
+/* c8 ignore next 6 */
 /**
- * @param {SelectState} state
- * @param {RulePseudo|RulePseudoNth} query
+ * @param {{[x: string]: unknown, type: string}} query
  */
-function assertDeep(state, query) {
-  if (state.shallow) {
-    throw new Error('Cannot use `:' + query.name + '` without parent')
-  }
+function unknownType(query) {
+  throw new Error('Unknown type `' + query.type + '`')
+}
+
+// Shouldn’t be invoked, parser gives correct data.
+/* c8 ignore next 3 */
+function invalidType() {
+  throw new Error('Invalid type')
 }
 
 /**
- * @param {RulePseudoSelector} query
- * @param {Node} node
- * @param {number|null} _1
- * @param {Parent|null} _2
- * @param {SelectState} state
- * @returns {boolean}
+ * @param {boolean} one
  */
-function hasSelector(query, node, _1, _2, state) {
-  var shallow = state.shallow
-  var one = state.one
-  var scopeNodes = state.scopeNodes
-  var value = appendScope(query.value)
-  var anything = state.any
+function collector(one) {
+  /** @type {Array.<Node>} */
+  var result = []
   /** @type {boolean} */
-  var result
-
-  state.shallow = false
-  state.one = true
-  state.scopeNodes = [node]
-
-  result = Boolean(anything(value, node, state)[0])
-
-  state.shallow = shallow
-  state.one = one
-  state.scopeNodes = scopeNodes
+  var found
 
-  return result
-}
+  collect.result = result
 
-/**
- * @param {Selector} value
- */
-function appendScope(value) {
-  /** @type {Selectors} */
-  var selector =
-    value.type === 'ruleSet' ? {type: 'selectors', selectors: [value]} : value
-  var index = -1
-  /** @type {Rule} */
-  var rule
+  return collect
 
-  while (++index < selector.selectors.length) {
-    rule = selector.selectors[index].rule
-    rule.nestingOperator = null
+  /**
+   * Append nodes to array, filtering out duplicates.
+   *
+   * @param {Node|Array.<Node>} node
+   */
+  function collect(node) {
+    var index = -1
 
-    // Needed if new pseudo’s are added that accepts commas (such as
-    // `:lang(en, nl)`)
-    /* c8 ignore else */
-    if (
-      !rule.pseudos ||
-      rule.pseudos.length !== 1 ||
-      rule.pseudos[0].name !== 'scope'
-    ) {
-      selector.selectors[index] = {
-        type: 'ruleSet',
-        rule: {
-          type: 'rule',
-          rule,
-          // @ts-ignore pseudos are fine w/ just a name!
-          pseudos: [{name: 'scope'}]
-        }
+    if ('length' in node) {
+      while (++index < node.length) {
+        collectOne(node[index])
       }
+    } else {
+      collectOne(node)
     }
   }
 
-  return selector
+  /**
+   * @param {Node} node
+   */
+  function collectOne(node) {
+    if (one) {
+      /* Shouldn’t happen, safeguards performance problems. */
+      /* c8 ignore next */
+      if (found) throw new Error('Cannot collect multiple nodes')
+
+      found = true
+    }
+
+    if (!result.includes(node)) result.push(node)
+  }
 }
 
-;// CONCATENATED MODULE: ./node_modules/unist-util-select/lib/attribute.js
+// EXTERNAL MODULE: ./node_modules/css-selector-parser/lib/index.js
+var lib = __webpack_require__(8079);
+// EXTERNAL MODULE: ./node_modules/nth-check/lib/index.js
+var nth_check_lib = __webpack_require__(7540);
+;// CONCATENATED MODULE: ./node_modules/unist-util-select/lib/parse.js
 /**
+ * @typedef {import('./types.js').Selector} Selector
+ * @typedef {import('./types.js').Selectors} Selectors
+ * @typedef {import('./types.js').RuleSet} RuleSet
  * @typedef {import('./types.js').Rule} Rule
- * @typedef {import('./types.js').RuleAttr} RuleAttr
- * @typedef {import('./types.js').Node} Node
+ * @typedef {import('./types.js').RulePseudo} RulePseudo
+ * @typedef {import('./types.js').RulePseudoNth} RulePseudoNth
  */
 
 
 
-var attribute_handle = zwitch('operator', {
-  unknown: unknownOperator,
-  invalid: exists,
-  handlers: {
-    '=': exact,
-    '^=': begins,
-    '$=': ends,
-    '*=': containsString,
-    '~=': containsArray
-  }
-})
+
+
+/** @type {import('nth-check').default} */
+// @ts-ignore
+var nthCheck = nth_check_lib/* default */.ZP
+
+var nth = new Set([
+  'nth-child',
+  'nth-last-child',
+  'nth-of-type',
+  'nth-last-of-type'
+])
+
+var parser = new lib/* CssSelectorParser */.N()
+
+parser.registerAttrEqualityMods('~', '^', '$', '*')
+parser.registerSelectorPseudos('any', 'matches', 'not', 'has')
+parser.registerNestingOperators('>', '+', '~')
+
+var compile = zwitch('type', {handlers: {selectors: parse_selectors, ruleSet: parse_ruleSet, rule: parse_rule}})
 
 /**
- * @param {Rule} query
- * @param {Node} node
+ * @param {string} selector
+ * @returns {Selector}
  */
-function attribute(query, node) {
-  var index = -1
-
-  while (++index < query.attrs.length) {
-    if (!attribute_handle(query.attrs[index], node)) return false
+function parse(selector) {
+  if (typeof selector !== 'string') {
+    throw new TypeError('Expected `string` as selector, not `' + selector + '`')
   }
 
-  return true
+  // @ts-ignore types are wrong.
+  return compile(parser.parse(selector))
 }
 
 /**
- * `[attr]`
- *
- * @param {RuleAttr} query
- * @param {Node} node
+ * @param {Selectors} query
  */
-function exists(query, node) {
-  return node[query.name] !== null && node[query.name] !== undefined
+function parse_selectors(query) {
+  var selectors = query.selectors
+  var index = -1
+
+  while (++index < selectors.length) {
+    compile(selectors[index])
+  }
+
+  return query
 }
 
 /**
- * `[attr=value]`
- *
- * @param {RuleAttr} query
- * @param {Node} node
+ * @param {RuleSet} query
  */
-function exact(query, node) {
-  return exists(query, node) && String(node[query.name]) === query.value
+function parse_ruleSet(query) {
+  return parse_rule(query.rule)
 }
 
 /**
- * `[attr~=value]`
- *
- * @param {RuleAttr} query
- * @param {Node} node
+ * @param {Rule} query
  */
-function containsArray(query, node) {
-  var value = node[query.name]
-
-  if (value === null || value === undefined) return false
-
-  // If this is an array, and the query is contained in it, return true.
-  // Coverage comment in place because TS turns `Array.isArray(unknown)`
-  // into `Array.<any>` instead of `Array.<unknown>`.
-  // type-coverage:ignore-next-line
-  if (Array.isArray(value) && value.includes(query.value)) {
-    return true
-  }
+function parse_rule(query) {
+  var pseudos = query.pseudos || []
+  var index = -1
+  /** @type {RulePseudo|RulePseudoNth} */
+  var pseudo
 
-  // For all other values, return whether this is an exact match.
-  return String(value) === query.value
-}
+  while (++index < pseudos.length) {
+    pseudo = pseudos[index]
 
-/**
- * `[attr^=value]`
- *
- * @param {RuleAttr} query
- * @param {Node} node
- */
-function begins(query, node) {
-  var value = node[query.name]
+    if (nth.has(pseudo.name)) {
+      // @ts-ignore Patch a non-primitive type.
+      pseudo.value = nthCheck(pseudo.value)
+      // @ts-ignore Patch a non-primitive type.
+      pseudo.valueType = 'function'
+    }
+  }
 
-  return (
-    typeof value === 'string' &&
-    value.slice(0, query.value.length) === query.value
-  )
+  compile(query.rule)
+
+  return query
 }
 
+;// CONCATENATED MODULE: ./node_modules/unist-util-select/index.js
 /**
- * `[attr$=value]`
- *
- * @param {RuleAttr} query
- * @param {Node} node
+ * @typedef {import('unist').Node} Node
  */
-function ends(query, node) {
-  var value = node[query.name]
 
-  return (
-    typeof value === 'string' &&
-    value.slice(-query.value.length) === query.value
-  )
-}
 
-/**
- * `[attr*=value]`
- *
- * @param {RuleAttr} query
- * @param {Node} node
- */
-function containsString(query, node) {
-  var value = node[query.name]
-  return typeof value === 'string' && value.includes(query.value)
-}
 
-// Shouldn’t be invoked, Parser throws an error instead.
-/* c8 ignore next 6 */
+
 /**
- * @param {{[x: string]: unknown, type: string}} query
+ * @param {string} selector
+ * @param {Node} [node]
+ * @returns {boolean}
  */
-function unknownOperator(query) {
-  throw new Error('Unknown operator `' + query.operator + '`')
+function unist_util_select_matches(selector, node) {
+  return Boolean(any(parse(selector), node, {one: true, shallow: true, any: any})[0])
 }
 
-;// CONCATENATED MODULE: ./node_modules/unist-util-select/lib/name.js
 /**
- * @typedef {import('./types.js').Rule} Rule
- * @typedef {import('./types.js').Node} Node
+ * @param {string} selector
+ * @param {Node} [node]
+ * @returns {Node|null}
  */
+function unist_util_select_select(selector, node) {
+  return any(parse(selector), node, {one: true, any: any})[0] || null
+}
 
 /**
- * @param {Rule} query
- * @param {Node} node
+ * @param {string} selector
+ * @param {Node} [node]
+ * @returns {Array.<Node>}
  */
-function name_name(query, node) {
-  return query.tagName === '*' || query.tagName === node.type
+function selectAll(selector, node) {
+  return any(parse(selector), node, {any: any})
 }
 
-;// CONCATENATED MODULE: ./node_modules/unist-util-select/lib/test.js
-/**
- * @typedef {import('./types.js').Rule} Rule
- * @typedef {import('./types.js').Node} Node
- * @typedef {import('./types.js').Parent} Parent
- * @typedef {import('./types.js').SelectState} SelectState
- */
 
+/***/ }),
+
+/***/ 6393:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
 
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "Vn": () => (/* binding */ visit)
+/* harmony export */ });
+/* harmony import */ var unist_util_visit_parents__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(5605);
+/**
+ * @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
+ */
 
 
 
 /**
- * @param {Rule} query
- * @param {Node} node
- * @param {number|null} index
- * @param {Parent|null} parent
- * @param {SelectState} state
- * @returns {boolean}
+ * 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).
  */
-function test(query, node, index, parent, state) {
-  if (query.id) throw new Error('Invalid selector: id')
-  if (query.classNames) throw new Error('Invalid selector: class')
+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
+      }
 
-  return Boolean(
-    node &&
-      (!query.tagName || name_name(query, node)) &&
-      (!query.attrs || attribute(query, node)) &&
-      (!query.pseudos || pseudo(query, node, index, parent, state))
+      (0,unist_util_visit_parents__WEBPACK_IMPORTED_MODULE_0__/* .visitParents */ .S4)(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: ./node_modules/unist-util-select/lib/any.js
-/**
- * @typedef {import('./types.js').Selector} Selector
- * @typedef {import('./types.js').Selectors} Selectors
- * @typedef {import('./types.js').Rule} Rule
- * @typedef {import('./types.js').RuleSet} RuleSet
- * @typedef {import('./types.js').RulePseudo} RulePseudo
- * @typedef {import('./types.js').Query} Query
- * @typedef {import('./types.js').Node} Node
- * @typedef {import('./types.js').Parent} Parent
- * @typedef {import('./types.js').SelectIterator} SelectIterator
- * @typedef {import('./types.js').SelectState} SelectState
- */
 
 
 
+/***/ }),
 
+/***/ 5605:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
 
+"use strict";
 
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "AM": () => (/* binding */ SKIP),
+  "S4": () => (/* binding */ visitParents)
+});
 
-var type = zwitch('type', {
-  unknown: unknownType,
-  invalid: invalidType,
-  handlers: {selectors, ruleSet, rule}
-})
+// UNUSED EXPORTS: CONTINUE, EXIT
 
+;// CONCATENATED MODULE: ./node_modules/unist-util-visit/node_modules/unist-util-is/index.js
 /**
- * @param {Selectors|RuleSet|Rule} query
- * @param {Node} node
- * @param {SelectState} state
+ * @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
  */
-function any(query, node, state) {
-  // @ts-ignore zwitch types are off.
-  return query && node ? type(query, node, state) : []
-}
 
 /**
- * @param {Selectors} query
+ * Check if a node passes a test
+ *
+ * @callback TestFunctionAnything
  * @param {Node} node
- * @param {SelectState} state
+ * @param {number|null|undefined} [index]
+ * @param {Parent|null|undefined} [parent]
+ * @returns {boolean|void}
  */
-function selectors(query, node, state) {
-  var collect = collector(state.one)
-  var index = -1
-
-  while (++index < query.selectors.length) {
-    collect(ruleSet(query.selectors[index], node, state))
-  }
-
-  return collect.result
-}
 
 /**
- * @param {RuleSet} query
+ * Check if a node passes a certain node test
+ *
+ * @template {Node} X
+ * @callback TestFunctionPredicate
  * @param {Node} node
- * @param {SelectState} state
+ * @param {number|null|undefined} [index]
+ * @param {Parent|null|undefined} [parent]
+ * @returns {node is X}
  */
-function ruleSet(query, node, state) {
-  return rule(query.rule, node, state)
-}
 
 /**
- * @param {Rule} query
- * @param {Node} tree
- * @param {SelectState} state
+ * @callback AssertAnything
+ * @param {unknown} [node]
+ * @param {number|null|undefined} [index]
+ * @param {Parent|null|undefined} [parent]
+ * @returns {boolean}
  */
-function rule(query, tree, state) {
-  var collect = collector(state.one)
 
-  if (state.shallow && query.rule) {
-    throw new Error('Expected selector without nesting')
-  }
+/**
+ * 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}
+ */
 
-  nest(
-    query,
-    tree,
-    0,
-    null,
-    configure(query, {
-      scopeNodes: root(tree) ? tree.children : [tree],
-      index: false,
-      iterator,
-      one: state.one,
-      shallow: state.shallow,
-      any: state.any
-    })
-  )
+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)
 
-  return collect.result
+      if (
+        index !== undefined &&
+        index !== null &&
+        (typeof index !== 'number' ||
+          index < 0 ||
+          index === Number.POSITIVE_INFINITY)
+      ) {
+        throw new Error('Expected positive finite index')
+      }
 
-  /** @type {SelectIterator} */
-  function iterator(query, node, index, parent, state) {
-    if (test(query, node, index, parent, state)) {
-      if ('rule' in query) {
-        nest(query.rule, node, index, parent, configure(query.rule, state))
-      } else {
-        collect(node)
-        state.found = true
+      if (
+        parent !== undefined &&
+        parent !== null &&
+        (!is(parent) || !parent.children)
+      ) {
+        throw new Error('Expected parent node')
       }
-    }
-  }
-}
 
-/**
- * @template {SelectState} S
- * @param {Rule} query
- * @param {S} state
- * @returns {S}
- */
-function configure(query, state) {
-  var pseudos = query.pseudos || []
-  var index = -1
+      if (
+        (parent === undefined || parent === null) !==
+        (index === undefined || index === null)
+      ) {
+        throw new Error('Expected both parent and index')
+      }
 
-  while (++index < pseudos.length) {
-    if (pseudo.needsIndex.includes(pseudos[index].name)) {
-      state.index = true
-      break
+      // @ts-expect-error Looks like a node.
+      return node && node.type && typeof node.type === 'string'
+        ? Boolean(check.call(context, node, index, parent))
+        : false
     }
-  }
+  )
 
-  return state
-}
+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
+      }
 
-// Shouldn’t be invoked, all data is handled.
-/* c8 ignore next 6 */
-/**
- * @param {{[x: string]: unknown, type: string}} query
- */
-function unknownType(query) {
-  throw new Error('Unknown type `' + query.type + '`')
-}
+      if (typeof test === 'string') {
+        return typeFactory(test)
+      }
 
-// Shouldn’t be invoked, parser gives correct data.
-/* c8 ignore next 3 */
-function invalidType() {
-  throw new Error('Invalid type')
-}
+      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 {boolean} one
+ * @param {Array.<Type|Props|TestFunctionAnything>} tests
+ * @returns {AssertAnything}
  */
-function collector(one) {
-  /** @type {Array.<Node>} */
-  var result = []
-  /** @type {boolean} */
-  var found
+function anyFactory(tests) {
+  /** @type {Array.<AssertAnything>} */
+  const checks = []
+  let index = -1
 
-  collect.result = result
+  while (++index < tests.length) {
+    checks[index] = convert(tests[index])
+  }
 
-  return collect
+  return castFactory(any)
 
   /**
-   * Append nodes to array, filtering out duplicates.
-   *
-   * @param {Node|Array.<Node>} node
+   * @this {unknown}
+   * @param {unknown[]} parameters
+   * @returns {boolean}
    */
-  function collect(node) {
-    var index = -1
+  function any(...parameters) {
+    let index = -1
 
-    if ('length' in node) {
-      while (++index < node.length) {
-        collectOne(node[index])
-      }
-    } else {
-      collectOne(node)
+    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 collectOne(node) {
-    if (one) {
-      /* Shouldn’t happen, safeguards performance problems. */
-      /* c8 ignore next */
-      if (found) throw new Error('Cannot collect multiple nodes')
+  function all(node) {
+    /** @type {string} */
+    let key
 
-      found = true
+    for (key in check) {
+      // @ts-expect-error: hush, it sure works as an index.
+      if (node[key] !== check[key]) return false
     }
 
-    if (!result.includes(node)) result.push(node)
+    return true
   }
 }
 
-// EXTERNAL MODULE: ./node_modules/css-selector-parser/lib/index.js
-var lib = __webpack_require__(8079);
-// EXTERNAL MODULE: ./node_modules/nth-check/lib/index.js
-var nth_check_lib = __webpack_require__(7540);
-;// CONCATENATED MODULE: ./node_modules/unist-util-select/lib/parse.js
 /**
- * @typedef {import('./types.js').Selector} Selector
- * @typedef {import('./types.js').Selectors} Selectors
- * @typedef {import('./types.js').RuleSet} RuleSet
- * @typedef {import('./types.js').Rule} Rule
- * @typedef {import('./types.js').RulePseudo} RulePseudo
- * @typedef {import('./types.js').RulePseudoNth} RulePseudoNth
+ * 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)
 
-
-
-
-
-/** @type {import('nth-check').default} */
-// @ts-ignore
-var nthCheck = nth_check_lib/* default */.ZP
-
-var nth = new Set([
-  'nth-child',
-  'nth-last-child',
-  'nth-of-type',
-  'nth-last-of-type'
-])
-
-var parser = new lib/* CssSelectorParser */.N()
-
-parser.registerAttrEqualityMods('~', '^', '$', '*')
-parser.registerSelectorPseudos('any', 'matches', 'not', 'has')
-parser.registerNestingOperators('>', '+', '~')
-
-var compile = zwitch('type', {handlers: {selectors: parse_selectors, ruleSet: parse_ruleSet, rule: parse_rule}})
+  /**
+   * @param {Node} node
+   */
+  function type(node) {
+    return node && node.type === check
+  }
+}
 
 /**
- * @param {string} selector
- * @returns {Selector}
+ * Utility to convert a string into a function which checks a given node’s type
+ * for said string.
+ * @param {TestFunctionAnything} check
+ * @returns {AssertAnything}
  */
-function parse(selector) {
-  if (typeof selector !== 'string') {
-    throw new TypeError('Expected `string` as selector, not `' + selector + '`')
+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
+}
 
-  // @ts-ignore types are wrong.
-  return compile(parser.parse(selector))
+;// 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
 /**
- * @param {Selectors} query
+ * @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
  */
-function parse_selectors(query) {
-  var selectors = query.selectors
-  var index = -1
 
-  while (++index < selectors.length) {
-    compile(selectors[index])
-  }
 
-  return query
-}
+
 
 /**
- * @param {RuleSet} query
+ * Continue traversing as normal
  */
-function parse_ruleSet(query) {
-  return parse_rule(query.rule)
-}
+const CONTINUE = true
+/**
+ * Do not traverse this node’s children
+ */
+const SKIP = 'skip'
+/**
+ * Stop traversing immediately
+ */
+const EXIT = false
 
 /**
- * @param {Rule} query
+ * 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).
  */
-function parse_rule(query) {
-  var pseudos = query.pseudos || []
-  var index = -1
-  /** @type {RulePseudo|RulePseudoNth} */
-  var pseudo
+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
+      }
 
-  while (++index < pseudos.length) {
-    pseudo = pseudos[index]
+      const is = convert(test)
+      const step = reverse ? -1 : 1
 
-    if (nth.has(pseudo.name)) {
-      // @ts-ignore Patch a non-primitive type.
-      pseudo.value = nthCheck(pseudo.value)
-      // @ts-ignore Patch a non-primitive type.
-      pseudo.valueType = 'function'
-    }
-  }
+      factory(tree, null, [])()
 
-  compile(query.rule)
+      /**
+       * @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
 
-  return query
-}
+        if (typeof value.type === 'string') {
+          name =
+            typeof value.tagName === 'string'
+              ? value.tagName
+              : typeof value.name === 'string'
+              ? value.name
+              : undefined
 
-;// CONCATENATED MODULE: ./node_modules/unist-util-select/index.js
-/**
- * @typedef {import('unist').Node} Node
- */
+          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
+            }
+          }
 
-/**
- * @param {string} selector
- * @param {Node} [node]
- * @returns {boolean}
- */
-function unist_util_select_matches(selector, node) {
-  return Boolean(any(parse(selector), node, {one: true, shallow: true, any: any})[0])
-}
+          // @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)
 
-/**
- * @param {string} selector
- * @param {Node} [node]
- * @returns {Node|null}
- */
-function unist_util_select_select(selector, node) {
-  return any(parse(selector), node, {one: true, any: any})[0] || null
-}
+            // @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 {string} selector
- * @param {Node} [node]
- * @returns {Array.<Node>}
+ * @param {VisitorResult} value
+ * @returns {ActionTuple}
  */
-function selectAll(selector, node) {
-  return any(parse(selector), node, {any: any})
+function toResult(value) {
+  if (Array.isArray(value)) {
+    return value
+  }
+
+  if (typeof value === 'number') {
+    return [CONTINUE, value]
+  }
+
+  return [value]
 }
 
 
@@ -34485,32 +34612,69 @@ var __webpack_exports__ = {};
 // This entry need to be wrapped in an IIFE because it need to be in strict mode.
 (() => {
 "use strict";
+// ESM COMPAT FLAG
 __webpack_require__.r(__webpack_exports__);
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   "Components": () => (/* binding */ Components),
-/* harmony export */   "astToPlainText": () => (/* binding */ astToPlainText),
-/* 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),
-/* harmony export */   "processor": () => (/* binding */ processor),
-/* harmony export */   "react": () => (/* binding */ react),
-/* harmony export */   "reactProcessor": () => (/* binding */ reactProcessor),
-/* harmony export */   "reactTOC": () => (/* binding */ reactTOC),
-/* harmony export */   "setup": () => (/* binding */ setup),
-/* harmony export */   "utils": () => (/* binding */ utils)
-/* harmony export */ });
-/* harmony import */ var _babel_runtime_helpers_toConsumableArray__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(2982);
-/* harmony import */ var _babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(1037);
-/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2167);
 
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "Components": () => (/* binding */ Components),
+  "astToPlainText": () => (/* binding */ astToPlainText),
+  "default": () => (/* binding */ index),
+  "hast": () => (/* binding */ hast),
+  "html": () => (/* binding */ html),
+  "htmlProcessor": () => (/* binding */ htmlProcessor),
+  "md": () => (/* binding */ md),
+  "mdast": () => (/* binding */ mdast),
+  "plain": () => (/* binding */ plain),
+  "processor": () => (/* binding */ processor),
+  "react": () => (/* binding */ react),
+  "reactProcessor": () => (/* binding */ reactProcessor),
+  "reactTOC": () => (/* binding */ reactTOC),
+  "setup": () => (/* binding */ setup),
+  "utils": () => (/* binding */ utils)
+});
+
+// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js + 3 modules
+var slicedToArray = __webpack_require__(1037);
+;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+  return target;
+}
+;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js
+
+function _objectWithoutProperties(source, excluded) {
+  if (source == null) return {};
+  var target = _objectWithoutPropertiesLoose(source, excluded);
+  var key, i;
+  if (Object.getOwnPropertySymbols) {
+    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+    for (i = 0; i < sourceSymbolKeys.length; i++) {
+      key = sourceSymbolKeys[i];
+      if (excluded.indexOf(key) >= 0) continue;
+      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+      target[key] = source[key];
+    }
+  }
+  return target;
+}
+// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js + 2 modules
+var defineProperty = __webpack_require__(2167);
+;// CONCATENATED MODULE: ./index.js
 
 
+
+var _excluded = ["reusableContent"];
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0,defineProperty/* default */.Z)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 /* eslint-disable no-param-reassign */
 __webpack_require__(2787);
 var Variable = __webpack_require__(3689);
@@ -34538,17 +34702,17 @@ var _require3 = __webpack_require__(8447),
 var BaseUrlContext = __webpack_require__(6785);
 var createElement = __webpack_require__(5894);
 var CustomParsers = Object.values(__webpack_require__(8521));
-var customCompilers = Object.values(__webpack_require__(9647));
+var customCompilers = Object.values(__webpack_require__(8457));
 var registerCustomComponents = __webpack_require__(1264);
 var _require4 = __webpack_require__(2531),
   options = _require4.options,
   parseOptions = _require4.parseOptions;
-var _require5 = __webpack_require__(8160),
+var _require5 = __webpack_require__(6284),
   calloutIcons = _require5.icons;
 var toPlainText = __webpack_require__(4792);
 var sectionAnchorId = __webpack_require__(9620);
 var tableFlattening = __webpack_require__(4625);
-var _require6 = __webpack_require__(3628),
+var _require6 = __webpack_require__(2692),
   remarkTransformers = _require6.remarkTransformers,
   rehypeTransformers = _require6.rehypeTransformers;
 var createSchema = __webpack_require__(8229);
@@ -34598,34 +34762,53 @@ var utils = {
   calloutIcons: calloutIcons
 };
 
+/**
+ * Pre-parse reusable content blocks. Note that they do not pass the content
+ * blocks recursively.
+ */
+var parseReusableContent = function parseReusableContent(_ref) {
+  var reusableContent = _ref.reusableContent,
+    opts = _objectWithoutProperties(_ref, _excluded);
+  var parsedReusableContent = Object.entries(reusableContent).reduce(function (memo, _ref2) {
+    var _ref3 = (0,slicedToArray/* default */.Z)(_ref2, 2),
+      name = _ref3[0],
+      content = _ref3[1];
+    // eslint-disable-next-line no-use-before-define
+    memo[name] = mdast(content, opts).children;
+    return memo;
+  }, {});
+  return [parsedReusableContent, opts];
+};
+
 /**
  * Core markdown to mdast processor
  */
 function processor() {
-  var _unified$use$use$data;
-  var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var _setup = setup('', opts);
-  var _setup2 = (0,_babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(_setup, 2);
-  opts = _setup2[1];
-  var _opts = opts,
-    sanitize = _opts.sanitize;
-  return (_unified$use$use$data = 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 userOpts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var _setup = setup('', userOpts),
+    _setup2 = (0,slicedToArray/* default */.Z)(_setup, 2),
+    parsedOpts = _setup2[1];
+  var sanitize = parsedOpts.sanitize;
+  var _parseReusableContent = parseReusableContent(parsedOpts),
+    _parseReusableContent2 = (0,slicedToArray/* default */.Z)(_parseReusableContent, 2),
+    reusableContent = _parseReusableContent2[0],
+    opts = _parseReusableContent2[1];
+  return unified().use(remarkParse, opts.markdownOptions).use(remarkFrontmatter, ['yaml', 'toml']).data('settings', opts.settings).data('compatibilityMode', opts.compatibilityMode).data('alwaysThrow', opts.alwaysThrow).data('reusableContent', reusableContent).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.apply(_unified$use$use$data, (0,_babel_runtime_helpers_toConsumableArray__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .Z)(remarkTransformers)).use(remarkSlug).use(remarkDisableTokenizers, opts.disableTokenizers);
+  })).use(remarkTransformers).use(remarkSlug).use(remarkDisableTokenizers, opts.disableTokenizers);
 }
 
 /**
  * Full markdown to html processor
  */
 function htmlProcessor() {
-  var _processor$use$use$us;
   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);
+  var _setup4 = (0,slicedToArray/* default */.Z)(_setup3, 2);
   opts = _setup4[1];
-  var _opts2 = opts,
-    sanitize = _opts2.sanitize;
+  var _opts = opts,
+    sanitize = _opts.sanitize;
 
   /*
    * This is kinda complicated: "markdown" within ReadMe is
@@ -34645,16 +34828,16 @@ function htmlProcessor() {
    * - sanitize and remove any disallowed attributes
    * - output the hast to a React vdom with our custom components
    */
-  return (_processor$use$use$us = processor(opts).use(remarkRehype, {
+  return processor(opts).use(remarkRehype, {
     allowDangerousHtml: true
-  }).use(rehypeRaw).use(rehypeSanitize, sanitize)).use.apply(_processor$use$use$us, (0,_babel_runtime_helpers_toConsumableArray__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .Z)(rehypeTransformers));
+  }).use(rehypeRaw).use(rehypeSanitize, sanitize).use(rehypeTransformers);
 }
 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 _setup5 = setup(text, opts);
-  var _setup6 = (0,_babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(_setup5, 2);
+  var _setup6 = (0,slicedToArray/* default */.Z)(_setup5, 2);
   text = _setup6[0];
   opts = _setup6[1];
   var proc = htmlProcessor(opts).use(rehypeReact, {
@@ -34669,8 +34852,8 @@ function plain(text) {
  *  return a React VDOM component tree
  */
 // eslint-disable-next-line react/prop-types
-var PinWrap = function PinWrap(_ref) {
-  var children = _ref.children;
+var PinWrap = function PinWrap(_ref4) {
+  var children = _ref4.children;
   return /*#__PURE__*/React.createElement("div", {
     className: "pin"
   }, children);
@@ -34680,10 +34863,10 @@ function reactProcessor() {
   var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
   var components = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   var _setup7 = setup('', opts);
-  var _setup8 = (0,_babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(_setup7, 2);
+  var _setup8 = (0,slicedToArray/* default */.Z)(_setup7, 2);
   opts = _setup8[1];
-  var _opts3 = opts,
-    sanitize = _opts3.sanitize;
+  var _opts2 = opts,
+    sanitize = _opts2.sanitize;
   return htmlProcessor(_objectSpread({}, opts)).use(sectionAnchorId).use(rehypeReact, {
     createElement: createElement(opts),
     Fragment: React.Fragment,
@@ -34714,12 +34897,12 @@ function react(content) {
   var components = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   if (!content) return null;else if (typeof content === 'string') {
     var _setup9 = setup(content, opts);
-    var _setup10 = (0,_babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(_setup9, 2);
+    var _setup10 = (0,slicedToArray/* 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);
+    var _setup12 = (0,slicedToArray/* default */.Z)(_setup11, 2);
     opts = _setup12[1];
   }
   var proc = reactProcessor(opts, components);
@@ -34730,7 +34913,7 @@ function reactTOC(tree) {
   var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   if (!tree) return null;
   var _setup13 = setup('', opts);
-  var _setup14 = (0,_babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(_setup13, 2);
+  var _setup14 = (0,slicedToArray/* default */.Z)(_setup13, 2);
   opts = _setup14[1];
   var proc = htmlProcessor(opts).use(rehypeReact, {
     createElement: React.createElement,
@@ -34742,8 +34925,8 @@ function reactTOC(tree) {
   });
 
   // Normalize Heading Levels
-  var minLevel = selectAll('heading', tree).reduce(function (i, _ref2) {
-    var depth = _ref2.depth;
+  var minLevel = selectAll('heading', tree).reduce(function (i, _ref5) {
+    var depth = _ref5.depth;
     return !i || depth <= i ? depth : i;
   }, false); // determine "root" depth
   tree = mapNodes(tree, function (n) {
@@ -34764,7 +34947,7 @@ function html(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);
+  var _setup16 = (0,slicedToArray/* default */.Z)(_setup15, 2);
   text = _setup16[0];
   opts = _setup16[1];
   return htmlProcessor(opts).use(rehypeStringify).processSync(text).contents;
@@ -34777,7 +34960,7 @@ function hast(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);
+  var _setup18 = (0,slicedToArray/* default */.Z)(_setup17, 2);
   text = _setup18[0];
   opts = _setup18[1];
   var rdmd = htmlProcessor(opts).use(tableFlattening);
@@ -34792,7 +34975,7 @@ function mdast(text) {
   var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   if (!text) return null;
   var _setup19 = setup(text, opts);
-  var _setup20 = (0,_babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(_setup19, 2);
+  var _setup20 = (0,slicedToArray/* default */.Z)(_setup19, 2);
   text = _setup20[0];
   opts = _setup20[1];
   var rdmd = processor(opts);
@@ -34806,7 +34989,7 @@ function astToPlainText(node) {
   var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   if (!node) return '';
   var _setup21 = setup('', opts);
-  var _setup22 = (0,_babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(_setup21, 2);
+  var _setup22 = (0,slicedToArray/* default */.Z)(_setup21, 2);
   opts = _setup22[1];
   return processor(opts).use(toPlainText).stringify(node);
 }
@@ -34818,7 +35001,7 @@ function md(tree) {
   var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   if (!tree) return null;
   var _setup23 = setup('', opts);
-  var _setup24 = (0,_babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(_setup23, 2);
+  var _setup24 = (0,slicedToArray/* default */.Z)(_setup23, 2);
   opts = _setup24[1];
   return processor(opts).use(remarkStringify, opts.markdownOptions).use(customCompilers).stringify(tree);
 }
@@ -34826,7 +35009,7 @@ var ReadMeMarkdown = function ReadMeMarkdown(text) {
   var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   return react(text, opts);
 };
-/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (ReadMeMarkdown);
+/* harmony default export */ const index = (ReadMeMarkdown);
 })();
 
 /******/ 	return __webpack_exports__;