@readme/markdown 6.68.0-beta.1 → 6.68.0-beta.3

package/dist/main.node.js

@@ -9154,64 +9154,94 @@ 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 */   "reusableContentCompiler": () => (/* reexport default from dynamic */ _reusable_content__WEBPACK_IMPORTED_MODULE_13___default.a),
-/* harmony export */   "tableCompiler": () => (/* reexport default from dynamic */ _table__WEBPACK_IMPORTED_MODULE_14___default.a),
-/* harmony export */   "tableHeadCompiler": () => (/* reexport default from dynamic */ _table_head__WEBPACK_IMPORTED_MODULE_15___default.a),
-/* harmony export */   "yamlCompiler": () => (/* reexport default from dynamic */ _yaml__WEBPACK_IMPORTED_MODULE_16___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 _reusable_content__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(9585);
-/* harmony import */ var _reusable_content__WEBPACK_IMPORTED_MODULE_13___default = /*#__PURE__*/__webpack_require__.n(_reusable_content__WEBPACK_IMPORTED_MODULE_13__);
-/* harmony import */ var _table__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(4669);
-/* harmony import */ var _table__WEBPACK_IMPORTED_MODULE_14___default = /*#__PURE__*/__webpack_require__.n(_table__WEBPACK_IMPORTED_MODULE_14__);
-/* harmony import */ var _table_head__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(186);
-/* harmony import */ var _table_head__WEBPACK_IMPORTED_MODULE_15___default = /*#__PURE__*/__webpack_require__.n(_table_head__WEBPACK_IMPORTED_MODULE_15__);
-/* harmony import */ var _yaml__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(1773);
-/* harmony import */ var _yaml__WEBPACK_IMPORTED_MODULE_16___default = /*#__PURE__*/__webpack_require__.n(_yaml__WEBPACK_IMPORTED_MODULE_16__);
+
+// 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
+var reusable_content = __webpack_require__(5772);
+;// 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
 
 
 
@@ -9246,19 +9276,6 @@ module.exports = function PinCompiler() {
 
 /***/ }),
 
-/***/ 9585:
-/***/ ((module) => {
-
-module.exports = function ReusableContentCompiler() {
-  var Compiler = this.Compiler;
-  var visitors = Compiler.prototype.visitors;
-  visitors['reusable-content'] = function (node) {
-    return "<ReadMeReusableContent name=\"".concat(node.name, "\" />");
-  };
-};
-
-/***/ }),
-
 /***/ 186:
 /***/ ((module) => {
 
@@ -10497,7 +10514,7 @@ module.exports.tableFlattening = transformer;
 
 /***/ }),
 
-/***/ 1269:
+/***/ 2692:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -10510,702 +10527,223 @@ __webpack_require__.d(__webpack_exports__, {
   "remarkTransformers": () => (/* binding */ remarkTransformers)
 });
 
-// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/typeof.js
-var helpers_typeof = __webpack_require__(8698);
-var typeof_default = /*#__PURE__*/__webpack_require__.n(helpers_typeof);
-// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/inherits.js
-var inherits = __webpack_require__(1655);
-var inherits_default = /*#__PURE__*/__webpack_require__.n(inherits);
-// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/setPrototypeOf.js
-var setPrototypeOf = __webpack_require__(6015);
-var setPrototypeOf_default = /*#__PURE__*/__webpack_require__.n(setPrototypeOf);
-;// CONCATENATED MODULE: ./node_modules/unist-util-visit/node_modules/unist-util-is/index.js
-/**
- * @typedef {import('unist').Node} Node
- * @typedef {import('unist').Parent} Parent
- *
- * @typedef {string} Type
- * @typedef {Object<string, unknown>} Props
- *
- * @typedef {null|undefined|Type|Props|TestFunctionAnything|Array.<Type|Props|TestFunctionAnything>} Test
- */
-
-/**
- * Check if a node passes a test
- *
- * @callback TestFunctionAnything
- * @param {Node} node
- * @param {number|null|undefined} [index]
- * @param {Parent|null|undefined} [parent]
- * @returns {boolean|void}
- */
+// EXTERNAL MODULE: ./processor/transform/reusable-content.js
+var reusable_content = __webpack_require__(5772);
+// 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 certain node test
- *
- * @template {Node} X
- * @callback TestFunctionPredicate
- * @param {Node} node
- * @param {number|null|undefined} [index]
- * @param {Parent|null|undefined} [parent]
- * @returns {node is X}
- */
+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__(9445);
+;// CONCATENATED MODULE: ./processor/transform/table-cell-inline-code.js
 
-/**
- * @callback AssertAnything
- * @param {unknown} [node]
- * @param {number|null|undefined} [index]
- * @param {Parent|null|undefined} [parent]
- * @returns {boolean}
- */
+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} Y
- * @callback AssertPredicate
- * @param {unknown} [node]
- * @param {number|null|undefined} [index]
- * @param {Parent|null|undefined} [parent]
- * @returns {node is Y}
+ * 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
 
-const is =
-  /**
-   * Check if a node passes a test.
-   * When a `parent` node is known the `index` of node should also be given.
-   *
-   * @type {(
-   *   (<T extends Node>(node: unknown, test: T['type']|Partial<T>|TestFunctionPredicate<T>|Array.<T['type']|Partial<T>|TestFunctionPredicate<T>>, index?: number|null|undefined, parent?: Parent|null|undefined, context?: unknown) => node is T) &
-   *   ((node?: unknown, test?: Test, index?: number|null|undefined, parent?: Parent|null|undefined, context?: unknown) => boolean)
-   * )}
-   */
-  (
-    /**
-     * Check if a node passes a test.
-     * When a `parent` node is known the `index` of node should also be given.
-     *
-     * @param {unknown} [node] Node to check
-     * @param {Test} [test]
-     * When nullish, checks if `node` is a `Node`.
-     * When `string`, works like passing `function (node) {return node.type === test}`.
-     * When `function` checks if function passed the node is true.
-     * When `object`, checks that all keys in test are in node, and that they have (strictly) equal values.
-     * When `array`, checks any one of the subtests pass.
-     * @param {number|null|undefined} [index] Position of `node` in `parent`
-     * @param {Parent|null|undefined} [parent] Parent of `node`
-     * @param {unknown} [context] Context object to invoke `test` with
-     * @returns {boolean} Whether test passed and `node` is a `Node` (object with `type` set to non-empty `string`).
-     */
-    // eslint-disable-next-line max-params
-    function is(node, test, index, parent, context) {
-      const check = convert(test)
-
-      if (
-        index !== undefined &&
-        index !== null &&
-        (typeof index !== 'number' ||
-          index < 0 ||
-          index === Number.POSITIVE_INFINITY)
-      ) {
-        throw new Error('Expected positive finite index')
-      }
-
-      if (
-        parent !== undefined &&
-        parent !== null &&
-        (!is(parent) || !parent.children)
-      ) {
-        throw new Error('Expected parent node')
-      }
 
-      if (
-        (parent === undefined || parent === null) !==
-        (index === undefined || index === null)
-      ) {
-        throw new Error('Expected both parent and index')
-      }
 
-      // @ts-expect-error Looks like a node.
-      return node && node.type && typeof node.type === 'string'
-        ? Boolean(check.call(context, node, index, parent))
-        : false
-    }
-  )
+var remarkTransformers = [single_code_tabs, reusable_content/* default */.ZP];
+var rehypeTransformers = [table_cell_inline_code];
 
-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)
-      }
+/***/ 5772:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
-      if (typeof test === 'object') {
-        return Array.isArray(test) ? anyFactory(test) : propsFactory(test)
-      }
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "ZP": () => (__WEBPACK_DEFAULT_EXPORT__),
+/* harmony export */   "_q": () => (/* binding */ tag),
+/* harmony export */   "dt": () => (/* binding */ type)
+/* harmony export */ });
+/* harmony import */ var unist_util_visit__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6393);
 
