@readme/markdown 6.67.0 → 6.68.0-beta.2

package/dist/main.node.js

@@ -8875,6 +8875,7 @@ var options = {
   },
   lazyImages: true,
   normalize: true,
+  reusableContent: {},
   safeMode: false,
   settings: {
     position: false
@@ -9153,61 +9154,95 @@ module.exports = function ImageCompiler() {
 
 /***/ }),
 
-/***/ 9647:
+/***/ 8457:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
+// ESM COMPAT FLAG
 __webpack_require__.r(__webpack_exports__);
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   "breakCompiler": () => (/* reexport default from dynamic */ _break__WEBPACK_IMPORTED_MODULE_0___default.a),
-/* harmony export */   "codeTabsCompiler": () => (/* reexport default from dynamic */ _code_tabs__WEBPACK_IMPORTED_MODULE_1___default.a),
-/* harmony export */   "divCompiler": () => (/* reexport default from dynamic */ _div__WEBPACK_IMPORTED_MODULE_2___default.a),
-/* harmony export */   "escapeCompiler": () => (/* reexport default from dynamic */ _escape__WEBPACK_IMPORTED_MODULE_3___default.a),
-/* harmony export */   "figureCompiler": () => (/* reexport default from dynamic */ _figure__WEBPACK_IMPORTED_MODULE_4___default.a),
-/* harmony export */   "htmlBlockCompiler": () => (/* reexport default from dynamic */ _html_block__WEBPACK_IMPORTED_MODULE_5___default.a),
-/* harmony export */   "iconCompiler": () => (/* reexport default from dynamic */ _i__WEBPACK_IMPORTED_MODULE_6___default.a),
-/* harmony export */   "imageCompiler": () => (/* reexport default from dynamic */ _image__WEBPACK_IMPORTED_MODULE_7___default.a),
-/* harmony export */   "rdmeCalloutCompiler": () => (/* reexport default from dynamic */ _callout__WEBPACK_IMPORTED_MODULE_8___default.a),
-/* harmony export */   "rdmeEmbedCompiler": () => (/* reexport default from dynamic */ _embed__WEBPACK_IMPORTED_MODULE_9___default.a),
-/* harmony export */   "rdmeGlossaryCompiler": () => (/* reexport default from dynamic */ _glossary__WEBPACK_IMPORTED_MODULE_10___default.a),
-/* harmony export */   "rdmePinCompiler": () => (/* reexport default from dynamic */ _pin__WEBPACK_IMPORTED_MODULE_11___default.a),
-/* harmony export */   "rdmeVarCompiler": () => (/* reexport default from dynamic */ _var__WEBPACK_IMPORTED_MODULE_12___default.a),
-/* harmony export */   "tableCompiler": () => (/* reexport default from dynamic */ _table__WEBPACK_IMPORTED_MODULE_13___default.a),
-/* harmony export */   "tableHeadCompiler": () => (/* reexport default from dynamic */ _table_head__WEBPACK_IMPORTED_MODULE_14___default.a),
-/* harmony export */   "yamlCompiler": () => (/* reexport default from dynamic */ _yaml__WEBPACK_IMPORTED_MODULE_15___default.a)
-/* harmony export */ });
-/* harmony import */ var _break__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3688);
-/* harmony import */ var _break__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_break__WEBPACK_IMPORTED_MODULE_0__);
-/* harmony import */ var _code_tabs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(4079);
-/* harmony import */ var _code_tabs__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_code_tabs__WEBPACK_IMPORTED_MODULE_1__);
-/* harmony import */ var _div__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(58);
-/* harmony import */ var _div__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_div__WEBPACK_IMPORTED_MODULE_2__);
-/* harmony import */ var _escape__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(8418);
-/* harmony import */ var _escape__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_escape__WEBPACK_IMPORTED_MODULE_3__);
-/* harmony import */ var _figure__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(8705);
-/* harmony import */ var _figure__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_figure__WEBPACK_IMPORTED_MODULE_4__);
-/* harmony import */ var _html_block__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(3551);
-/* harmony import */ var _html_block__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(_html_block__WEBPACK_IMPORTED_MODULE_5__);
-/* harmony import */ var _i__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(4258);
-/* harmony import */ var _i__WEBPACK_IMPORTED_MODULE_6___default = /*#__PURE__*/__webpack_require__.n(_i__WEBPACK_IMPORTED_MODULE_6__);
-/* harmony import */ var _image__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(3356);
-/* harmony import */ var _image__WEBPACK_IMPORTED_MODULE_7___default = /*#__PURE__*/__webpack_require__.n(_image__WEBPACK_IMPORTED_MODULE_7__);
-/* harmony import */ var _callout__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(5733);
-/* harmony import */ var _callout__WEBPACK_IMPORTED_MODULE_8___default = /*#__PURE__*/__webpack_require__.n(_callout__WEBPACK_IMPORTED_MODULE_8__);
-/* harmony import */ var _embed__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(4338);
-/* harmony import */ var _embed__WEBPACK_IMPORTED_MODULE_9___default = /*#__PURE__*/__webpack_require__.n(_embed__WEBPACK_IMPORTED_MODULE_9__);
-/* harmony import */ var _glossary__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(2459);
-/* harmony import */ var _glossary__WEBPACK_IMPORTED_MODULE_10___default = /*#__PURE__*/__webpack_require__.n(_glossary__WEBPACK_IMPORTED_MODULE_10__);
-/* harmony import */ var _pin__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(2151);
-/* harmony import */ var _pin__WEBPACK_IMPORTED_MODULE_11___default = /*#__PURE__*/__webpack_require__.n(_pin__WEBPACK_IMPORTED_MODULE_11__);
-/* harmony import */ var _var__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(1067);
-/* harmony import */ var _var__WEBPACK_IMPORTED_MODULE_12___default = /*#__PURE__*/__webpack_require__.n(_var__WEBPACK_IMPORTED_MODULE_12__);
-/* harmony import */ var _table__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(4669);
-/* harmony import */ var _table__WEBPACK_IMPORTED_MODULE_13___default = /*#__PURE__*/__webpack_require__.n(_table__WEBPACK_IMPORTED_MODULE_13__);
-/* harmony import */ var _table_head__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(186);
-/* harmony import */ var _table_head__WEBPACK_IMPORTED_MODULE_14___default = /*#__PURE__*/__webpack_require__.n(_table_head__WEBPACK_IMPORTED_MODULE_14__);
-/* harmony import */ var _yaml__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(1773);
-/* harmony import */ var _yaml__WEBPACK_IMPORTED_MODULE_15___default = /*#__PURE__*/__webpack_require__.n(_yaml__WEBPACK_IMPORTED_MODULE_15__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "breakCompiler": () => (/* reexport */ (break_default())),
+  "codeTabsCompiler": () => (/* reexport */ (code_tabs_default())),
+  "divCompiler": () => (/* reexport */ (div_default())),
+  "escapeCompiler": () => (/* reexport */ (escape_default())),
+  "figureCompiler": () => (/* reexport */ (figure_default())),
+  "htmlBlockCompiler": () => (/* reexport */ (html_block_default())),
+  "iconCompiler": () => (/* reexport */ (i_default())),
+  "imageCompiler": () => (/* reexport */ (image_default())),
+  "rdmeCalloutCompiler": () => (/* reexport */ (callout_default())),
+  "rdmeEmbedCompiler": () => (/* reexport */ (embed_default())),
+  "rdmeGlossaryCompiler": () => (/* reexport */ (glossary_default())),
+  "rdmePinCompiler": () => (/* reexport */ (pin_default())),
+  "rdmeVarCompiler": () => (/* reexport */ (var_default())),
+  "reusableContentCompiler": () => (/* reexport */ ReusableContentCompiler),
+  "tableCompiler": () => (/* reexport */ (table_default())),
+  "tableHeadCompiler": () => (/* reexport */ (table_head_default())),
+  "yamlCompiler": () => (/* reexport */ (yaml_default()))
+});
+
+// EXTERNAL MODULE: ./processor/compile/break.js
+var compile_break = __webpack_require__(3688);
+var break_default = /*#__PURE__*/__webpack_require__.n(compile_break);
+// EXTERNAL MODULE: ./processor/compile/code-tabs.js
+var code_tabs = __webpack_require__(4079);
+var code_tabs_default = /*#__PURE__*/__webpack_require__.n(code_tabs);
+// EXTERNAL MODULE: ./processor/compile/div.js
+var div = __webpack_require__(58);
+var div_default = /*#__PURE__*/__webpack_require__.n(div);
+// EXTERNAL MODULE: ./processor/compile/escape.js
+var compile_escape = __webpack_require__(8418);
+var escape_default = /*#__PURE__*/__webpack_require__.n(compile_escape);
+// EXTERNAL MODULE: ./processor/compile/figure.js
+var figure = __webpack_require__(8705);
+var figure_default = /*#__PURE__*/__webpack_require__.n(figure);
+// EXTERNAL MODULE: ./processor/compile/html-block.js
+var html_block = __webpack_require__(3551);
+var html_block_default = /*#__PURE__*/__webpack_require__.n(html_block);
+// EXTERNAL MODULE: ./processor/compile/i.js
+var i = __webpack_require__(4258);
+var i_default = /*#__PURE__*/__webpack_require__.n(i);
+// EXTERNAL MODULE: ./processor/compile/image.js
+var compile_image = __webpack_require__(3356);
+var image_default = /*#__PURE__*/__webpack_require__.n(compile_image);
+// EXTERNAL MODULE: ./processor/compile/callout.js
+var callout = __webpack_require__(5733);
+var callout_default = /*#__PURE__*/__webpack_require__.n(callout);
+// EXTERNAL MODULE: ./processor/compile/embed.js
+var compile_embed = __webpack_require__(4338);
+var embed_default = /*#__PURE__*/__webpack_require__.n(compile_embed);
+// EXTERNAL MODULE: ./processor/compile/glossary.js
+var glossary = __webpack_require__(2459);
+var glossary_default = /*#__PURE__*/__webpack_require__.n(glossary);
+// EXTERNAL MODULE: ./processor/compile/pin.js
+var pin = __webpack_require__(2151);
+var pin_default = /*#__PURE__*/__webpack_require__.n(pin);
+// EXTERNAL MODULE: ./processor/compile/var.js
+var compile_var = __webpack_require__(1067);
+var var_default = /*#__PURE__*/__webpack_require__.n(compile_var);
+// EXTERNAL MODULE: ./processor/transform/reusable-content.js
+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
+
 
 
 