-      if (typeof test === 'function') {
-        return castFactory(test)
-      }
+var type = 'reusable-content';
+var tag = 'RMReusableContent';
+var regexp = new RegExp("^\\s*<".concat(tag, " name=\"(?<name>.*)\" />\\s*$"));
+var reusableContentTransformer = function reusableContentTransformer() {
+  var reusableContent = this.data('reusableContent');
+  return function (tree) {
+    (0,unist_util_visit__WEBPACK_IMPORTED_MODULE_0__/* .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 __WEBPACK_DEFAULT_EXPORT__ = (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__) => {
 
-  return castFactory(any)
-
-  /**
-   * @this {unknown}
-   * @param {unknown[]} parameters
-   * @returns {boolean}
-   */
-  function any(...parameters) {
-    let index = -1
-
-    while (++index < checks.length) {
-      if (checks[index].call(this, ...parameters)) return true
-    }
+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));
 
-    return false
+  // 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;
 
-/**
- * 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
+/***/ 8841:
+/***/ ((module) => {
 
-    for (key in check) {
-      // @ts-expect-error: hush, it sure works as an index.
-      if (node[key] !== check[key]) return false
-    }
+"use strict";
 
-    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)
+module.exports = bail
 
-  /**
-   * @param {Node} node
-   */
-  function type(node) {
-    return node && node.type === check
+function bail(err) {
+  if (err) {
+    throw err
   }
 }
 
-/**
- * Utility to convert a string into a function which checks a given node’s type
- * for said string.
- * @param {TestFunctionAnything} check
- * @returns {AssertAnything}
- */
-function castFactory(check) {
-  return assertion
 
-  /**
-   * @this {unknown}
-   * @param {Array.<unknown>} parameters
-   * @returns {boolean}
-   */
-  function assertion(...parameters) {
-    // @ts-expect-error: spreading is fine.
-    return Boolean(check.call(this, ...parameters))
-  }
-}
+/***/ }),
 
-// Utility to return true.
-function ok() {
-  return true
-}
+/***/ 1073:
+/***/ ((module) => {
 
-;// CONCATENATED MODULE: ./node_modules/unist-util-visit/node_modules/unist-util-visit-parents/color.js
-/**
- * @param {string} d
- * @returns {string}
- */
-function color(d) {
-  return '\u001B[33m' + d + '\u001B[39m'
-}
+module.exports = {
+	trueFunc: function trueFunc(){
+		return true;
+	},
+	falseFunc: function falseFunc(){
+		return false;
+	}
+};
 
-;// 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
- */
+/***/ }),
 
+/***/ 932:
+/***/ ((module) => {
 
+"use strict";
 
 
-/**
- * Continue traversing as normal
- */
-const CONTINUE = true
-/**
- * Do not traverse this node’s children
- */
-const SKIP = 'skip'
-/**
- * Stop traversing immediately
- */
-const EXIT = false
+module.exports = ccount
 
-/**
- * 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
-      }
+function ccount(value, character) {
+  var val = String(value)
+  var count = 0
+  var index
 
-      const is = convert(test)
-      const step = reverse ? -1 : 1
+  if (typeof character !== 'string' || character.length !== 1) {
+    throw new Error('Expected character')
+  }
 
-      factory(tree, null, [])()
+  index = val.indexOf(character)
 
-      /**
-       * @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
+  while (index !== -1) {
+    count++
+    index = val.indexOf(character, index + 1)
+  }
 
-        if (typeof value.type === 'string') {
-          name =
-            typeof value.tagName === 'string'
-              ? value.tagName
-              : typeof value.name === 'string'
-              ? value.name
-              : undefined
+  return count
+}
 
-          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
+/***/ 6313:
+/***/ ((module) => {
 
-          if (!test || is(node, index, parents[parents.length - 1] || null)) {
-            result = toResult(visitor(node, parents))
+var clone = (function() {
+'use strict';
 
-            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/reusable-content.js
-
-
-
-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_default()(_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_default()(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" != typeof_default()(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); }
-
-var type = 'reusable-content';
-var regexp = /*#__PURE__*/_wrapRegExp(/^\s*<ReadMeReusableContent name="(.*)" \/>\s*$/, {
-  name: 1
-});
-var reusableContentTransformer = function reusableContentTransformer() {
-  var reusableContent = this.data('reusableContent');
-  return function (tree) {
-    visit(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);
-;// 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, reusable_content];
-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;
-}
+function _instanceof(obj, type) {
+  return type != null && obj instanceof type;
+}
 
 var nativeMap;
 try {
@@ -32657,745 +32195,972 @@ const defaultSchema = {
 }
 
 
-/***/ }),
+/***/ }),
+
+/***/ 1445:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "map": () => (/* binding */ map)
+/* harmony export */ });
+/**
+ * @typedef {import('unist').Node} Node
+ */
+
+/**
+ * @template {Node} [Tree=Node]
+ * @typedef {import('./complex-types.js').MapFunction<Tree>} MapFunction
+ *   Function called with a node, its index, and its parent to produce a new
+ *   node.
+ */
+
+/**
+ * Create a new tree by mapping all nodes with the given function.
+ *
+ * @template {Node} Tree
+ *   Type of input tree.
+ * @param {Tree} tree
+ *   Tree to map.
+ * @param {MapFunction<Tree>} mapFunction
+ *   Function called with a node, its index, and its parent to produce a new
+ *   node.
+ * @returns {Tree}
+ *   New mapped tree.
+ */
+function map(tree, mapFunction) {
+  // @ts-expect-error Looks like a children.
+  return preorder(tree, null, null)
+
+  /** @type {import('./complex-types').MapFunction<Tree>} */
+  function preorder(node, index, parent) {
+    var newNode = Object.assign({}, mapFunction(node, index, parent))
+
+    if ('children' in node) {
+      // @ts-expect-error Looks like a parent.
+      newNode.children = node.children.map(function (
+        /** @type {import('./complex-types').InclusiveDescendant<Tree>} */ child,
+        /** @type {number} */ index
+      ) {
+        return preorder(child, index, node)
+      })
+    }
+
+    return newNode
+  }
+}
+
+
+/***/ }),
+
+/***/ 5907:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "matches": () => (/* binding */ unist_util_select_matches),
+  "select": () => (/* binding */ unist_util_select_select),
+  "selectAll": () => (/* binding */ selectAll)
+});
+
+;// CONCATENATED MODULE: ./node_modules/unist-util-select/node_modules/zwitch/index.js
+var own = {}.hasOwnProperty
+
+/**
+ * @callback Handler
+ * @param {...unknown} value
+ * @return {unknown}
+ *
+ * @typedef {Record<string, Handler>} Handlers
+ *
+ * @typedef {Object} Options
+ * @property {Handler} [unknown]
+ * @property {Handler} [invalid]
+ * @property {Handlers} [handlers]
+ */
+
+/**
+ * Handle values based on a property.
+ *
+ * @param {string} key
+ * @param {Options} [options]
+ */
+function zwitch(key, options) {
+  var settings = options || {}
+
+  /**
+   * Handle one value.
+   * Based on the bound `key`, a respective handler will be called.
+   * If `value` is not an object, or doesn’t have a `key` property, the special
+   * “invalid” handler will be called.
+   * If `value` has an unknown `key`, the special “unknown” handler will be
+   * called.
+   *
+   * All arguments, and the context object, are passed through to the handler,
+   * and it’s result is returned.
+   *
+   * @param {...unknown} [value]
+   * @this {unknown}
+   * @returns {unknown}
+   * @property {Handler} invalid
+   * @property {Handler} unknown
+   * @property {Handlers} handlers
+   */
+  function one(value) {
+    var fn = one.invalid
+    var handlers = one.handlers
+
+    if (value && own.call(value, key)) {
+      fn = own.call(handlers, value[key]) ? handlers[value[key]] : one.unknown
+    }
+
+    if (fn) {
+      return fn.apply(this, arguments)
+    }
+  }
+
+  one.handlers = settings.handlers || {}
+  one.invalid = settings.invalid
+  one.unknown = settings.unknown
+
+  return one
+}
+
+;// CONCATENATED MODULE: ./node_modules/unist-util-select/lib/util.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
+ */
+
+/**
+ * @param {Node} node
+ * @returns {node is Parent}
+ */
+function root(node) {
+  return (
+    // Root in nlcst.
+    node.type === 'RootNode' ||
+    // Rest
+    node.type === 'root'
+  )
+}
+
+/**
+ * @param {Node} node
+ * @returns {node is Parent}
+ */
+function util_parent(node) {
+  return Array.isArray(node.children)
+}
+
+;// CONCATENATED MODULE: ./node_modules/unist-util-select/lib/nest.js
+/**
+ * @typedef {import('./types.js').Rule} Rule
+ * @typedef {import('./types.js').Query} Query
+ * @typedef {import('./types.js').Node} Node
+ * @typedef {import('./types.js').Parent} Parent
+ * @typedef {import('./types.js').SelectState} SelectState
+ * @typedef {import('./types.js').SelectIterator} SelectIterator
+ * @typedef {import('./types.js').Handler} Handler
+ */
+
+
+
+
+var nest_own = {}.hasOwnProperty
+
+var handle = zwitch('nestingOperator', {
+  unknown: unknownNesting,
+  invalid: topScan, // `undefined` is the top query selector.
+  handlers: {
+    null: descendant, // `null` is the descendant combinator.
+    '>': child,
+    '+': adjacentSibling,
+    '~': generalSibling
+  }
+})
+
+/** @type {Handler} */
+function nest(query, node, index, parent, state) {
+  return handle(query, node, index, parent, state)
+}
+
+// Shouldn’t be invoked, parser gives correct data.
+/* c8 ignore next 6 */
+/**
+ * @param {{[x: string]: unknown, type: string}} query
+ */
+function unknownNesting(query) {
+  throw new Error('Unexpected nesting `' + query.nestingOperator + '`')
+}
+
+/** @type {Handler} */
+function topScan(query, node, index, parent, state) {
+  // Shouldn’t happen.
+  /* c8 ignore next 3 */
+  if (parent) {
+    throw new Error('topScan is supposed to be called from the root node')
+  }
+
+  state.iterator(query, node, index, parent, state)
+  if (!state.shallow) descendant(query, node, index, parent, state)
+}
+
+/** @type {Handler} */
+function descendant(query, node, index, parent, state) {
+  var previous = state.iterator
+
+  state.iterator = iterator
+  child(query, node, index, parent, state)
 
-/***/ 1445:
-/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+  /** @type {SelectIterator} */
+  function iterator(query, node, index, parent, state) {
+    state.iterator = previous
+    previous(query, node, index, parent, state)
+    state.iterator = iterator
 
-"use strict";
-__webpack_require__.r(__webpack_exports__);
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   "map": () => (/* binding */ map)
-/* harmony export */ });
-/**
- * @typedef {import('unist').Node} Node
- */
+    if (state.one && state.found) return
 
-/**
- * @template {Node} [Tree=Node]
- * @typedef {import('./complex-types.js').MapFunction<Tree>} MapFunction
- *   Function called with a node, its index, and its parent to produce a new
- *   node.
- */
+    child(query, node, index, parent, state)
+  }
+}
 
-/**
- * Create a new tree by mapping all nodes with the given function.
- *
- * @template {Node} Tree
- *   Type of input tree.
- * @param {Tree} tree
- *   Tree to map.
- * @param {MapFunction<Tree>} mapFunction
- *   Function called with a node, its index, and its parent to produce a new
- *   node.
- * @returns {Tree}
- *   New mapped tree.
- */
-function map(tree, mapFunction) {
-  // @ts-expect-error Looks like a children.
-  return preorder(tree, null, null)
+/** @type {Handler} */
+function child(query, node, _1, _2, state) {
+  if (!util_parent(node)) return
+  if (node.children.length === 0) return
 
-  /** @type {import('./complex-types').MapFunction<Tree>} */
-  function preorder(node, index, parent) {
-    var newNode = Object.assign({}, mapFunction(node, index, parent))
+  new WalkIterator(query, node, state).each().done()
+}
 
-    if ('children' in node) {
-      // @ts-expect-error Looks like a parent.
-      newNode.children = node.children.map(function (
-        /** @type {import('./complex-types').InclusiveDescendant<Tree>} */ child,
-        /** @type {number} */ index
-      ) {
-        return preorder(child, index, node)
-      })
+/** @type {Handler} */
+function adjacentSibling(query, _, index, parent, state) {
+  // Shouldn’t happen.
+  /* c8 ignore next */
+  if (!parent) return
+
+  new WalkIterator(query, parent, state)
+    .prefillTypeIndex(0, ++index)
+    .each(index, ++index)
+    .prefillTypeIndex(index)
+    .done()
+}
+
+/** @type {Handler} */
+function generalSibling(query, _, index, parent, state) {
+  // Shouldn’t happen.
+  /* c8 ignore next */
+  if (!parent) return
+
+  new WalkIterator(query, parent, state)
+    .prefillTypeIndex(0, ++index)
+    .each(index)
+    .done()
+}
+
+class WalkIterator {
+  /**
+   * Handles typeIndex and typeCount properties for every walker.
+   *
+   * @param {Rule} query
+   * @param {Parent} parent
+   * @param {SelectState} state
+   */
+  constructor(query, parent, state) {
+    /** @type {Rule} */
+    this.query = query
+    /** @type {Parent} */
+    this.parent = parent
+    /** @type {SelectState} */
+    this.state = state
+    /** @type {TypeIndex|undefined} */
+    this.typeIndex = state.index ? new TypeIndex() : undefined
+    /** @type {Array.<Function>} */
+    this.delayed = []
+  }
+
+  /**
+   * @param {number|null|undefined} [x]
+   * @param {number|null|undefined} [y]
+   * @returns {this}
+   */
+  prefillTypeIndex(x, y) {
+    var [start, end] = this.defaults(x, y)
+
+    if (this.typeIndex) {
+      while (start < end) {
+        this.typeIndex.index(this.parent.children[start])
+        start++
+      }
     }
 
-    return newNode
+    return this
   }
-}
 
+  /**
+   * @param {number|null|undefined} [x]
+   * @param {number|null|undefined} [y]
+   * @returns {this}
+   */
+  each(x, y) {
+    var [start, end] = this.defaults(x, y)
+    var child = this.parent.children[start]
+    /** @type {number} */
+    var index
+    /** @type {number} */
+    var nodeIndex
 
-/***/ }),
+    if (start >= end) return this
 
-/***/ 5907:
-/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+    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)
+    }
 
-"use strict";
-// ESM COMPAT FLAG
-__webpack_require__.r(__webpack_exports__);
+    // Stop if we’re looking for one node and it’s already found.
+    if (this.state.one && this.state.found) return this
 
-// EXPORTS
-__webpack_require__.d(__webpack_exports__, {
-  "matches": () => (/* binding */ unist_util_select_matches),
-  "select": () => (/* binding */ unist_util_select_select),
-  "selectAll": () => (/* binding */ selectAll)
-});
+    return this.each(start + 1, end)
 
-;// CONCATENATED MODULE: ./node_modules/unist-util-select/node_modules/zwitch/index.js
-var own = {}.hasOwnProperty
+    /**
+     * @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)
+    }
+  }
 
-/**
- * @callback Handler
- * @param {...unknown} value
- * @return {unknown}
- *
- * @typedef {Record<string, Handler>} Handlers
- *
- * @typedef {Object} Options
- * @property {Handler} [unknown]
- * @property {Handler} [invalid]
- * @property {Handlers} [handlers]
- */
+  /**
+   * Done!
+   * @returns {this}
+   */
+  done() {
+    var index = -1
 
-/**
- * Handle values based on a property.
- *
- * @param {string} key
- * @param {Options} [options]
- */
-function zwitch(key, options) {
-  var settings = options || {}
+    while (++index < this.delayed.length) {
+      this.delayed[index].call(this)
+      if (this.state.one && this.state.found) break
+    }
+
+    return this
+  }
 
   /**
-   * Handle one value.
-   * Based on the bound `key`, a respective handler will be called.
-   * If `value` is not an object, or doesn’t have a `key` property, the special
-   * “invalid” handler will be called.
-   * If `value` has an unknown `key`, the special “unknown” handler will be
-   * called.
-   *
-   * All arguments, and the context object, are passed through to the handler,
-   * and it’s result is returned.
-   *
-   * @param {...unknown} [value]
-   * @this {unknown}
-   * @returns {unknown}
-   * @property {Handler} invalid
-   * @property {Handler} unknown
-   * @property {Handlers} handlers
+   * @param {number|null|undefined} [start]
+   * @param {number|null|undefined} [end]
+   * @returns {[number, number]}
    */
-  function one(value) {
-    var fn = one.invalid
-    var handlers = one.handlers
+  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 (value && own.call(value, key)) {
-      fn = own.call(handlers, value[key]) ? handlers[value[key]] : one.unknown
-    }
+    if (!nest_own.call(this.counts, type)) this.counts[type] = 0
 
-    if (fn) {
-      return fn.apply(this, arguments)
-    }
+    // Note: `++` is intended to be postfixed!
+    return this.counts[type]++
   }
 
-  one.handlers = settings.handlers || {}
-  one.invalid = settings.invalid
-  one.unknown = settings.unknown
-
-  return one
+  /**
+   * @param {Node} node
+   * @returns {number|undefined}
+   */
+  count(node) {
+    return this.counts[node.type]
+  }
 }
 
-;// CONCATENATED MODULE: ./node_modules/unist-util-select/lib/util.js
+;// CONCATENATED MODULE: ./node_modules/unist-util-select/node_modules/unist-util-is/index.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
+ * @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
- * @returns {node is Parent}
+ * @param {number} [index]
+ * @param {Parent} [parent]
+ * @returns {boolean|void}
  */
-function root(node) {
-  return (
-    // Root in nlcst.
-    node.type === 'RootNode' ||
-    // Rest
-    node.type === 'root'
-  )
-}
 
 /**
+ * Check if a node passes a certain node test
+ *
+ * @template {Node} X
+ * @callback TestFunctionPredicate
  * @param {Node} node
- * @returns {node is Parent}
+ * @param {number} [index]
+ * @param {Parent} [parent]
+ * @returns {node is X}
  */
-function util_parent(node) {
-  return Array.isArray(node.children)
-}
 
-;// CONCATENATED MODULE: ./node_modules/unist-util-select/lib/nest.js
 /**
- * @typedef {import('./types.js').Rule} Rule
- * @typedef {import('./types.js').Query} Query
- * @typedef {import('./types.js').Node} Node
- * @typedef {import('./types.js').Parent} Parent
- * @typedef {import('./types.js').SelectState} SelectState
- * @typedef {import('./types.js').SelectIterator} SelectIterator
- * @typedef {import('./types.js').Handler} Handler
+ * @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')
+      }
 
-var nest_own = {}.hasOwnProperty
-
-var handle = zwitch('nestingOperator', {
-  unknown: unknownNesting,
-  invalid: topScan, // `undefined` is the top query selector.
-  handlers: {
-    null: descendant, // `null` is the descendant combinator.
-    '>': child,
-    '+': adjacentSibling,
-    '~': generalSibling
-  }
-})
-
-/** @type {Handler} */
-function nest(query, node, index, parent, state) {
-  return handle(query, node, index, parent, state)
-}
+      if (
+        parent !== undefined &&
+        parent !== null &&
+        (!is(parent) || !parent.children)
+      ) {
+        throw new Error('Expected parent node')
+      }
 
-// Shouldn’t be invoked, parser gives correct data.
-/* c8 ignore next 6 */
-/**
- * @param {{[x: string]: unknown, type: string}} query
- */
-function unknownNesting(query) {
-  throw new Error('Unexpected nesting `' + query.nestingOperator + '`')
-}
+      if (
+        (parent === undefined || parent === null) !==
+        (index === undefined || index === null)
+      ) {
+        throw new Error('Expected both parent and index')
+      }
 
-/** @type {Handler} */
-function topScan(query, node, index, parent, state) {
-  // Shouldn’t happen.
-  /* c8 ignore next 3 */
-  if (parent) {
-    throw new Error('topScan is supposed to be called from the root node')
-  }
+      // @ts-ignore Looks like a node.
+      return node && node.type && typeof node.type === 'string'
+        ? Boolean(check.call(context, node, index, parent))
+        : false
+    }
+  )
 
-  state.iterator(query, node, index, parent, state)
-  if (!state.shallow) descendant(query, node, index, parent, state)
-}
+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
+      }
 
-/** @type {Handler} */
-function descendant(query, node, index, parent, state) {
-  var previous = state.iterator
+      if (typeof test === 'string') {
+        return typeFactory(test)
+      }
 
-  state.iterator = iterator
-  child(query, node, index, parent, state)
+      if (typeof test === 'object') {
+        // @ts-ignore looks like a list of tests / partial test object.
+        return 'length' in test ? anyFactory(test) : propsFactory(test)
+      }
 
-  /** @type {SelectIterator} */
-  function iterator(query, node, index, parent, state) {
-    state.iterator = previous
-    previous(query, node, index, parent, state)
-    state.iterator = iterator
+      if (typeof test === 'function') {
+        return castFactory(test)
+      }
 
-    if (state.one && state.found) return
+      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
 
-    child(query, node, index, parent, state)
+  while (++index < tests.length) {
+    checks[index] = convert(tests[index])
   }
-}
 
-/** @type {Handler} */
-function child(query, node, _1, _2, state) {
-  if (!util_parent(node)) return
-  if (node.children.length === 0) return
+  return castFactory(any)
 
-  new WalkIterator(query, node, state).each().done()
+  /**
+   * @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
+    }
+  }
 }
 
-/** @type {Handler} */
-function adjacentSibling(query, _, index, parent, state) {
-  // Shouldn’t happen.
-  /* c8 ignore next */
-  if (!parent) return
+/**
+ * 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)
 
-  new WalkIterator(query, parent, state)
-    .prefillTypeIndex(0, ++index)
-    .each(index, ++index)
-    .prefillTypeIndex(index)
-    .done()
-}
+  /**
+   * @param {Node} node
+   * @returns {boolean}
+   */
+  function all(node) {
+    /** @type {string} */
+    var key
 
-/** @type {Handler} */
-function generalSibling(query, _, index, parent, state) {
-  // Shouldn’t happen.
-  /* c8 ignore next */
-  if (!parent) return
+    for (key in check) {
+      if (node[key] !== check[key]) return
+    }
 
-  new WalkIterator(query, parent, state)
-    .prefillTypeIndex(0, ++index)
-    .each(index)
-    .done()
+    return true
+  }
 }
 
-class WalkIterator {
+/**
+ * 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)
+
   /**
-   * Handles typeIndex and typeCount properties for every walker.
-   *
-   * @param {Rule} query
-   * @param {Parent} parent
-   * @param {SelectState} state
+   * @param {Node} node
    */
-  constructor(query, parent, state) {
-    /** @type {Rule} */
-    this.query = query
-    /** @type {Parent} */
-    this.parent = parent
-    /** @type {SelectState} */
-    this.state = state
-    /** @type {TypeIndex|undefined} */
-    this.typeIndex = state.index ? new TypeIndex() : undefined
-    /** @type {Array.<Function>} */
-    this.delayed = []
+  function type(node) {
+    return node && node.type === check
   }
+}
+
+/**
+ * Utility to convert a string into a function which checks a given node’s type
+ * for said string.
+ * @param {TestFunctionAnything} check
+ * @returns {AssertAnything}
+ */
+function castFactory(check) {
+  return assertion
 
   /**
-   * @param {number|null|undefined} [x]
-   * @param {number|null|undefined} [y]
-   * @returns {this}
+   * @this {unknown}
+   * @param {Array.<unknown>} parameters
+   * @returns {boolean}
    */
-  prefillTypeIndex(x, y) {
-    var [start, end] = this.defaults(x, y)
+  function assertion(...parameters) {
+    return Boolean(check.call(this, ...parameters))
+  }
+}
 
-    if (this.typeIndex) {
-      while (start < end) {
-        this.typeIndex.index(this.parent.children[start])
-        start++
-      }
-    }
+// Utility to return true.
+function ok() {
+  return true
+}
 
-    return this
-  }
+;// 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
+ */
 
-  /**
-   * @param {number|null|undefined} [x]
-   * @param {number|null|undefined} [y]
-   * @returns {this}
-   */
-  each(x, y) {
-    var [start, end] = this.defaults(x, y)
-    var child = this.parent.children[start]
-    /** @type {number} */
-    var index
-    /** @type {number} */
-    var nodeIndex
 
-    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)
+var pseudo_is = convert()
 
-    /**
-     * @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)
-    }
+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
   }
+})
 
-  /**
-   * Done!
-   * @returns {this}
-   */
-  done() {
-    var index = -1
+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'
+]
 
-    while (++index < this.delayed.length) {
-      this.delayed[index].call(this)
-      if (this.state.one && this.state.found) break
-    }
+/**
+ * @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
 
-    return this
+  while (++offset < pseudos.length) {
+    if (!pseudo_handle(pseudos[offset], node, index, parent, state)) return false
   }
 
-  /**
-   * @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]
-  }
+  return true
 }
 
-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
+/**
+ * @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
 
-    this.nodes++
+  state.one = true
+  state.shallow = true
 
-    if (!nest_own.call(this.counts, type)) this.counts[type] = 0
+  result = state.any(query.value, node, state)[0] === node
 
-    // Note: `++` is intended to be postfixed!
-    return this.counts[type]++
-  }
+  state.shallow = shallow
+  state.one = one
 
-  /**
-   * @param {Node} node
-   * @returns {number|undefined}
-   */
-  count(node) {
-    return this.counts[node.type]
-  }
+  return result
 }
 
-;// 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} index
+ * @param {Parent|null} parent
+ * @param {SelectState} state
+ * @returns {boolean}
  */
+function not(query, node, index, parent, state) {
+  return !matches(query, node, index, parent, state)
+}
 
 /**
- * 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} parent
+ * @returns {boolean}
  */
+function pseudo_root(_1, node, _2, parent) {
+  return pseudo_is(node) && !parent
+}
 
 /**
- * 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}
+ * @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)
+}
 
 /**
- * @callback AssertAnything
- * @param {unknown} [node]
- * @param {number} [index]
- * @param {Parent} [parent]
+ * @param {RulePseudo} _1
+ * @param {Node} node
  * @returns {boolean}
  */
+function empty(_1, node) {
+  return util_parent(node) ? node.children.length === 0 : !('value' in node)
+}
 
 /**
- * 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 firstChild(query, _1, _2, _3, state) {
+  assertDeep(state, query)
+  return state.nodeIndex === 0 // Specifically `0`, not falsey.
+}
 
-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)
-      }
-
-      throw new Error('Expected function, string, or object as test')
-    }
-  )
 /**
- * @param {Array.<Type|Props|TestFunctionAnything>} tests
- * @returns {AssertAnything}
+ * @param {RulePseudo} query
+ * @param {Node} _1
+ * @param {number|null} _2
+ * @param {Parent|null} _3
+ * @param {SelectState} state
+ * @returns {boolean}
  */
-function anyFactory(tests) {
-  /** @type {Array.<AssertAnything>} */
-  var checks = []
-  var index = -1
+function lastChild(query, _1, _2, _3, state) {
+  assertDeep(state, query)
+  return state.nodeIndex === state.nodeCount - 1
+}
 
-  while (++index < tests.length) {
-    checks[index] = convert(tests[index])
-  }
+/**
+ * @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
+}
 
-  return castFactory(any)
+/**
+ * @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)
+}
 
-  /**
-   * @this {unknown}
-   * @param {unknown[]} parameters
-   * @returns {boolean}
-   */
-  function any(...parameters) {
-    var index = -1
+/**
+ * @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)
+}
 
-    while (++index < checks.length) {
-      if (checks[index].call(this, ...parameters)) return true
-    }
-  }
+/**
+ * @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)
 }
 
 /**
- * Utility to assert each property in `test` is represented in `node`, and each
- * values are strictly equal.
- *
- * @param {Props} check
- * @returns {AssertAnything}
+ * @param {RulePseudoNth} query
+ * @param {Node} _1
+ * @param {number|null} _2
+ * @param {Parent|null} _3
+ * @param {SelectState} state
+ * @returns {boolean}
  */
-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 nthLastOfType(query, _1, _2, _3, state) {
+  assertDeep(state, query)
+  return query.value(state.typeCount - 1 - state.typeIndex)
 }
 
 /**
- * Utility to convert a string into a function which checks a given node’s type
- * for said string.
- *
- * @param {Type} check
- * @returns {AssertAnything}
+ * @param {RulePseudo} query
+ * @param {Node} _1
+ * @param {number|null} _2
+ * @param {Parent|null} _3
+ * @param {SelectState} state
+ * @returns {boolean}
  */
-function typeFactory(check) {
-  return castFactory(type)
-
-  /**
-   * @param {Node} node
-   */
-  function type(node) {
-    return node && node.type === check
-  }
+function firstOfType(query, _1, _2, _3, state) {
+  assertDeep(state, query)
+  return state.typeIndex === 0
 }
 
 /**
- * Utility to convert a string into a function which checks a given node’s type
- * for said string.
- * @param {TestFunctionAnything} check
- * @returns {AssertAnything}
+ * @param {RulePseudo} query
+ * @param {Node} _1
+ * @param {number|null} _2
+ * @param {Parent|null} _3
+ * @param {SelectState} state
+ * @returns {boolean}
  */
-function castFactory(check) {
-  return assertion
+function lastOfType(query, _1, _2, _3, state) {
+  assertDeep(state, query)
+  return state.typeIndex === state.typeCount - 1
+}
 
-  /**
-   * @this {unknown}
-   * @param {Array.<unknown>} parameters
-   * @returns {boolean}
-   */
-  function assertion(...parameters) {
-    return Boolean(check.call(this, ...parameters))
-  }
+/**
+ * @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
 }
 
-// Utility to return true.
-function ok() {
-  return true
+// Shouldn’t be invoked, parser gives correct data.
+/* c8 ignore next 3 */
+function invalidPseudo() {
+  throw new Error('Invalid pseudo-selector')
 }
 
-;// 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
+ * @param {RulePseudo} query
+ * @returns {boolean}
  */
-
-
-
-
-
-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
+function unknownPseudo(query) {
+  if (query.name) {
+    throw new Error('Unknown pseudo-selector `' + query.name + '`')
   }
-})
 
-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'
-]
+  throw new Error('Unexpected pseudo-element or empty pseudo-class')
+}
 
 /**
- * @param {Rule} query
- * @param {Node} node
- * @param {number|null} index
- * @param {Parent|null} parent
  * @param {SelectState} state
- * @returns {boolean}
+ * @param {RulePseudo|RulePseudoNth} query
  */
-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
+function assertDeep(state, query) {
+  if (state.shallow) {
+    throw new Error('Cannot use `:' + query.name + '` without parent')
   }
-
-  return true
 }
 
 /**
@@ -33406,780 +33171,1062 @@ function pseudo(query, node, index, parent, state) {
  * @param {SelectState} state
  * @returns {boolean}
  */
-function matches(query, node, _1, _2, state) {
+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
 
+  state.shallow = false
   state.one = true
-  state.shallow = true
+  state.scopeNodes = [node]
+
+  result = Boolean(anything(value, node, state)[0])
+
+  state.shallow = shallow
+  state.one = one
+  state.scopeNodes = scopeNodes
+
+  return 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
+
+  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'}]
+        }
+      }
+    }
+  }
+
+  return selector
+}
+
+;// CONCATENATED MODULE: ./node_modules/unist-util-select/lib/attribute.js
+/**
+ * @typedef {import('./types.js').Rule} Rule
+ * @typedef {import('./types.js').RuleAttr} RuleAttr
+ * @typedef {import('./types.js').Node} Node
+ */
+
+
+
+var attribute_handle = zwitch('operator', {
+  unknown: unknownOperator,
+  invalid: exists,
+  handlers: {
+    '=': exact,
+    '^=': begins,
+    '$=': ends,
+    '*=': containsString,
+    '~=': containsArray
+  }
+})
 