@@ -10479,7 +10514,7 @@ module.exports.tableFlattening = transformer;
 
 /***/ }),
 
-/***/ 2442:
+/***/ 2692:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -10492,570 +10527,141 @@ __webpack_require__.d(__webpack_exports__, {
   "remarkTransformers": () => (/* binding */ remarkTransformers)
 });
 
-;// CONCATENATED MODULE: ./node_modules/unist-util-visit/node_modules/unist-util-is/index.js
-/**
- * @typedef {import('unist').Node} Node
- * @typedef {import('unist').Parent} Parent
- *
- * @typedef {string} Type
- * @typedef {Object<string, unknown>} Props
- *
- * @typedef {null|undefined|Type|Props|TestFunctionAnything|Array.<Type|Props|TestFunctionAnything>} Test
- */
-
-/**
- * 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 _babel_runtime_helpers_typeof__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(8698);
+/* harmony import */ var _babel_runtime_helpers_typeof__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_typeof__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(1655);
+/* harmony import */ var _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _babel_runtime_helpers_setPrototypeOf__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(6015);
+/* harmony import */ var _babel_runtime_helpers_setPrototypeOf__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_setPrototypeOf__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var unist_util_visit__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(6393);
 
-      if (typeof test === 'function') {
-        return castFactory(test)
-      }
 