-  result = state.any(query.value, node, state)[0] === node
+/**
+ * @param {Rule} query
+ * @param {Node} node
+ */
+function attribute(query, node) {
+  var index = -1
 
-  state.shallow = shallow
-  state.one = one
+  while (++index < query.attrs.length) {
+    if (!attribute_handle(query.attrs[index], node)) return false
+  }
 
-  return result
+  return true
 }
 
 /**
- * @param {RulePseudoSelector} query
+ * `[attr]`
+ *
+ * @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 exists(query, node) {
+  return node[query.name] !== null && node[query.name] !== undefined
 }
 
 /**
- * @param {RulePseudo} _1
+ * `[attr=value]`
+ *
+ * @param {RuleAttr} query
  * @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
+function exact(query, node) {
+  return exists(query, node) && String(node[query.name]) === 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 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
+  }
+
+  // For all other values, return whether this is an exact match.
+  return String(value) === 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 begins(query, node) {
+  var value = node[query.name]
 
-/**
- * @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.
+  return (
+    typeof value === 'string' &&
+    value.slice(0, query.value.length) === query.value
+  )
 }
 
 /**
- * @param {RulePseudo} query
- * @param {Node} _1
- * @param {number|null} _2
- * @param {Parent|null} _3
- * @param {SelectState} state
- * @returns {boolean}
+ * `[attr$=value]`
+ *
+ * @param {RuleAttr} query
+ * @param {Node} node
  */