-      throw new Error('Expected function, string, or object as test')
-    }
-  )
-/**
- * @param {Array.<Type|Props|TestFunctionAnything>} tests
- * @returns {AssertAnything}
- */
-function anyFactory(tests) {
-  /** @type {Array.<AssertAnything>} */
-  const checks = []
-  let index = -1
 
-  while (++index < tests.length) {
-    checks[index] = convert(tests[index])
-  }
+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)), _babel_runtime_helpers_setPrototypeOf__WEBPACK_IMPORTED_MODULE_2___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 _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_1___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" != _babel_runtime_helpers_typeof__WEBPACK_IMPORTED_MODULE_0___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); }
 
-  return castFactory(any)
+var type = 'reusable-content';
+var tag = 'RMReusableContent';
+var regexp = /*#__PURE__*/_wrapRegExp(/^\s*<RMReusableContent name="(.*)" \/>\s*$/, {
+  name: 1
+});
+var reusableContentTransformer = function reusableContentTransformer() {
+  var reusableContent = this.data('reusableContent');
+  return function (tree) {
+    (0,unist_util_visit__WEBPACK_IMPORTED_MODULE_3__/* .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);
 
-  /**
-   * @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
-    }
+/***/ 8229:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-    return false
-  }
-}
-
-/**
- * Utility to assert each property in `test` is represented in `node`, and each
- * values are strictly equal.
- *
- * @param {Props} check
- * @returns {AssertAnything}
- */
-function propsFactory(check) {
-  return castFactory(all)
-
-  /**
-   * @param {Node} node
-   * @returns {boolean}
-   */
-  function all(node) {
-    /** @type {string} */
-    let key
-
-    for (key in check) {
-      // @ts-expect-error: hush, it sure works as an index.
-      if (node[key] !== check[key]) return false
-    }
-
-    return true
-  }
-}
-
-/**
- * Utility to convert a string into a function which checks a given node’s type
- * for said string.
- *
- * @param {Type} check
- * @returns {AssertAnything}
- */
-function typeFactory(check) {
-  return castFactory(type)
-
-  /**
-   * @param {Node} node
-   */
-  function type(node) {
-    return node && node.type === check
-  }
-}
-
-/**
- * Utility to convert a string into a function which checks a given node’s type
- * for said string.
- * @param {TestFunctionAnything} check
- * @returns {AssertAnything}
- */
-function castFactory(check) {
-  return assertion
-
-  /**
-   * @this {unknown}
-   * @param {Array.<unknown>} parameters
-   * @returns {boolean}
-   */
-  function assertion(...parameters) {
-    // @ts-expect-error: spreading is fine.
-    return Boolean(check.call(this, ...parameters))
-  }
-}
-
-// Utility to return true.
-function ok() {
-  return true
-}
-
-;// CONCATENATED MODULE: ./node_modules/unist-util-visit/node_modules/unist-util-visit-parents/color.js
-/**
- * @param {string} d
- * @returns {string}
- */
-function color(d) {
-  return '\u001B[33m' + d + '\u001B[39m'
-}
-
-;// CONCATENATED MODULE: ./node_modules/unist-util-visit/node_modules/unist-util-visit-parents/index.js
-/**
- * @typedef {import('unist').Node} Node
- * @typedef {import('unist').Parent} Parent
- * @typedef {import('unist-util-is').Test} Test
- * @typedef {import('./complex-types.js').Action} Action
- * @typedef {import('./complex-types.js').Index} Index
- * @typedef {import('./complex-types.js').ActionTuple} ActionTuple
- * @typedef {import('./complex-types.js').VisitorResult} VisitorResult
- * @typedef {import('./complex-types.js').Visitor} Visitor
- */
-
-
-
-
-/**
- * Continue traversing as normal
- */
-const CONTINUE = true
-/**
- * Do not traverse this node’s children
- */
-const SKIP = 'skip'
-/**
- * Stop traversing immediately
- */
-const EXIT = false
-
-/**
- * Visit children of tree which pass test.
- *
- * @param tree
- *   Tree to walk
- * @param [test]
- *   `unist-util-is`-compatible test
- * @param visitor
- *   Function called for nodes that pass `test`.
- * @param [reverse=false]
- *   Traverse in reverse preorder (NRL) instead of preorder (NLR) (default).
- */
-const visitParents =
-  /**
-   * @type {(
-   *   (<Tree extends Node, Check extends Test>(tree: Tree, test: Check, visitor: import('./complex-types.js').BuildVisitor<Tree, Check>, reverse?: boolean) => void) &
-   *   (<Tree extends Node>(tree: Tree, visitor: import('./complex-types.js').BuildVisitor<Tree>, reverse?: boolean) => void)
-   * )}
-   */
-  (
-    /**
-     * @param {Node} tree
-     * @param {Test} test
-     * @param {import('./complex-types.js').Visitor<Node>} visitor
-     * @param {boolean} [reverse=false]
-     */
-    function (tree, test, visitor, reverse) {
-      if (typeof test === 'function' && typeof visitor !== 'function') {
-        reverse = visitor
-        // @ts-expect-error no visitor given, so `visitor` is test.
-        visitor = test
-        test = null
-      }
-
-      const is = convert(test)
-      const step = reverse ? -1 : 1
-
-      factory(tree, null, [])()
-
-      /**
-       * @param {Node} node
-       * @param {number?} index
-       * @param {Array<Parent>} parents
-       */
-      function factory(node, index, parents) {
-        /** @type {Record<string, unknown>} */
-        // @ts-expect-error: hush
-        const value = typeof node === 'object' && node !== null ? node : {}
-        /** @type {string|undefined} */
-        let name
-
-        if (typeof value.type === 'string') {
-          name =
-            typeof value.tagName === 'string'
-              ? value.tagName
-              : typeof value.name === 'string'
-              ? value.name
-              : undefined
-
-          Object.defineProperty(visit, 'name', {
-            value:
-              'node (' +
-              color(value.type + (name ? '<' + name + '>' : '')) +
-              ')'
-          })
-        }
-
-        return visit
-
-        function visit() {
-          /** @type {ActionTuple} */
-          let result = []
-          /** @type {ActionTuple} */
-          let subresult
-          /** @type {number} */
-          let offset
-          /** @type {Array<Parent>} */
-          let grandparents
-
-          if (!test || is(node, index, parents[parents.length - 1] || null)) {
-            result = toResult(visitor(node, parents))
-
-            if (result[0] === EXIT) {
-              return result
-            }
-          }
-
-          // @ts-expect-error looks like a parent.
-          if (node.children && result[0] !== SKIP) {
-            // @ts-expect-error looks like a parent.
-            offset = (reverse ? node.children.length : -1) + step
-            // @ts-expect-error looks like a parent.
-            grandparents = parents.concat(node)
-
-            // @ts-expect-error looks like a parent.
-            while (offset > -1 && offset < node.children.length) {
-              // @ts-expect-error looks like a parent.
-              subresult = factory(node.children[offset], offset, grandparents)()
-
-              if (subresult[0] === EXIT) {
-                return subresult
-              }
-
-              offset =
-                typeof subresult[1] === 'number' ? subresult[1] : offset + step
-            }
-          }
-
-          return result
-        }
-      }
-    }
-  )
-
-/**
- * @param {VisitorResult} value
- * @returns {ActionTuple}
- */
-function toResult(value) {
-  if (Array.isArray(value)) {
-    return value
-  }
-
-  if (typeof value === 'number') {
-    return [CONTINUE, value]
-  }
-
-  return [value]
-}
-
-;// CONCATENATED MODULE: ./node_modules/unist-util-visit/index.js
-/**
- * @typedef {import('unist').Node} Node
- * @typedef {import('unist').Parent} Parent
- * @typedef {import('unist-util-is').Test} Test
- * @typedef {import('unist-util-visit-parents').VisitorResult} VisitorResult
- * @typedef {import('./complex-types.js').Visitor} Visitor
- */
-
-
-
-/**
- * Visit children of tree which pass test.
- *
- * @param tree
- *   Tree to walk
- * @param [test]
- *   `unist-util-is`-compatible test
- * @param visitor
- *   Function called for nodes that pass `test`.
- * @param reverse
- *   Traverse in reverse preorder (NRL) instead of preorder (NLR) (default).
- */
-const visit =
-  /**
-   * @type {(
-   *   (<Tree extends Node, Check extends Test>(tree: Tree, test: Check, visitor: import('./complex-types.js').BuildVisitor<Tree, Check>, reverse?: boolean) => void) &
-   *   (<Tree extends Node>(tree: Tree, visitor: import('./complex-types.js').BuildVisitor<Tree>, reverse?: boolean) => void)
-   * )}
-   */
-  (
-    /**
-     * @param {Node} tree
-     * @param {Test} test
-     * @param {import('./complex-types.js').Visitor} visitor
-     * @param {boolean} [reverse]
-     */
-    function (tree, test, visitor, reverse) {
-      if (typeof test === 'function' && typeof visitor !== 'function') {
-        reverse = visitor
-        visitor = test
-        test = null
-      }
-
-      visitParents(tree, test, overload, reverse)
-
-      /**
-       * @param {Node} node
-       * @param {Array<Parent>} parents
-       */
-      function overload(node, parents) {
-        const parent = parents[parents.length - 1]
-        return visitor(
-          node,
-          parent ? parent.children.indexOf(node) : null,
-          parent
-        )
-      }
-    }
-  )
-
-
-
-;// CONCATENATED MODULE: ./processor/transform/single-code-tabs.js
-
-var singleCodeTabs = function singleCodeTabs() {
-  return function (tree) {
-    visit(tree, function (node, index, parent) {
-      if (node.type === 'code' && (node.lang || node.meta) && parent.type !== 'code-tabs') {
-        Object.assign(node, {
-          className: 'tab-panel',
-          data: {
-            hName: 'code',
-            hProperties: {
-              meta: node.meta,
-              lang: node.lang
-            }
-          }
-        });
-        parent.children[index] = {
-          type: 'code-tabs',
-          className: 'tabs',
-          data: {
-            hName: 'div',
-            hProperties: {
-              className: ['code-tabs']
-            }
-          },
-          children: [node]
-        };
-      }
-    });
-    return tree;
-  };
-};
-/* harmony default export */ const single_code_tabs = (singleCodeTabs);
-;// CONCATENATED MODULE: ./processor/transform/table-cell-inline-code.js
-
-var rxEscapedPipe = /\\\|/g;
-
-/**
- * HAST Transformer that finds all inline code nodes within table cells and
- * unescapes any escaped pipe chars so that the editor outputs them without
- * escape chars.
- *
- * This appears to be a bug with remark-parse < ~8
- */
-var tableCellInlineCode = function tableCellInlineCode() {
-  return function (tree) {
-    visit(tree, [{
-      tagName: 'th'
-    }, {
-      tagName: 'td'
-    }], function (tableCellNode) {
-      visit(tableCellNode, {
-        tagName: 'code'
-      }, function (inlineCodeNode) {
-        var textNode = inlineCodeNode.children[0];
-        if (textNode && rxEscapedPipe.test(textNode.value)) {
-          textNode.value = textNode.value.replace(rxEscapedPipe, '|');
-        }
-      });
-      return SKIP;
-    });
-  };
-};
-/* harmony default export */ const table_cell_inline_code = (tableCellInlineCode);
-;// CONCATENATED MODULE: ./processor/transform/index.js
-
-
-var remarkTransformers = [single_code_tabs];
-var rehypeTransformers = [table_cell_inline_code];
-
-/***/ }),
-
-/***/ 8229:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-var _require = __webpack_require__(2781),
-  defaultSchema = _require.defaultSchema;
-var createSchema = function createSchema() {
-  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
-    safeMode = _ref.safeMode;
-  var schema = JSON.parse(JSON.stringify(defaultSchema));
+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 = '';
@@ -33791,339 +33397,848 @@ function name_name(query, node) {
 
 
 
-/**
- * @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')
+/**
+ * @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))
+  )
+}
+
+;// CONCATENATED MODULE: ./node_modules/unist-util-select/lib/any.js
+/**
+ * @typedef {import('./types.js').Selector} Selector
+ * @typedef {import('./types.js').Selectors} Selectors
+ * @typedef {import('./types.js').Rule} Rule
+ * @typedef {import('./types.js').RuleSet} RuleSet
+ * @typedef {import('./types.js').RulePseudo} RulePseudo
+ * @typedef {import('./types.js').Query} Query
+ * @typedef {import('./types.js').Node} Node
+ * @typedef {import('./types.js').Parent} Parent
+ * @typedef {import('./types.js').SelectIterator} SelectIterator
+ * @typedef {import('./types.js').SelectState} SelectState
+ */
+
+
+
+
+
+
+
+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 {Selectors} query
+ * @param {Node} node
+ * @param {SelectState} state
+ */
+function selectors(query, node, state) {
+  var collect = collector(state.one)
+  var index = -1
+
+  while (++index < query.selectors.length) {
+    collect(ruleSet(query.selectors[index], node, state))
+  }
+
+  return collect.result
+}
+
+/**
+ * @param {RuleSet} query
+ * @param {Node} node
+ * @param {SelectState} state
+ */
+function ruleSet(query, node, state) {
+  return rule(query.rule, node, state)
+}
+
+/**
+ * @param {Rule} query
+ * @param {Node} tree
+ * @param {SelectState} state
+ */
+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
+
+  /** @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
+      }
+    }
+  }
+}
+
+/**
+ * @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 */
+/**
+ * @param {{[x: string]: unknown, type: string}} query
+ */
+function unknownType(query) {
+  throw new Error('Unknown type `' + query.type + '`')
+}
+
+// Shouldn’t be invoked, parser gives correct data.
+/* c8 ignore next 3 */
+function invalidType() {
+  throw new Error('Invalid type')
+}
+
+/**
+ * @param {boolean} one
+ */
+function collector(one) {
+  /** @type {Array.<Node>} */
+  var result = []
+  /** @type {boolean} */
+  var found
+
+  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)
+    }
+  }
+
+  /**
+   * @param {Node} node
+   */
+  function collectOne(node) {
+    if (one) {
+      /* Shouldn’t happen, safeguards performance problems. */
+      /* c8 ignore next */
+      if (found) throw new Error('Cannot collect multiple nodes')
+
+      found = true
+    }
 
-  return Boolean(
-    node &&
-      (!query.tagName || name_name(query, node)) &&
-      (!query.attrs || attribute(query, node)) &&
-      (!query.pseudos || pseudo(query, node, index, parent, state))
-  )
+    if (!result.includes(node)) result.push(node)
+  }
 }
 
-;// CONCATENATED MODULE: ./node_modules/unist-util-select/lib/any.js
+// EXTERNAL MODULE: ./node_modules/css-selector-parser/lib/index.js
+var lib = __webpack_require__(8079);
+// EXTERNAL MODULE: ./node_modules/nth-check/lib/index.js
+var nth_check_lib = __webpack_require__(7540);
+;// CONCATENATED MODULE: ./node_modules/unist-util-select/lib/parse.js
 /**
  * @typedef {import('./types.js').Selector} Selector
  * @typedef {import('./types.js').Selectors} Selectors
- * @typedef {import('./types.js').Rule} Rule
  * @typedef {import('./types.js').RuleSet} RuleSet
+ * @typedef {import('./types.js').Rule} Rule
  * @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('./types.js').RulePseudoNth} RulePseudoNth
  */
 
 
 
 
 
+/** @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 type = zwitch('type', {
-  unknown: unknownType,
-  invalid: invalidType,
-  handlers: {selectors, ruleSet, rule}
-})
+var parser = new lib/* CssSelectorParser */.N()
+
+parser.registerAttrEqualityMods('~', '^', '$', '*')
+parser.registerSelectorPseudos('any', 'matches', 'not', 'has')
+parser.registerNestingOperators('>', '+', '~')
+
+var compile = zwitch('type', {handlers: {selectors: parse_selectors, ruleSet: parse_ruleSet, rule: parse_rule}})
 
 /**
- * @param {Selectors|RuleSet|Rule} query
- * @param {Node} node
- * @param {SelectState} state
+ * @param {string} selector
+ * @returns {Selector}
  */