-function lastChild(query, _1, _2, _3, state) {
-  assertDeep(state, query)
-  return state.nodeIndex === state.nodeCount - 1
-}
+function ends(query, node) {
+  var value = node[query.name]
 
-/**
- * @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
+  return (
+    typeof value === 'string' &&
+    value.slice(-query.value.length) === query.value
+  )
 }
 
 /**
- * @param {RulePseudoNth} query
- * @param {Node} _1
- * @param {number|null} _2
- * @param {Parent|null} _3
- * @param {SelectState} state
- * @returns {boolean}
+ * `[attr*=value]`
+ *
+ * @param {RuleAttr} query
+ * @param {Node} node
  */
-function nthChild(query, _1, _2, _3, state) {
-  assertDeep(state, query)
-  return query.value(state.nodeIndex)
+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 {RulePseudoNth} 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 nthLastChild(query, _1, _2, _3, state) {
-  assertDeep(state, query)
-  return query.value(state.nodeCount - state.nodeIndex - 1)
+function unknownOperator(query) {
+  throw new Error('Unknown operator `' + query.operator + '`')
 }
 
+;// CONCATENATED MODULE: ./node_modules/unist-util-select/lib/name.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
  */
-function nthOfType(query, _1, _2, _3, state) {
-  assertDeep(state, query)
-  return query.value(state.typeIndex)
-}
 
 /**
- * @param {RulePseudoNth} query
- * @param {Node} _1
- * @param {number|null} _2
- * @param {Parent|null} _3
- * @param {SelectState} state
- * @returns {boolean}
+ * @param {Rule} query
+ * @param {Node} node
  */
-function nthLastOfType(query, _1, _2, _3, state) {
-  assertDeep(state, query)
-  return query.value(state.typeCount - 1 - state.typeIndex)
+function name_name(query, node) {
+  return query.tagName === '*' || query.tagName === node.type
 }
 
+;// CONCATENATED MODULE: ./node_modules/unist-util-select/lib/test.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
+ * @typedef {import('./types.js').Parent} Parent
+ * @typedef {import('./types.js').SelectState} SelectState
  */
-function firstOfType(query, _1, _2, _3, state) {
-  assertDeep(state, query)
-  return state.typeIndex === 0
-}
+
+
+
+
 
 /**
- * @param {RulePseudo} 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 lastOfType(query, _1, _2, _3, state) {
-  assertDeep(state, query)
-  return state.typeIndex === state.typeCount - 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 {RulePseudo} 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 onlyOfType(query, _1, _2, _3, state) {
-  assertDeep(state, query)
-  return state.typeCount === 1
-}
 
-// Shouldn’t be invoked, parser gives correct data.
-/* c8 ignore next 3 */
-function invalidPseudo() {
-  throw new Error('Invalid pseudo-selector')
+
+
+
+
+
+
+var type = zwitch('type', {
+  unknown: unknownType,
+  invalid: invalidType,
+  handlers: {selectors, ruleSet, rule}
+})
+
+/**
+ * @param {Selectors|RuleSet|Rule} query
+ * @param {Node} node
+ * @param {SelectState} state
+ */
+function any(query, node, state) {
+  // @ts-ignore zwitch types are off.
+  return query && node ? type(query, node, state) : []
 }
 
 /**
- * @param {RulePseudo} query
- * @returns {boolean}
+ * @param {Selectors} query
+ * @param {Node} node
+ * @param {SelectState} state
  */
-function unknownPseudo(query) {
-  if (query.name) {
-    throw new Error('Unknown pseudo-selector `' + query.name + '`')
+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))
   }
 
-  throw new Error('Unexpected pseudo-element or empty pseudo-class')
+  return collect.result
 }
 
 /**
+ * @param {RuleSet} query
+ * @param {Node} node
  * @param {SelectState} state
- * @param {RulePseudo|RulePseudoNth} query
  */
-function assertDeep(state, query) {
-  if (state.shallow) {
-    throw new Error('Cannot use `:' + query.name + '` without parent')
-  }
+function ruleSet(query, node, state) {
+  return rule(query.rule, node, state)
 }
 
 /**
- * @param {RulePseudoSelector} query
- * @param {Node} node
- * @param {number|null} _1
- * @param {Parent|null} _2
+ * @param {Rule} query
+ * @param {Node} tree
  * @param {SelectState} state
- * @returns {boolean}
  */
-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
+function rule(query, tree, state) {
+  var collect = collector(state.one)
 
-  state.shallow = false
-  state.one = true
-  state.scopeNodes = [node]
+  if (state.shallow && query.rule) {
+    throw new Error('Expected selector without nesting')
+  }
 
-  result = Boolean(anything(value, node, state)[0])
+  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
+    })
+  )
 
-  state.shallow = shallow
-  state.one = one
-  state.scopeNodes = scopeNodes
+  return collect.result
 
-  return 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 {Selector} value
+ * @template {SelectState} S
+ * @param {Rule} query
+ * @param {S} state
+ * @returns {S}
  */
-function appendScope(value) {
-  /** @type {Selectors} */
-  var selector =
-    value.type === 'ruleSet' ? {type: 'selectors', selectors: [value]} : value
+function configure(query, state) {
+  var pseudos = query.pseudos || []
   var index = -1
-  /** @type {Rule} */
-  var rule
-
-  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'}]
-        }
-      }
+  while (++index < pseudos.length) {
+    if (pseudo.needsIndex.includes(pseudos[index].name)) {
+      state.index = true
+      break
     }
   }
 
-  return selector
+  return state
 }
 
-;// CONCATENATED MODULE: ./node_modules/unist-util-select/lib/attribute.js
+// Shouldn’t be invoked, all data is handled.
+/* c8 ignore next 6 */
 /**
- * @typedef {import('./types.js').Rule} Rule
- * @typedef {import('./types.js').RuleAttr} RuleAttr
- * @typedef {import('./types.js').Node} Node
+ * @param {{[x: string]: unknown, type: string}} query
  */
+function unknownType(query) {
+  throw new Error('Unknown type `' + query.type + '`')
+}
 
-
-
-var attribute_handle = zwitch('operator', {
-  unknown: unknownOperator,
-  invalid: exists,
-  handlers: {
-    '=': exact,
-    '^=': begins,
-    '$=': ends,
-    '*=': containsString,
-    '~=': containsArray
-  }
-})
+// Shouldn’t be invoked, parser gives correct data.
+/* c8 ignore next 3 */
+function invalidType() {
+  throw new Error('Invalid type')
+}
 
 /**
- * @param {Rule} query
- * @param {Node} node
+ * @param {boolean} one
  */
-function attribute(query, node) {
-  var index = -1
+function collector(one) {
+  /** @type {Array.<Node>} */
+  var result = []
+  /** @type {boolean} */
+  var found
 
-  while (++index < query.attrs.length) {
-    if (!attribute_handle(query.attrs[index], node)) return false
+  collect.result = result
+
+  return collect
+
+  /**
+   * Append nodes to array, filtering out duplicates.
+   *
+   * @param {Node|Array.<Node>} node
+   */
+  function collect(node) {
+    var index = -1
+
+    if ('length' in node) {
+      while (++index < node.length) {
+        collectOne(node[index])
+      }
+    } else {
+      collectOne(node)
+    }
   }
 
-  return true
-}
+  /**
+   * @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')
 
-/**
- * `[attr]`
- *
- * @param {RuleAttr} query
- * @param {Node} node
- */
-function exists(query, node) {
-  return node[query.name] !== null && node[query.name] !== undefined
-}
+      found = true
+    }
 
-/**
- * `[attr=value]`
- *
- * @param {RuleAttr} query
- * @param {Node} node
- */
-function exact(query, node) {
-  return exists(query, node) && String(node[query.name]) === query.value
+    if (!result.includes(node)) result.push(node)
+  }
 }
 
+// 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
 /**
- * `[attr~=value]`
- *
- * @param {RuleAttr} query
- * @param {Node} node
+ * @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
  */
-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
-  }
 