-function any(query, node, state) {
-  // @ts-ignore zwitch types are off.
-  return query && node ? type(query, node, state) : []
+function parse(selector) {
+  if (typeof selector !== 'string') {
+    throw new TypeError('Expected `string` as selector, not `' + selector + '`')
+  }
+
+  // @ts-ignore types are wrong.
+  return compile(parser.parse(selector))
 }
 
 /**
  * @param {Selectors} query
- * @param {Node} node
- * @param {SelectState} state
  */
-function selectors(query, node, state) {
-  var collect = collector(state.one)
+function parse_selectors(query) {
+  var selectors = query.selectors
   var index = -1
 
-  while (++index < query.selectors.length) {
-    collect(ruleSet(query.selectors[index], node, state))
+  while (++index < selectors.length) {
+    compile(selectors[index])
   }
 
-  return collect.result
+  return query
 }
 
 /**
  * @param {RuleSet} query
- * @param {Node} node
- * @param {SelectState} state
  */
-function ruleSet(query, node, state) {
-  return rule(query.rule, node, state)
+function parse_ruleSet(query) {
+  return parse_rule(query.rule)
 }
 
 /**
  * @param {Rule} query
- * @param {Node} tree
- * @param {SelectState} state
  */
-function rule(query, tree, state) {
-  var collect = collector(state.one)
+function parse_rule(query) {
+  var pseudos = query.pseudos || []
+  var index = -1
+  /** @type {RulePseudo|RulePseudoNth} */
+  var pseudo
 
-  if (state.shallow && query.rule) {
-    throw new Error('Expected selector without nesting')
+  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'
+    }
   }
 
-  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
-    })
-  )
+  compile(query.rule)
 
-  return collect.result
+  return query
+}
 
-  /** @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
-      }
-    }
-  }
+;// CONCATENATED MODULE: ./node_modules/unist-util-select/index.js
+/**
+ * @typedef {import('unist').Node} Node
+ */
+
+
+
+
+/**
+ * @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])
 }
 
 /**
- * @template {SelectState} S
- * @param {Rule} query
- * @param {S} state
- * @returns {S}
+ * @param {string} selector
+ * @param {Node} [node]
+ * @returns {Node|null}
  */
-function configure(query, state) {
-  var pseudos = query.pseudos || []
-  var index = -1
+function unist_util_select_select(selector, node) {
+  return any(parse(selector), node, {one: true, any: any})[0] || null
+}
 
-  while (++index < pseudos.length) {
-    if (pseudo.needsIndex.includes(pseudos[index].name)) {
-      state.index = true
-      break
+/**
+ * @param {string} selector
+ * @param {Node} [node]
+ * @returns {Array.<Node>}
+ */
+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);
+/**
+ * @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
+      }
+
+      (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
+        )
+      }
     }
-  }
+  )
 
-  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]
 }
 
 
@@ -34307,15 +34422,16 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   "setup": () => (/* binding */ setup),
 /* harmony export */   "utils": () => (/* binding */ utils)
 /* harmony export */ });