-  // For all other values, return whether this is an exact match.
-  return String(value) === query.value
-}
+
+
+/** @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}})
 
 /**
- * `[attr^=value]`
- *
- * @param {RuleAttr} query
- * @param {Node} node
+ * @param {string} selector
+ * @returns {Selector}
  */
-function begins(query, node) {
-  var value = node[query.name]
+function parse(selector) {
+  if (typeof selector !== 'string') {
+    throw new TypeError('Expected `string` as selector, not `' + selector + '`')
+  }
 
-  return (
-    typeof value === 'string' &&
-    value.slice(0, query.value.length) === query.value
-  )
+  // @ts-ignore types are wrong.
+  return compile(parser.parse(selector))
 }
 
 /**
- * `[attr$=value]`
- *
- * @param {RuleAttr} query
- * @param {Node} node
+ * @param {Selectors} query
  */
-function ends(query, node) {
-  var value = node[query.name]
+function parse_selectors(query) {
+  var selectors = query.selectors
+  var index = -1
 
-  return (
-    typeof value === 'string' &&
-    value.slice(-query.value.length) === query.value
-  )
-}
+  while (++index < selectors.length) {
+    compile(selectors[index])
+  }
 
-/**
- * `[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)
+  return query
 }
 
-// Shouldn’t be invoked, Parser throws an error instead.
-/* c8 ignore next 6 */
 /**
- * @param {{[x: string]: unknown, type: string}} query
+ * @param {RuleSet} query
  */
-function unknownOperator(query) {
-  throw new Error('Unknown operator `' + query.operator + '`')
+function parse_ruleSet(query) {
+  return parse_rule(query.rule)
 }
 
-;// CONCATENATED MODULE: ./node_modules/unist-util-select/lib/name.js
-/**
- * @typedef {import('./types.js').Rule} Rule
- * @typedef {import('./types.js').Node} Node
- */
-
 /**
  * @param {Rule} query
- * @param {Node} node
- */
-function name_name(query, node) {
-  return query.tagName === '*' || query.tagName === node.type
-}
-
-;// 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
  */
+function parse_rule(query) {
+  var pseudos = query.pseudos || []
+  var index = -1
+  /** @type {RulePseudo|RulePseudoNth} */
+  var pseudo
 
+  while (++index < pseudos.length) {
+    pseudo = pseudos[index]
 
+    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'
+    }
+  }
 
+  compile(query.rule)
 
-
-/**
- * @param {Rule} query
- * @param {Node} node
- * @param {number|null} index
- * @param {Parent|null} parent
- * @param {SelectState} state
- * @returns {boolean}
- */
-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))
-  )
+  return query
 }
 
-;// CONCATENATED MODULE: ./node_modules/unist-util-select/lib/any.js
+;// CONCATENATED MODULE: ./node_modules/unist-util-select/index.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
+ * @typedef {import('unist').Node} Node
  */
 
 
 
 
-
-
-
-var type = zwitch('type', {
-  unknown: unknownType,
-  invalid: invalidType,
-  handlers: {selectors, ruleSet, rule}
-})
-
 /**
- * @param {Selectors|RuleSet|Rule} query
- * @param {Node} node
- * @param {SelectState} state
+ * @param {string} selector
+ * @param {Node} [node]
+ * @returns {boolean}
  */
-function any(query, node, state) {
-  // @ts-ignore zwitch types are off.
-  return query && node ? type(query, node, state) : []
+function unist_util_select_matches(selector, node) {
+  return Boolean(any(parse(selector), node, {one: true, shallow: true, any: any})[0])
 }
 
 /**
- * @param {Selectors} query
- * @param {Node} node
- * @param {SelectState} state
+ * @param {string} selector
+ * @param {Node} [node]
+ * @returns {Node|null}
  */
-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
+function unist_util_select_select(selector, node) {
+  return any(parse(selector), node, {one: true, any: any})[0] || null
 }
 
 /**
- * @param {RuleSet} query
- * @param {Node} node
- * @param {SelectState} state
+ * @param {string} selector
+ * @param {Node} [node]
+ * @returns {Array.<Node>}
  */
-function ruleSet(query, node, state) {
-  return rule(query.rule, node, state)
+function selectAll(selector, node) {
+  return any(parse(selector), node, {any: any})
 }
 
+
+/***/ }),
+
+/***/ 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__(9445);
 /**
- * @param {Rule} query
- * @param {Node} tree
- * @param {SelectState} state
+ * @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
  */
-function rule(query, tree, state) {
-  var collect = collector(state.one)
 
-  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
+/**
+ * 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
+      }
 
-  /** @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
+      (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
+        )
       }
     }
-  }
-}
+  )
 
-/**
- * @template {SelectState} S
- * @param {Rule} query
- * @param {S} state
- * @returns {S}
- */
-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
-    }
-  }
 
-  return state
-}
 
-// Shouldn’t be invoked, all data is handled.
-/* c8 ignore next 6 */
+/***/ }),
+
+/***/ 9445:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "AM": () => (/* binding */ SKIP),
+  "S4": () => (/* binding */ visitParents)
+});
+
+// UNUSED EXPORTS: CONTINUE, EXIT
+
+;// CONCATENATED MODULE: ./node_modules/unist-util-visit/node_modules/unist-util-is/index.js
 /**
- * @param {{[x: string]: unknown, type: string}} query
+ * @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 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')
-}
+/**
+ * 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}
+ */
 
 /**
- * @param {boolean} one
+ * Check if a node passes a certain node test
+ *
+ * @template {Node} X
+ * @callback TestFunctionPredicate
+ * @param {Node} node
+ * @param {number|null|undefined} [index]
+ * @param {Parent|null|undefined} [parent]
+ * @returns {node is X}
  */