-/* harmony import */ var _babel_runtime_helpers_toConsumableArray__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(861);
-/* harmony import */ var _babel_runtime_helpers_toConsumableArray__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_toConsumableArray__WEBPACK_IMPORTED_MODULE_0__);
-/* harmony import */ var _babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7424);
-/* harmony import */ var _babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(7424);
+/* harmony import */ var _babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _babel_runtime_helpers_objectWithoutProperties__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(215);
+/* harmony import */ var _babel_runtime_helpers_objectWithoutProperties__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_objectWithoutProperties__WEBPACK_IMPORTED_MODULE_1__);
 /* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(8416);
 /* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2__);
 
 
 
+var _excluded = ["reusableContent"];
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 /* eslint-disable no-param-reassign */
@@ -34345,7 +34461,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,
@@ -34355,7 +34471,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__(2442),
+var _require6 = __webpack_require__(2692),
   remarkTransformers = _require6.remarkTransformers,
   rehypeTransformers = _require6.rehypeTransformers;
 var createSchema = __webpack_require__(8229);
@@ -34405,34 +34521,53 @@ var utils = {
   calloutIcons: calloutIcons
 };
 
+/**
+ * Pre-parse reusable content blocks. Note that they do not pass the content
+ * blocks recursively.
+ */
+var parseReusableContent = function parseReusableContent(_ref) {
+  var reusableContent = _ref.reusableContent,
+    opts = _babel_runtime_helpers_objectWithoutProperties__WEBPACK_IMPORTED_MODULE_1___default()(_ref, _excluded);
+  var parsedReusableContent = Object.entries(reusableContent).reduce(function (memo, _ref2) {
+    var _ref3 = _babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_0___default()(_ref2, 2),
+      name = _ref3[0],
+      content = _ref3[1];
+    // eslint-disable-next-line no-use-before-define
+    memo[name] = mdast(content, opts).children;
+    return memo;
+  }, {});
+  return [parsedReusableContent, opts];
+};
+
 /**
  * Core markdown to mdast processor
  */
 function processor() {
-  var _unified$use$use$data;
-  var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var _setup = setup('', opts);
-  var _setup2 = _babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1___default()(_setup, 2);
-  opts = _setup2[1];
-  var _opts = opts,
-    sanitize = _opts.sanitize;
-  return (_unified$use$use$data = unified().use(remarkParse, opts.markdownOptions).use(remarkFrontmatter, ['yaml', 'toml']).data('settings', opts.settings).data('compatibilityMode', opts.compatibilityMode).data('alwaysThrow', opts.alwaysThrow).use(!opts.correctnewlines ? remarkBreaks : function () {}).use(CustomParsers.map(function (parser) {
+  var userOpts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var _setup = setup('', userOpts),
+    _setup2 = _babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_0___default()(_setup, 2),
+    parsedOpts = _setup2[1];
+  var sanitize = parsedOpts.sanitize;
+  var _parseReusableContent = parseReusableContent(parsedOpts),
+    _parseReusableContent2 = _babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_0___default()(_parseReusableContent, 2),
+    reusableContent = _parseReusableContent2[0],
+    opts = _parseReusableContent2[1];
+  return unified().use(remarkParse, opts.markdownOptions).use(remarkFrontmatter, ['yaml', 'toml']).data('settings', opts.settings).data('compatibilityMode', opts.compatibilityMode).data('alwaysThrow', opts.alwaysThrow).data('reusableContent', reusableContent).use(!opts.correctnewlines ? remarkBreaks : function () {}).use(CustomParsers.map(function (parser) {
     var _parser$sanitize;
     return ((_parser$sanitize = parser.sanitize) === null || _parser$sanitize === void 0 ? void 0 : _parser$sanitize.call(parser, sanitize)) || parser;
-  }))).use.apply(_unified$use$use$data, _babel_runtime_helpers_toConsumableArray__WEBPACK_IMPORTED_MODULE_0___default()(remarkTransformers)).use(remarkSlug).use(remarkDisableTokenizers, opts.disableTokenizers);
+  })).use(remarkTransformers).use(remarkSlug).use(remarkDisableTokenizers, opts.disableTokenizers);
 }
 
 /**
  * Full markdown to html processor
  */
 function htmlProcessor() {
-  var _processor$use$use$us;
   var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
   var _setup3 = setup('', opts);
-  var _setup4 = _babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1___default()(_setup3, 2);
+  var _setup4 = _babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_0___default()(_setup3, 2);
   opts = _setup4[1];
-  var _opts2 = opts,
-    sanitize = _opts2.sanitize;
+  var _opts = opts,
+    sanitize = _opts.sanitize;
 
   /*
    * This is kinda complicated: "markdown" within ReadMe is
@@ -34452,16 +34587,16 @@ function htmlProcessor() {
    * - sanitize and remove any disallowed attributes
    * - output the hast to a React vdom with our custom components
    */
-  return (_processor$use$use$us = processor(opts).use(remarkRehype, {
+  return processor(opts).use(remarkRehype, {
     allowDangerousHtml: true
-  }).use(rehypeRaw).use(rehypeSanitize, sanitize)).use.apply(_processor$use$use$us, _babel_runtime_helpers_toConsumableArray__WEBPACK_IMPORTED_MODULE_0___default()(rehypeTransformers));
+  }).use(rehypeRaw).use(rehypeSanitize, sanitize).use(rehypeTransformers);
 }
 function plain(text) {
   var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   var components = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   if (!text) return null;
   var _setup5 = setup(text, opts);
-  var _setup6 = _babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1___default()(_setup5, 2);
+  var _setup6 = _babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_0___default()(_setup5, 2);
   text = _setup6[0];
   opts = _setup6[1];
   var proc = htmlProcessor(opts).use(rehypeReact, {
@@ -34476,8 +34611,8 @@ function plain(text) {
  *  return a React VDOM component tree
  */
 // eslint-disable-next-line react/prop-types
-var PinWrap = function PinWrap(_ref) {
-  var children = _ref.children;
+var PinWrap = function PinWrap(_ref4) {
+  var children = _ref4.children;
   return /*#__PURE__*/React.createElement("div", {
     className: "pin"
   }, children);
@@ -34487,10 +34622,10 @@ function reactProcessor() {
   var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
   var components = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   var _setup7 = setup('', opts);
-  var _setup8 = _babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1___default()(_setup7, 2);
+  var _setup8 = _babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_0___default()(_setup7, 2);
   opts = _setup8[1];
-  var _opts3 = opts,
-    sanitize = _opts3.sanitize;
+  var _opts2 = opts,
+    sanitize = _opts2.sanitize;
   return htmlProcessor(_objectSpread({}, opts)).use(sectionAnchorId).use(rehypeReact, {
     createElement: createElement(opts),
     Fragment: React.Fragment,
@@ -34521,12 +34656,12 @@ function react(content) {
   var components = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   if (!content) return null;else if (typeof content === 'string') {
     var _setup9 = setup(content, opts);
-    var _setup10 = _babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1___default()(_setup9, 2);
+    var _setup10 = _babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_0___default()(_setup9, 2);
     content = _setup10[0];
     opts = _setup10[1];
   } else {
     var _setup11 = setup('', opts);
-    var _setup12 = _babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1___default()(_setup11, 2);
+    var _setup12 = _babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_0___default()(_setup11, 2);
     opts = _setup12[1];
   }
   var proc = reactProcessor(opts, components);
@@ -34537,7 +34672,7 @@ function reactTOC(tree) {
   var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   if (!tree) return null;
   var _setup13 = setup('', opts);
-  var _setup14 = _babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1___default()(_setup13, 2);
+  var _setup14 = _babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_0___default()(_setup13, 2);
   opts = _setup14[1];
   var proc = htmlProcessor(opts).use(rehypeReact, {
     createElement: React.createElement,
@@ -34549,8 +34684,8 @@ function reactTOC(tree) {
   });
 
   // Normalize Heading Levels
-  var minLevel = selectAll('heading', tree).reduce(function (i, _ref2) {
-    var depth = _ref2.depth;
+  var minLevel = selectAll('heading', tree).reduce(function (i, _ref5) {
+    var depth = _ref5.depth;
     return !i || depth <= i ? depth : i;
   }, false); // determine "root" depth
   tree = mapNodes(tree, function (n) {
@@ -34571,7 +34706,7 @@ function html(text) {
   var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   if (!text) return null;
   var _setup15 = setup(text, opts);
-  var _setup16 = _babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1___default()(_setup15, 2);
+  var _setup16 = _babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_0___default()(_setup15, 2);
   text = _setup16[0];
   opts = _setup16[1];
   return htmlProcessor(opts).use(rehypeStringify).processSync(text).contents;
@@ -34584,7 +34719,7 @@ function hast(text) {
   var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   if (!text) return null;
   var _setup17 = setup(text, opts);
-  var _setup18 = _babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1___default()(_setup17, 2);
+  var _setup18 = _babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_0___default()(_setup17, 2);
   text = _setup18[0];
   opts = _setup18[1];
   var rdmd = htmlProcessor(opts).use(tableFlattening);
@@ -34599,7 +34734,7 @@ function mdast(text) {
   var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   if (!text) return null;
   var _setup19 = setup(text, opts);
-  var _setup20 = _babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1___default()(_setup19, 2);
+  var _setup20 = _babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_0___default()(_setup19, 2);
   text = _setup20[0];
   opts = _setup20[1];
   var rdmd = processor(opts);
@@ -34613,7 +34748,7 @@ function astToPlainText(node) {
   var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   if (!node) return '';
   var _setup21 = setup('', opts);
-  var _setup22 = _babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1___default()(_setup21, 2);
+  var _setup22 = _babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_0___default()(_setup21, 2);
   opts = _setup22[1];
   return processor(opts).use(toPlainText).stringify(node);
 }
@@ -34625,7 +34760,7 @@ function md(tree) {
   var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   if (!tree) return null;
   var _setup23 = setup('', opts);
-  var _setup24 = _babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1___default()(_setup23, 2);
+  var _setup24 = _babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_0___default()(_setup23, 2);
   opts = _setup24[1];
   return processor(opts).use(remarkStringify, opts.markdownOptions).use(customCompilers).stringify(tree);
 }