-function collector(one) {
-  /** @type {Array.<Node>} */
-  var result = []
-  /** @type {boolean} */
-  var found
 
-  collect.result = result
+/**
+ * @callback AssertAnything
+ * @param {unknown} [node]
+ * @param {number|null|undefined} [index]
+ * @param {Parent|null|undefined} [parent]
+ * @returns {boolean}
+ */
 
-  return collect
+/**
+ * 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 =
   /**
-   * Append nodes to array, filtering out duplicates.
+   * Check if a node passes a test.
+   * When a `parent` node is known the `index` of node should also be given.
    *
-   * @param {Node|Array.<Node>} node
+   * @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)
+   * )}
    */
-  function collect(node) {
-    var index = -1
+  (
+    /**
+     * Check if a node passes a test.
+     * When a `parent` node is known the `index` of node should also be given.
+     *
+     * @param {unknown} [node] Node to check
+     * @param {Test} [test]
+     * When nullish, checks if `node` is a `Node`.
+     * When `string`, works like passing `function (node) {return node.type === test}`.
+     * When `function` checks if function passed the node is true.
+     * When `object`, checks that all keys in test are in node, and that they have (strictly) equal values.
+     * When `array`, checks any one of the subtests pass.
+     * @param {number|null|undefined} [index] Position of `node` in `parent`
+     * @param {Parent|null|undefined} [parent] Parent of `node`
+     * @param {unknown} [context] Context object to invoke `test` with
+     * @returns {boolean} Whether test passed and `node` is a `Node` (object with `type` set to non-empty `string`).
+     */
+    // eslint-disable-next-line max-params
+    function is(node, test, index, parent, context) {
+      const check = convert(test)
 
-    if ('length' in node) {
-      while (++index < node.length) {
-        collectOne(node[index])
+      if (
+        index !== undefined &&
+        index !== null &&
+        (typeof index !== 'number' ||
+          index < 0 ||
+          index === Number.POSITIVE_INFINITY)
+      ) {
+        throw new Error('Expected positive finite index')
       }
-    } else {
-      collectOne(node)
+
+      if (
+        parent !== undefined &&
+        parent !== null &&
+        (!is(parent) || !parent.children)
+      ) {
+        throw new Error('Expected parent node')
+      }
+
+      if (
+        (parent === undefined || parent === null) !==
+        (index === undefined || index === null)
+      ) {
+        throw new Error('Expected both parent and index')
+      }
+
+      // @ts-expect-error Looks like a node.
+      return node && node.type && typeof node.type === 'string'
+        ? Boolean(check.call(context, node, index, parent))
+        : false
     }
-  }
+  )
 
+const convert =
   /**
-   * @param {Node} node
+   * @type {(
+   *   (<T extends Node>(test: T['type']|Partial<T>|TestFunctionPredicate<T>) => AssertPredicate<T>) &
+   *   ((test?: Test) => AssertAnything)
+   * )}
    */
-  function collectOne(node) {
-    if (one) {
-      /* Shouldn’t happen, safeguards performance problems. */
-      /* c8 ignore next */
-      if (found) throw new Error('Cannot collect multiple nodes')
+  (
+    /**
+     * 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
+      }
 
-      found = true
-    }
+      if (typeof test === 'string') {
+        return typeFactory(test)
+      }
 
-    if (!result.includes(node)) result.push(node)
-  }
-}
+      if (typeof test === 'object') {
+        return Array.isArray(test) ? anyFactory(test) : propsFactory(test)
+      }
 
-// 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
+      if (typeof test === 'function') {
+        return castFactory(test)
+      }
+
+      throw new Error('Expected function, string, or object as test')
+    }
+  )
 /**
- * @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
+ * @param {Array.<Type|Props|TestFunctionAnything>} tests
+ * @returns {AssertAnything}
  */
+function anyFactory(tests) {
+  /** @type {Array.<AssertAnything>} */
+  const checks = []
+  let index = -1
 
+  while (++index < tests.length) {
+    checks[index] = convert(tests[index])
+  }
 
+  return castFactory(any)
 
+  /**
+   * @this {unknown}
+   * @param {unknown[]} parameters
+   * @returns {boolean}
+   */
+  function any(...parameters) {
+    let index = -1
 
+    while (++index < checks.length) {
+      if (checks[index].call(this, ...parameters)) return true
+    }
 
-/** @type {import('nth-check').default} */
-// @ts-ignore
-var nthCheck = nth_check_lib/* default */.ZP
+    return false
+  }
+}
 
-var nth = new Set([
-  'nth-child',
-  'nth-last-child',
-  'nth-of-type',
-  'nth-last-of-type'
-])
+/**
+ * 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)
 
-var parser = new lib/* CssSelectorParser */.N()
+  /**
+   * @param {Node} node
+   * @returns {boolean}
+   */
+  function all(node) {
+    /** @type {string} */
+    let key
 
-parser.registerAttrEqualityMods('~', '^', '$', '*')
-parser.registerSelectorPseudos('any', 'matches', 'not', 'has')
-parser.registerNestingOperators('>', '+', '~')
+    for (key in check) {
+      // @ts-expect-error: hush, it sure works as an index.
+      if (node[key] !== check[key]) return false
+    }
 
-var compile = zwitch('type', {handlers: {selectors: parse_selectors, ruleSet: parse_ruleSet, rule: parse_rule}})
+    return true
+  }
+}
 
 /**
- * @param {string} selector
- * @returns {Selector}
+ * Utility to convert a string into a function which checks a given node’s type
+ * for said string.
+ *
+ * @param {Type} check
+ * @returns {AssertAnything}
  */
-function parse(selector) {
-  if (typeof selector !== 'string') {
-    throw new TypeError('Expected `string` as selector, not `' + selector + '`')
-  }
+function typeFactory(check) {
+  return castFactory(type)
 
-  // @ts-ignore types are wrong.
-  return compile(parser.parse(selector))
+  /**
+   * @param {Node} node
+   */
+  function type(node) {
+    return node && node.type === check
+  }
 }
 
 /**
- * @param {Selectors} query
+ * 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_selectors(query) {
-  var selectors = query.selectors
-  var index = -1
+function castFactory(check) {
+  return assertion
 
-  while (++index < selectors.length) {
-    compile(selectors[index])
+  /**
+   * @this {unknown}
+   * @param {Array.<unknown>} parameters
+   * @returns {boolean}
+   */
+  function assertion(...parameters) {
+    // @ts-expect-error: spreading is fine.
+    return Boolean(check.call(this, ...parameters))
   }
+}
 
-  return query
+// Utility to return true.
+function ok() {
+  return true
 }
 
+;// CONCATENATED MODULE: ./node_modules/unist-util-visit/node_modules/unist-util-visit-parents/color.js
 /**
- * @param {RuleSet} query
+ * @param {string} d
+ * @returns {string}
  */
-function parse_ruleSet(query) {
-  return parse_rule(query.rule)
+function color(d) {
+  return '\u001B[33m' + d + '\u001B[39m'
 }
 
+;// CONCATENATED MODULE: ./node_modules/unist-util-visit/node_modules/unist-util-visit-parents/index.js
 /**
- * @param {Rule} 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_rule(query) {
-  var pseudos = query.pseudos || []
-  var index = -1
-  /** @type {RulePseudo|RulePseudoNth} */
-  var pseudo
 
-  while (++index < pseudos.length) {
-    pseudo = pseudos[index]
 
-    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'
-    }
-  }
 
-  compile(query.rule)
 
-  return query
-}
+/**
+ * Continue traversing as normal
+ */
+const CONTINUE = true
+/**
+ * Do not traverse this node’s children
+ */
+const SKIP = 'skip'
+/**
+ * Stop traversing immediately
+ */
+const EXIT = false
 
-;// CONCATENATED MODULE: ./node_modules/unist-util-select/index.js
 /**
- * @typedef {import('unist').Node} Node
+ * 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
 
-/**
- * @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])
-}
+        if (typeof value.type === 'string') {
+          name =
+            typeof value.tagName === 'string'
+              ? value.tagName
+              : typeof value.name === 'string'
+              ? value.name
+              : undefined
 
-/**
- * @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
-}
+          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 {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]
 }
 
 
@@ -34402,7 +34449,7 @@ 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,
@@ -34412,7 +34459,7 @@ var _require5 = __webpack_require__(8160),
 var toPlainText = __webpack_require__(4792);
 var sectionAnchorId = __webpack_require__(9620);
 var tableFlattening = __webpack_require__(4625);
-var _require6 = __webpack_require__(1269),
+var _require6 = __webpack_require__(2692),
   remarkTransformers = _require6.remarkTransformers,
   rehypeTransformers = _require6.rehypeTransformers;
 var createSchema = __webpack_require__(8229);