lab.waku.org/examples/flush-notes/.next/server/vendor-chunks/unified.js

"use strict";
/*
 * ATTENTION: An "eval-source-map" devtool has been used.
 * This devtool is neither made for production nor for readable output files.
 * It uses "eval()" calls to create a separate source file with attached SourceMaps in the browser devtools.
 * If you are trying to read the output file, select a different devtool (https://webpack.js.org/configuration/devtool/)
 * or disable the default devtool with "devtool: false".
 * If you are looking for production-ready output files, see mode: "production" (https://webpack.js.org/configuration/mode/).
 */
exports.id = "vendor-chunks/unified";
exports.ids = ["vendor-chunks/unified"];
exports.modules = {

/***/ "(ssr)/./node_modules/unified/lib/callable-instance.js":
/*!*******************************************************!*\
  !*** ./node_modules/unified/lib/callable-instance.js ***!
  \*******************************************************/
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {

eval("__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\n/* harmony export */   CallableInstance: () => (/* binding */ CallableInstance)\n/* harmony export */ });\nconst CallableInstance = /**\n   * @type {new <Parameters extends Array<unknown>, Result>(property: string | symbol) => (...parameters: Parameters) => Result}\n   */ /** @type {unknown} */ /**\n       * @this {Function}\n       * @param {string | symbol} property\n       * @returns {(...parameters: Array<unknown>) => unknown}\n       */ function(property) {\n    const self = this;\n    const constr = self.constructor;\n    const proto = /** @type {Record<string | symbol, Function>} */ // Prototypes do exist.\n    // type-coverage:ignore-next-line\n    constr.prototype;\n    const func = proto[property];\n    /** @type {(...parameters: Array<unknown>) => unknown} */ const apply = function() {\n        return func.apply(apply, arguments);\n    };\n    Object.setPrototypeOf(apply, proto);\n    const names = Object.getOwnPropertyNames(func);\n    for (const p of names){\n        const descriptor = Object.getOwnPropertyDescriptor(func, p);\n        if (descriptor) Object.defineProperty(apply, p, descriptor);\n    }\n    return apply;\n};\n//# sourceURL=[module]\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,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\n//# sourceURL=webpack-internal:///(ssr)/./node_modules/unified/lib/callable-instance.js\n");

/***/ }),

/***/ "(ssr)/./node_modules/unified/lib/index.js":
/*!*******************************************!*\
  !*** ./node_modules/unified/lib/index.js ***!
  \*******************************************/
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {

eval("__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\n/* harmony export */   Processor: () => (/* binding */ Processor),\n/* harmony export */   unified: () => (/* binding */ unified)\n/* harmony export */ });\n/* harmony import */ var bail__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! bail */ \"(ssr)/./node_modules/bail/index.js\");\n/* harmony import */ var extend__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! extend */ \"(ssr)/./node_modules/extend/index.js\");\n/* harmony import */ var devlop__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! devlop */ \"(ssr)/./node_modules/devlop/lib/development.js\");\n/* harmony import */ var is_plain_obj__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! is-plain-obj */ \"(ssr)/./node_modules/unified/node_modules/is-plain-obj/index.js\");\n/* harmony import */ var trough__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! trough */ \"(ssr)/./node_modules/trough/index.js\");\n/* harmony import */ var vfile__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! vfile */ \"(ssr)/./node_modules/vfile/lib/index.js\");\n/* harmony import */ var _callable_instance_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./callable-instance.js */ \"(ssr)/./node_modules/unified/lib/callable-instance.js\");\n/**\n * @typedef {import('trough').Pipeline} Pipeline\n *\n * @typedef {import('unist').Node} Node\n *\n * @typedef {import('vfile').Compatible} Compatible\n * @typedef {import('vfile').Value} Value\n *\n * @typedef {import('../index.js').CompileResultMap} CompileResultMap\n * @typedef {import('../index.js').Data} Data\n * @typedef {import('../index.js').Settings} Settings\n */ /**\n * @typedef {CompileResultMap[keyof CompileResultMap]} CompileResults\n *   Acceptable results from compilers.\n *\n *   To register custom results, add them to\n *   {@link CompileResultMap `CompileResultMap`}.\n */ /**\n * @template {Node} [Tree=Node]\n *   The node that the compiler receives (default: `Node`).\n * @template {CompileResults} [Result=CompileResults]\n *   The thing that the compiler yields (default: `CompileResults`).\n * @callback Compiler\n *   A **compiler** handles the compiling of a syntax tree to something else\n *   (in most cases, text) (TypeScript type).\n *\n *   It is used in the stringify phase and called with a {@link Node `Node`}\n *   and {@link VFile `VFile`} representation of the document to compile.\n *   It should return the textual representation of the given tree (typically\n *   `string`).\n *\n *   > 👉 **Note**: unified typically compiles by serializing: most compilers\n *   > return `string` (or `Uint8Array`).\n *   > Some compilers, such as the one configured with\n *   > [`rehype-react`][rehype-react], return other values (in this case, a\n *   > React tree).\n *   > If you’re using a compiler that doesn’t serialize, expect different\n *   > result values.\n *   >\n *   > To register custom results in TypeScript, add them to\n *   > {@link CompileResultMap `CompileResultMap`}.\n *\n *   [rehype-react]: https://github.com/rehypejs/rehype-react\n * @param {Tree} tree\n *   Tree to compile.\n * @param {VFile} file\n *   File associated with `tree`.\n * @returns {Result}\n *   New content: compiled text (`string` or `Uint8Array`, for `file.value`) or\n *   something else (for `file.result`).\n */ /**\n * @template {Node} [Tree=Node]\n *   The node that the parser yields (default: `Node`)\n * @callback Parser\n *   A **parser** handles the parsing of text to a syntax tree.\n *\n *   It is used in the parse phase and is called with a `string` and\n *   {@link VFile `VFile`} of the document to parse.\n *   It must return the syntax tree representation of the given file\n *   ({@link Node `Node`}).\n * @param {string} document\n *   Document to parse.\n * @param {VFile} file\n *   File associated with `document`.\n * @returns {Tree}\n *   Node representing the given file.\n */ /**\n * @typedef {(\n *   Plugin<Array<any>, any, any> |\n *   PluginTuple<Array<any>, any, any> |\n *   Preset\n * )} Pluggable\n *   Union of the different ways to add plugins and settings.\n */ /**\n * @typedef {Array<Pluggable>} PluggableList\n *   List of plugins and presets.\n */ // Note: we can’t use `callback` yet as it messes up `this`:\n//  <https://github.com/microsoft/TypeScript/issues/55197>.\n/**\n * @template {Array<unknown>} [PluginParameters=[]]\n *   Arguments passed to the plugin (default: `[]`, the empty tuple).\n * @template {Node | string | undefined} [Input=Node]\n *   Value that is expected as input (default: `Node`).\n *\n *   *   If the plugin returns a {@link Transformer `Transformer`}, this\n *       should be the node it expects.\n *   *   If the plugin sets a {@link Parser `Parser`}, this should be\n *       `string`.\n *   *   If the plugin sets a {@link Compiler `Compiler`}, this should be the\n *       node it expects.\n * @template [Output=Input]\n *   Value that is yielded as output (default: `Input`).\n *\n *   *   If the plugin returns a {@link Transformer `Transformer`}, this\n *       should be the node that that yields.\n *   *   If the plugin sets a {@link Parser `Parser`}, this should be the\n *       node that it yields.\n *   *   If the plugin sets a {@link Compiler `Compiler`}, this should be\n *       result it yields.\n * @typedef {(\n *   (this: Processor, ...parameters: PluginParameters) =>\n *     Input extends string ? // Parser.\n *        Output extends Node | undefined ? undefined | void : never :\n *     Output extends CompileResults ? // Compiler.\n *        Input extends Node | undefined ? undefined | void : never :\n *     Transformer<\n *       Input extends Node ? Input : Node,\n *       Output extends Node ? Output : Node\n *     > | undefined | void\n * )} Plugin\n *   Single plugin.\n *\n *   Plugins configure the processors they are applied on in the following\n *   ways:\n *\n *   *   they change the processor, such as the parser, the compiler, or by\n *       configuring data\n *   *   they specify how to handle trees and files\n *\n *   In practice, they are functions that can receive options and configure the\n *   processor (`this`).\n *\n *   > 👉 **Note**: plugins are called when the processor is *frozen*, not when\n *   > they are applied.\n */ /**\n * Tuple of a plugin and its configuration.\n *\n * The first item is a plugin, the rest are its parameters.\n *\n * @template {Array<unknown>} [TupleParameters=[]]\n *   Arguments passed to the plugin (default: `[]`, the empty tuple).\n * @template {Node | string | undefined} [Input=undefined]\n *   Value that is expected as input (optional).\n *\n *   *   If the plugin returns a {@link Transformer `Transformer`}, this\n *       should be the node it expects.\n *   *   If the plugin sets a {@link Parser `Parser`}, this should be\n *       `string`.\n *   *   If the plugin sets a {@link Compiler `Compiler`}, this should be the\n *       node it expects.\n * @template [Output=undefined] (optional).\n *   Value that is yielded as output.\n *\n *   *   If the plugin returns a {@link Transformer `Transformer`}, this\n *       should be the node that that yields.\n *   *   If the plugin sets a {@link Parser `Parser`}, this should be the\n *       node that it yields.\n *   *   If the plugin sets a {@link Compiler `Compiler`}, this should be\n *       result it yields.\n * @typedef {(\n *   [\n *     plugin: Plugin<TupleParameters, Input, Output>,\n *     ...parameters: TupleParameters\n *   ]\n * )} PluginTuple\n */ /**\n * @typedef Preset\n *   Sharable configuration.\n *\n *   They can contain plugins and settings.\n * @property {PluggableList | undefined} [plugins]\n *   List of plugins and presets (optional).\n * @property {Settings | undefined} [settings]\n *   Shared settings for parsers and compilers (optional).\n */ /**\n * @template {VFile} [File=VFile]\n *   The file that the callback receives (default: `VFile`).\n * @callback ProcessCallback\n *   Callback called when the process is done.\n *\n *   Called with either an error or a result.\n * @param {Error | undefined} [error]\n *   Fatal error (optional).\n * @param {File | undefined} [file]\n *   Processed file (optional).\n * @returns {undefined}\n *   Nothing.\n */ /**\n * @template {Node} [Tree=Node]\n *   The tree that the callback receives (default: `Node`).\n * @callback RunCallback\n *   Callback called when transformers are done.\n *\n *   Called with either an error or results.\n * @param {Error | undefined} [error]\n *   Fatal error (optional).\n * @param {Tree | undefined} [tree]\n *   Transformed tree (optional).\n * @param {VFile | undefined} [file]\n *   File (optional).\n * @returns {undefined}\n *   Nothing.\n */ /**\n * @template {Node} [Output=Node]\n *   Node type that the transformer yields (default: `Node`).\n * @callback TransformCallback\n *   Callback passed to transforms.\n *\n *   If the signature of a `transformer` accepts a third argument, the\n *   transformer may perform asynchronous operations, and must call it.\n * @param {Error | undefined} [error]\n *   Fatal error to stop the process (optional).\n * @param {Output | undefined} [tree]\n *   New, changed, tree (optional).\n * @param {VFile | undefined} [file]\n *   New, changed, file (optional).\n * @returns {undefined}\n *   Nothing.\n */ /**\n * @template {Node} [Input=Node]\n *   Node type that the transformer expects (default: `Node`).\n * @template {Node} [Output=Input]\n *   Node type that the transformer yields (default: `Input`).\n * @callback Transformer\n *   Transformers handle syntax trees and files.\n *\n *   They are functions that are called each time a syntax tree and file are\n *   passed through the run phase.\n *   When an error occurs in them (either because it’s thrown, returned,\n *   rejected, or passed to `next`), the process stops.\n *\n *   The run phase is handled by [`trough`][trough], see its documentation for\n *   the exact semantics of these functions.\n *\n *   > 👉 **Note**: you should likely ignore `next`: don’t accept it.\n *   > it supports callback-style async work.\n *   > But promises are likely easier to reason about.\n *\n *   [trough]: https://github.com/wooorm/trough#function-fninput-next\n * @param {Input} tree\n *   Tree to handle.\n * @param {VFile} file\n *   File to handle.\n * @param {TransformCallback<Output>} next\n *   Callback.\n * @returns {(\n *   Promise<Output | undefined | void> |\n *   Promise<never> | // For some reason this is needed separately.\n *   Output |\n *   Error |\n *   undefined |\n *   void\n * )}\n *   If you accept `next`, nothing.\n *   Otherwise:\n *\n *   *   `Error` — fatal error to stop the process\n *   *   `Promise<undefined>` or `undefined` — the next transformer keeps using\n *       same tree\n *   *   `Promise<Node>` or `Node` — new, changed, tree\n */ /**\n * @template {Node | undefined} ParseTree\n *   Output of `parse`.\n * @template {Node | undefined} HeadTree\n *   Input for `run`.\n * @template {Node | undefined} TailTree\n *   Output for `run`.\n * @template {Node | undefined} CompileTree\n *   Input of `stringify`.\n * @template {CompileResults | undefined} CompileResult\n *   Output of `stringify`.\n * @template {Node | string | undefined} Input\n *   Input of plugin.\n * @template Output\n *   Output of plugin (optional).\n * @typedef {(\n *   Input extends string\n *     ? Output extends Node | undefined\n *       ? // Parser.\n *         Processor<\n *           Output extends undefined ? ParseTree : Output,\n *           HeadTree,\n *           TailTree,\n *           CompileTree,\n *           CompileResult\n *         >\n *       : // Unknown.\n *         Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>\n *     : Output extends CompileResults\n *     ? Input extends Node | undefined\n *       ? // Compiler.\n *         Processor<\n *           ParseTree,\n *           HeadTree,\n *           TailTree,\n *           Input extends undefined ? CompileTree : Input,\n *           Output extends undefined ? CompileResult : Output\n *         >\n *       : // Unknown.\n *         Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>\n *     : Input extends Node | undefined\n *     ? Output extends Node | undefined\n *       ? // Transform.\n *         Processor<\n *           ParseTree,\n *           HeadTree extends undefined ? Input : HeadTree,\n *           Output extends undefined ? TailTree : Output,\n *           CompileTree,\n *           CompileResult\n *         >\n *       : // Unknown.\n *         Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>\n *     : // Unknown.\n *       Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>\n * )} UsePlugin\n *   Create a processor based on the input/output of a {@link Plugin plugin}.\n */ /**\n * @template {CompileResults | undefined} Result\n *   Node type that the transformer yields.\n * @typedef {(\n *   Result extends Value | undefined ?\n *     VFile :\n *     VFile & {result: Result}\n *   )} VFileWithOutput\n *   Type to generate a {@link VFile `VFile`} corresponding to a compiler result.\n *\n *   If a result that is not acceptable on a `VFile` is used, that will\n *   be stored on the `result` field of {@link VFile `VFile`}.\n */ \n\n\n\n\n\n\n// To do: next major: drop `Compiler`, `Parser`: prefer lowercase.\n// To do: we could start yielding `never` in TS when a parser is missing and\n// `parse` is called.\n// Currently, we allow directly setting `processor.parser`, which is untyped.\nconst own = {}.hasOwnProperty;\n/**\n * @template {Node | undefined} [ParseTree=undefined]\n *   Output of `parse` (optional).\n * @template {Node | undefined} [HeadTree=undefined]\n *   Input for `run` (optional).\n * @template {Node | undefined} [TailTree=undefined]\n *   Output for `run` (optional).\n * @template {Node | undefined} [CompileTree=undefined]\n *   Input of `stringify` (optional).\n * @template {CompileResults | undefined} [CompileResult=undefined]\n *   Output of `stringify` (optional).\n * @extends {CallableInstance<[], Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>>}\n */ class Processor extends _callable_instance_js__WEBPACK_IMPORTED_MODULE_2__.CallableInstance {\n    /**\n   * Create a processor.\n   */ constructor(){\n        // If `Processor()` is called (w/o new), `copy` is called instead.\n        super(\"copy\");\n        /**\n     * Compiler to use (deprecated).\n     *\n     * @deprecated\n     *   Use `compiler` instead.\n     * @type {(\n     *   Compiler<\n     *     CompileTree extends undefined ? Node : CompileTree,\n     *     CompileResult extends undefined ? CompileResults : CompileResult\n     *   > |\n     *   undefined\n     * )}\n     */ this.Compiler = undefined;\n        /**\n     * Parser to use (deprecated).\n     *\n     * @deprecated\n     *   Use `parser` instead.\n     * @type {(\n     *   Parser<ParseTree extends undefined ? Node : ParseTree> |\n     *   undefined\n     * )}\n     */ this.Parser = undefined;\n        // Note: the following fields are considered private.\n        // However, they are needed for tests, and TSC generates an untyped\n        // `private freezeIndex` field for, which trips `type-coverage` up.\n        // Instead, we use `@deprecated` to visualize that they shouldn’t be used.\n        /**\n     * Internal list of configured plugins.\n     *\n     * @deprecated\n     *   This is a private internal property and should not be used.\n     * @type {Array<PluginTuple<Array<unknown>>>}\n     */ this.attachers = [];\n        /**\n     * Compiler to use.\n     *\n     * @type {(\n     *   Compiler<\n     *     CompileTree extends undefined ? Node : CompileTree,\n     *     CompileResult extends undefined ? CompileResults : CompileResult\n     *   > |\n     *   undefined\n     * )}\n     */ this.compiler = undefined;\n        /**\n     * Internal state to track where we are while freezing.\n     *\n     * @deprecated\n     *   This is a private internal property and should not be used.\n     * @type {number}\n     */ this.freezeIndex = -1;\n        /**\n     * Internal state to track whether we’re frozen.\n     *\n     * @deprecated\n     *   This is a private internal property and should not be used.\n     * @type {boolean | undefined}\n     */ this.frozen = undefined;\n        /**\n     * Internal state.\n     *\n     * @deprecated\n     *   This is a private internal property and should not be used.\n     * @type {Data}\n     */ this.namespace = {};\n        /**\n     * Parser to use.\n     *\n     * @type {(\n     *   Parser<ParseTree extends undefined ? Node : ParseTree> |\n     *   undefined\n     * )}\n     */ this.parser = undefined;\n        /**\n     * Internal list of configured transformers.\n     *\n     * @deprecated\n     *   This is a private internal property and should not be used.\n     * @type {Pipeline}\n     */ this.transformers = (0,trough__WEBPACK_IMPORTED_MODULE_3__.trough)();\n    }\n    /**\n   * Copy a processor.\n   *\n   * @deprecated\n   *   This is a private internal method and should not be used.\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *   New *unfrozen* processor ({@link Processor `Processor`}) that is\n   *   configured to work the same as its ancestor.\n   *   When the descendant processor is configured in the future it does not\n   *   affect the ancestral processor.\n   */ copy() {\n        // Cast as the type parameters will be the same after attaching.\n        const destination = /** @type {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>} */ new Processor();\n        let index = -1;\n        while(++index < this.attachers.length){\n            const attacher = this.attachers[index];\n            destination.use(...attacher);\n        }\n        destination.data(extend__WEBPACK_IMPORTED_MODULE_0__(true, {}, this.namespace));\n        return destination;\n    }\n    /**\n   * Configure the processor with info available to all plugins.\n   * Information is stored in an object.\n   *\n   * Typically, options can be given to a specific plugin, but sometimes it\n   * makes sense to have information shared with several plugins.\n   * For example, a list of HTML elements that are self-closing, which is\n   * needed during all phases.\n   *\n   * > 👉 **Note**: setting information cannot occur on *frozen* processors.\n   * > Call the processor first to create a new unfrozen processor.\n   *\n   * > 👉 **Note**: to register custom data in TypeScript, augment the\n   * > {@link Data `Data`} interface.\n   *\n   * @example\n   *   This example show how to get and set info:\n   *\n   *   ```js\n   *   import {unified} from 'unified'\n   *\n   *   const processor = unified().data('alpha', 'bravo')\n   *\n   *   processor.data('alpha') // => 'bravo'\n   *\n   *   processor.data() // => {alpha: 'bravo'}\n   *\n   *   processor.data({charlie: 'delta'})\n   *\n   *   processor.data() // => {charlie: 'delta'}\n   *   ```\n   *\n   * @template {keyof Data} Key\n   *\n   * @overload\n   * @returns {Data}\n   *\n   * @overload\n   * @param {Data} dataset\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *\n   * @overload\n   * @param {Key} key\n   * @returns {Data[Key]}\n   *\n   * @overload\n   * @param {Key} key\n   * @param {Data[Key]} value\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *\n   * @param {Data | Key} [key]\n   *   Key to get or set, or entire dataset to set, or nothing to get the\n   *   entire dataset (optional).\n   * @param {Data[Key]} [value]\n   *   Value to set (optional).\n   * @returns {unknown}\n   *   The current processor when setting, the value at `key` when getting, or\n   *   the entire dataset when getting without key.\n   */ data(key, value) {\n        if (typeof key === \"string\") {\n            // Set `key`.\n            if (arguments.length === 2) {\n                assertUnfrozen(\"data\", this.frozen);\n                this.namespace[key] = value;\n                return this;\n            }\n            // Get `key`.\n            return own.call(this.namespace, key) && this.namespace[key] || undefined;\n        }\n        // Set space.\n        if (key) {\n            assertUnfrozen(\"data\", this.frozen);\n            this.namespace = key;\n            return this;\n        }\n        // Get space.\n        return this.namespace;\n    }\n    /**\n   * Freeze a processor.\n   *\n   * Frozen processors are meant to be extended and not to be configured\n   * directly.\n   *\n   * When a processor is frozen it cannot be unfrozen.\n   * New processors working the same way can be created by calling the\n   * processor.\n   *\n   * It’s possible to freeze processors explicitly by calling `.freeze()`.\n   * Processors freeze automatically when `.parse()`, `.run()`, `.runSync()`,\n   * `.stringify()`, `.process()`, or `.processSync()` are called.\n   *\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *   The current processor.\n   */ freeze() {\n        if (this.frozen) {\n            return this;\n        }\n        // Cast so that we can type plugins easier.\n        // Plugins are supposed to be usable on different processors, not just on\n        // this exact processor.\n        const self = /** @type {Processor} */ /** @type {unknown} */ this;\n        while(++this.freezeIndex < this.attachers.length){\n            const [attacher, ...options] = this.attachers[this.freezeIndex];\n            if (options[0] === false) {\n                continue;\n            }\n            if (options[0] === true) {\n                options[0] = undefined;\n            }\n            const transformer = attacher.call(self, ...options);\n            if (typeof transformer === \"function\") {\n                this.transformers.use(transformer);\n            }\n        }\n        this.frozen = true;\n        this.freezeIndex = Number.POSITIVE_INFINITY;\n        return this;\n    }\n    /**\n   * Parse text to a syntax tree.\n   *\n   * > 👉 **Note**: `parse` freezes the processor if not already *frozen*.\n   *\n   * > 👉 **Note**: `parse` performs the parse phase, not the run phase or other\n   * > phases.\n   *\n   * @param {Compatible | undefined} [file]\n   *   file to parse (optional); typically `string` or `VFile`; any value\n   *   accepted as `x` in `new VFile(x)`.\n   * @returns {ParseTree extends undefined ? Node : ParseTree}\n   *   Syntax tree representing `file`.\n   */ parse(file) {\n        this.freeze();\n        const realFile = vfile(file);\n        const parser = this.parser || this.Parser;\n        assertParser(\"parse\", parser);\n        return parser(String(realFile), realFile);\n    }\n    /**\n   * Process the given file as configured on the processor.\n   *\n   * > 👉 **Note**: `process` freezes the processor if not already *frozen*.\n   *\n   * > 👉 **Note**: `process` performs the parse, run, and stringify phases.\n   *\n   * @overload\n   * @param {Compatible | undefined} file\n   * @param {ProcessCallback<VFileWithOutput<CompileResult>>} done\n   * @returns {undefined}\n   *\n   * @overload\n   * @param {Compatible | undefined} [file]\n   * @returns {Promise<VFileWithOutput<CompileResult>>}\n   *\n   * @param {Compatible | undefined} [file]\n   *   File (optional); typically `string` or `VFile`]; any value accepted as\n   *   `x` in `new VFile(x)`.\n   * @param {ProcessCallback<VFileWithOutput<CompileResult>> | undefined} [done]\n   *   Callback (optional).\n   * @returns {Promise<VFile> | undefined}\n   *   Nothing if `done` is given.\n   *   Otherwise a promise, rejected with a fatal error or resolved with the\n   *   processed file.\n   *\n   *   The parsed, transformed, and compiled value is available at\n   *   `file.value` (see note).\n   *\n   *   > 👉 **Note**: unified typically compiles by serializing: most\n   *   > compilers return `string` (or `Uint8Array`).\n   *   > Some compilers, such as the one configured with\n   *   > [`rehype-react`][rehype-react], return other values (in this case, a\n   *   > React tree).\n   *   > If you’re using a compiler that doesn’t serialize, expect different\n   *   > result values.\n   *   >\n   *   > To register custom results in TypeScript, add them to\n   *   > {@link CompileResultMap `CompileResultMap`}.\n   *\n   *   [rehype-react]: https://github.com/rehypejs/rehype-react\n   */ process(file, done) {\n        const self = this;\n        this.freeze();\n        assertParser(\"process\", this.parser || this.Parser);\n        assertCompiler(\"process\", this.compiler || this.Compiler);\n        return done ? executor(undefined, done) : new Promise(executor);\n        // Note: `void`s needed for TS.\n        /**\n     * @param {((file: VFileWithOutput<CompileResult>) => undefined | void) | undefined} resolve\n     * @param {(error: Error | undefined) => undefined | void} reject\n     * @returns {undefined}\n     */ function executor(resolve, reject) {\n            const realFile = vfile(file);\n            // Assume `ParseTree` (the result of the parser) matches `HeadTree` (the\n            // input of the first transform).\n            const parseTree = /** @type {HeadTree extends undefined ? Node : HeadTree} */ /** @type {unknown} */ self.parse(realFile);\n            self.run(parseTree, realFile, function(error, tree, file) {\n                if (error || !tree || !file) {\n                    return realDone(error);\n                }\n                // Assume `TailTree` (the output of the last transform) matches\n                // `CompileTree` (the input of the compiler).\n                const compileTree = /** @type {CompileTree extends undefined ? Node : CompileTree} */ /** @type {unknown} */ tree;\n                const compileResult = self.stringify(compileTree, file);\n                if (looksLikeAValue(compileResult)) {\n                    file.value = compileResult;\n                } else {\n                    file.result = compileResult;\n                }\n                realDone(error, /** @type {VFileWithOutput<CompileResult>} */ file);\n            });\n            /**\n       * @param {Error | undefined} error\n       * @param {VFileWithOutput<CompileResult> | undefined} [file]\n       * @returns {undefined}\n       */ function realDone(error, file) {\n                if (error || !file) {\n                    reject(error);\n                } else if (resolve) {\n                    resolve(file);\n                } else {\n                    (0,devlop__WEBPACK_IMPORTED_MODULE_4__.ok)(done, \"`done` is defined if `resolve` is not\");\n                    done(undefined, file);\n                }\n            }\n        }\n    }\n    /**\n   * Process the given file as configured on the processor.\n   *\n   * An error is thrown if asynchronous transforms are configured.\n   *\n   * > 👉 **Note**: `processSync` freezes the processor if not already *frozen*.\n   *\n   * > 👉 **Note**: `processSync` performs the parse, run, and stringify phases.\n   *\n   * @param {Compatible | undefined} [file]\n   *   File (optional); typically `string` or `VFile`; any value accepted as\n   *   `x` in `new VFile(x)`.\n   * @returns {VFileWithOutput<CompileResult>}\n   *   The processed file.\n   *\n   *   The parsed, transformed, and compiled value is available at\n   *   `file.value` (see note).\n   *\n   *   > 👉 **Note**: unified typically compiles by serializing: most\n   *   > compilers return `string` (or `Uint8Array`).\n   *   > Some compilers, such as the one configured with\n   *   > [`rehype-react`][rehype-react], return other values (in this case, a\n   *   > React tree).\n   *   > If you’re using a compiler that doesn’t serialize, expect different\n   *   > result values.\n   *   >\n   *   > To register custom results in TypeScript, add them to\n   *   > {@link CompileResultMap `CompileResultMap`}.\n   *\n   *   [rehype-react]: https://github.com/rehypejs/rehype-react\n   */ processSync(file) {\n        /** @type {boolean} */ let complete = false;\n        /** @type {VFileWithOutput<CompileResult> | undefined} */ let result;\n        this.freeze();\n        assertParser(\"processSync\", this.parser || this.Parser);\n        assertCompiler(\"processSync\", this.compiler || this.Compiler);\n        this.process(file, realDone);\n        assertDone(\"processSync\", \"process\", complete);\n        (0,devlop__WEBPACK_IMPORTED_MODULE_4__.ok)(result, \"we either bailed on an error or have a tree\");\n        return result;\n        /**\n     * @type {ProcessCallback<VFileWithOutput<CompileResult>>}\n     */ function realDone(error, file) {\n            complete = true;\n            (0,bail__WEBPACK_IMPORTED_MODULE_5__.bail)(error);\n            result = file;\n        }\n    }\n    /**\n   * Run *transformers* on a syntax tree.\n   *\n   * > 👉 **Note**: `run` freezes the processor if not already *frozen*.\n   *\n   * > 👉 **Note**: `run` performs the run phase, not other phases.\n   *\n   * @overload\n   * @param {HeadTree extends undefined ? Node : HeadTree} tree\n   * @param {RunCallback<TailTree extends undefined ? Node : TailTree>} done\n   * @returns {undefined}\n   *\n   * @overload\n   * @param {HeadTree extends undefined ? Node : HeadTree} tree\n   * @param {Compatible | undefined} file\n   * @param {RunCallback<TailTree extends undefined ? Node : TailTree>} done\n   * @returns {undefined}\n   *\n   * @overload\n   * @param {HeadTree extends undefined ? Node : HeadTree} tree\n   * @param {Compatible | undefined} [file]\n   * @returns {Promise<TailTree extends undefined ? Node : TailTree>}\n   *\n   * @param {HeadTree extends undefined ? Node : HeadTree} tree\n   *   Tree to transform and inspect.\n   * @param {(\n   *   RunCallback<TailTree extends undefined ? Node : TailTree> |\n   *   Compatible\n   * )} [file]\n   *   File associated with `node` (optional); any value accepted as `x` in\n   *   `new VFile(x)`.\n   * @param {RunCallback<TailTree extends undefined ? Node : TailTree>} [done]\n   *   Callback (optional).\n   * @returns {Promise<TailTree extends undefined ? Node : TailTree> | undefined}\n   *   Nothing if `done` is given.\n   *   Otherwise, a promise rejected with a fatal error or resolved with the\n   *   transformed tree.\n   */ run(tree, file, done) {\n        assertNode(tree);\n        this.freeze();\n        const transformers = this.transformers;\n        if (!done && typeof file === \"function\") {\n            done = file;\n            file = undefined;\n        }\n        return done ? executor(undefined, done) : new Promise(executor);\n        // Note: `void`s needed for TS.\n        /**\n     * @param {(\n     *   ((tree: TailTree extends undefined ? Node : TailTree) => undefined | void) |\n     *   undefined\n     * )} resolve\n     * @param {(error: Error) => undefined | void} reject\n     * @returns {undefined}\n     */ function executor(resolve, reject) {\n            (0,devlop__WEBPACK_IMPORTED_MODULE_4__.ok)(typeof file !== \"function\", \"`file` can’t be a `done` anymore, we checked\");\n            const realFile = vfile(file);\n            transformers.run(tree, realFile, realDone);\n            /**\n       * @param {Error | undefined} error\n       * @param {Node} outputTree\n       * @param {VFile} file\n       * @returns {undefined}\n       */ function realDone(error, outputTree, file) {\n                const resultingTree = /** @type {TailTree extends undefined ? Node : TailTree} */ outputTree || tree;\n                if (error) {\n                    reject(error);\n                } else if (resolve) {\n                    resolve(resultingTree);\n                } else {\n                    (0,devlop__WEBPACK_IMPORTED_MODULE_4__.ok)(done, \"`done` is defined if `resolve` is not\");\n                    done(undefined, resultingTree, file);\n                }\n            }\n        }\n    }\n    /**\n   * Run *transformers* on a syntax tree.\n   *\n   * An error is thrown if asynchronous transforms are configured.\n   *\n   * > 👉 **Note**: `runSync` freezes the processor if not already *frozen*.\n   *\n   * > 👉 **Note**: `runSync` performs the run phase, not other phases.\n   *\n   * @param {HeadTree extends undefined ? Node : HeadTree} tree\n   *   Tree to transform and inspect.\n   * @param {Compatible | undefined} [file]\n   *   File associated with `node` (optional); any value accepted as `x` in\n   *   `new VFile(x)`.\n   * @returns {TailTree extends undefined ? Node : TailTree}\n   *   Transformed tree.\n   */ runSync(tree, file) {\n        /** @type {boolean} */ let complete = false;\n        /** @type {(TailTree extends undefined ? Node : TailTree) | undefined} */ let result;\n        this.run(tree, file, realDone);\n        assertDone(\"runSync\", \"run\", complete);\n        (0,devlop__WEBPACK_IMPORTED_MODULE_4__.ok)(result, \"we either bailed on an error or have a tree\");\n        return result;\n        /**\n     * @type {RunCallback<TailTree extends undefined ? Node : TailTree>}\n     */ function realDone(error, tree) {\n            (0,bail__WEBPACK_IMPORTED_MODULE_5__.bail)(error);\n            result = tree;\n            complete = true;\n        }\n    }\n    /**\n   * Compile a syntax tree.\n   *\n   * > 👉 **Note**: `stringify` freezes the processor if not already *frozen*.\n   *\n   * > 👉 **Note**: `stringify` performs the stringify phase, not the run phase\n   * > or other phases.\n   *\n   * @param {CompileTree extends undefined ? Node : CompileTree} tree\n   *   Tree to compile.\n   * @param {Compatible | undefined} [file]\n   *   File associated with `node` (optional); any value accepted as `x` in\n   *   `new VFile(x)`.\n   * @returns {CompileResult extends undefined ? Value : CompileResult}\n   *   Textual representation of the tree (see note).\n   *\n   *   > 👉 **Note**: unified typically compiles by serializing: most compilers\n   *   > return `string` (or `Uint8Array`).\n   *   > Some compilers, such as the one configured with\n   *   > [`rehype-react`][rehype-react], return other values (in this case, a\n   *   > React tree).\n   *   > If you’re using a compiler that doesn’t serialize, expect different\n   *   > result values.\n   *   >\n   *   > To register custom results in TypeScript, add them to\n   *   > {@link CompileResultMap `CompileResultMap`}.\n   *\n   *   [rehype-react]: https://github.com/rehypejs/rehype-react\n   */ stringify(tree, file) {\n        this.freeze();\n        const realFile = vfile(file);\n        const compiler = this.compiler || this.Compiler;\n        assertCompiler(\"stringify\", compiler);\n        assertNode(tree);\n        return compiler(tree, realFile);\n    }\n    /**\n   * Configure the processor to use a plugin, a list of usable values, or a\n   * preset.\n   *\n   * If the processor is already using a plugin, the previous plugin\n   * configuration is changed based on the options that are passed in.\n   * In other words, the plugin is not added a second time.\n   *\n   * > 👉 **Note**: `use` cannot be called on *frozen* processors.\n   * > Call the processor first to create a new unfrozen processor.\n   *\n   * @example\n   *   There are many ways to pass plugins to `.use()`.\n   *   This example gives an overview:\n   *\n   *   ```js\n   *   import {unified} from 'unified'\n   *\n   *   unified()\n   *     // Plugin with options:\n   *     .use(pluginA, {x: true, y: true})\n   *     // Passing the same plugin again merges configuration (to `{x: true, y: false, z: true}`):\n   *     .use(pluginA, {y: false, z: true})\n   *     // Plugins:\n   *     .use([pluginB, pluginC])\n   *     // Two plugins, the second with options:\n   *     .use([pluginD, [pluginE, {}]])\n   *     // Preset with plugins and settings:\n   *     .use({plugins: [pluginF, [pluginG, {}]], settings: {position: false}})\n   *     // Settings only:\n   *     .use({settings: {position: false}})\n   *   ```\n   *\n   * @template {Array<unknown>} [Parameters=[]]\n   * @template {Node | string | undefined} [Input=undefined]\n   * @template [Output=Input]\n   *\n   * @overload\n   * @param {Preset | null | undefined} [preset]\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *\n   * @overload\n   * @param {PluggableList} list\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *\n   * @overload\n   * @param {Plugin<Parameters, Input, Output>} plugin\n   * @param {...(Parameters | [boolean])} parameters\n   * @returns {UsePlugin<ParseTree, HeadTree, TailTree, CompileTree, CompileResult, Input, Output>}\n   *\n   * @param {PluggableList | Plugin | Preset | null | undefined} value\n   *   Usable value.\n   * @param {...unknown} parameters\n   *   Parameters, when a plugin is given as a usable value.\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *   Current processor.\n   */ use(value, ...parameters) {\n        const attachers = this.attachers;\n        const namespace = this.namespace;\n        assertUnfrozen(\"use\", this.frozen);\n        if (value === null || value === undefined) {\n        // Empty.\n        } else if (typeof value === \"function\") {\n            addPlugin(value, parameters);\n        } else if (typeof value === \"object\") {\n            if (Array.isArray(value)) {\n                addList(value);\n            } else {\n                addPreset(value);\n            }\n        } else {\n            throw new TypeError(\"Expected usable value, not `\" + value + \"`\");\n        }\n        return this;\n        /**\n     * @param {Pluggable} value\n     * @returns {undefined}\n     */ function add(value) {\n            if (typeof value === \"function\") {\n                addPlugin(value, []);\n            } else if (typeof value === \"object\") {\n                if (Array.isArray(value)) {\n                    const [plugin, ...parameters] = /** @type {PluginTuple<Array<unknown>>} */ value;\n                    addPlugin(plugin, parameters);\n                } else {\n                    addPreset(value);\n                }\n            } else {\n                throw new TypeError(\"Expected usable value, not `\" + value + \"`\");\n            }\n        }\n        /**\n     * @param {Preset} result\n     * @returns {undefined}\n     */ function addPreset(result) {\n            if (!(\"plugins\" in result) && !(\"settings\" in result)) {\n                throw new Error(\"Expected usable value but received an empty preset, which is probably a mistake: presets typically come with `plugins` and sometimes with `settings`, but this has neither\");\n            }\n            addList(result.plugins);\n            if (result.settings) {\n                namespace.settings = extend__WEBPACK_IMPORTED_MODULE_0__(true, namespace.settings, result.settings);\n            }\n        }\n        /**\n     * @param {PluggableList | null | undefined} plugins\n     * @returns {undefined}\n     */ function addList(plugins) {\n            let index = -1;\n            if (plugins === null || plugins === undefined) {\n            // Empty.\n            } else if (Array.isArray(plugins)) {\n                while(++index < plugins.length){\n                    const thing = plugins[index];\n                    add(thing);\n                }\n            } else {\n                throw new TypeError(\"Expected a list of plugins, not `\" + plugins + \"`\");\n            }\n        }\n        /**\n     * @param {Plugin} plugin\n     * @param {Array<unknown>} parameters\n     * @returns {undefined}\n     */ function addPlugin(plugin, parameters) {\n            let index = -1;\n            let entryIndex = -1;\n            while(++index < attachers.length){\n                if (attachers[index][0] === plugin) {\n                    entryIndex = index;\n                    break;\n                }\n            }\n            if (entryIndex === -1) {\n                attachers.push([\n                    plugin,\n                    ...parameters\n                ]);\n            } else if (parameters.length > 0) {\n                let [primary, ...rest] = parameters;\n                const currentPrimary = attachers[entryIndex][1];\n                if ((0,is_plain_obj__WEBPACK_IMPORTED_MODULE_1__[\"default\"])(currentPrimary) && (0,is_plain_obj__WEBPACK_IMPORTED_MODULE_1__[\"default\"])(primary)) {\n                    primary = extend__WEBPACK_IMPORTED_MODULE_0__(true, currentPrimary, primary);\n                }\n                attachers[entryIndex] = [\n                    plugin,\n                    primary,\n                    ...rest\n                ];\n            }\n        }\n    }\n}\n// Note: this returns a *callable* instance.\n// That’s why it’s documented as a function.\n/**\n * Create a new processor.\n *\n * @example\n *   This example shows how a new processor can be created (from `remark`) and linked\n *   to **stdin**(4) and **stdout**(4).\n *\n *   ```js\n *   import process from 'node:process'\n *   import concatStream from 'concat-stream'\n *   import {remark} from 'remark'\n *\n *   process.stdin.pipe(\n *     concatStream(function (buf) {\n *       process.stdout.write(String(remark().processSync(buf)))\n *     })\n *   )\n *   ```\n *\n * @returns\n *   New *unfrozen* processor (`processor`).\n *\n *   This processor is configured to work the same as its ancestor.\n *   When the descendant processor is configured in the future it does not\n *   affect the ancestral processor.\n */ const unified = new Processor().freeze();\n/**\n * Assert a parser is available.\n *\n * @param {string} name\n * @param {unknown} value\n * @returns {asserts value is Parser}\n */ function assertParser(name, value) {\n    if (typeof value !== \"function\") {\n        throw new TypeError(\"Cannot `\" + name + \"` without `parser`\");\n    }\n}\n/**\n * Assert a compiler is available.\n *\n * @param {string} name\n * @param {unknown} value\n * @returns {asserts value is Compiler}\n */ function assertCompiler(name, value) {\n    if (typeof value !== \"function\") {\n        throw new TypeError(\"Cannot `\" + name + \"` without `compiler`\");\n    }\n}\n/**\n * Assert the processor is not frozen.\n *\n * @param {string} name\n * @param {unknown} frozen\n * @returns {asserts frozen is false}\n */ function assertUnfrozen(name, frozen) {\n    if (frozen) {\n        throw new Error(\"Cannot call `\" + name + \"` on a frozen processor.\\nCreate a new processor first, by calling it: use `processor()` instead of `processor`.\");\n    }\n}\n/**\n * Assert `node` is a unist node.\n *\n * @param {unknown} node\n * @returns {asserts node is Node}\n */ function assertNode(node) {\n    // `isPlainObj` unfortunately uses `any` instead of `unknown`.\n    // type-coverage:ignore-next-line\n    if (!(0,is_plain_obj__WEBPACK_IMPORTED_MODULE_1__[\"default\"])(node) || typeof node.type !== \"string\") {\n        throw new TypeError(\"Expected node, got `\" + node + \"`\");\n    // Fine.\n    }\n}\n/**\n * Assert that `complete` is `true`.\n *\n * @param {string} name\n * @param {string} asyncName\n * @param {unknown} complete\n * @returns {asserts complete is true}\n */ function assertDone(name, asyncName, complete) {\n    if (!complete) {\n        throw new Error(\"`\" + name + \"` finished async. Use `\" + asyncName + \"` instead\");\n    }\n}\n/**\n * @param {Compatible | undefined} [value]\n * @returns {VFile}\n */ function vfile(value) {\n    return looksLikeAVFile(value) ? value : new vfile__WEBPACK_IMPORTED_MODULE_6__.VFile(value);\n}\n/**\n * @param {Compatible | undefined} [value]\n * @returns {value is VFile}\n */ function looksLikeAVFile(value) {\n    return Boolean(value && typeof value === \"object\" && \"message\" in value && \"messages\" in value);\n}\n/**\n * @param {unknown} [value]\n * @returns {value is Value}\n */ function looksLikeAValue(value) {\n    return typeof value === \"string\" || isUint8Array(value);\n}\n/**\n * Assert `value` is an `Uint8Array`.\n *\n * @param {unknown} value\n *   thing.\n * @returns {value is Uint8Array}\n *   Whether `value` is an `Uint8Array`.\n */ function isUint8Array(value) {\n    return Boolean(value && typeof value === \"object\" && \"byteLength\" in value && \"byteOffset\" in value);\n}\n//# sourceURL=[module]\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"(ssr)/./node_modules/unified/lib/index.js","mappings":"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","sources":["webpack://flush-notes/./node_modules/unified/lib/index.js?3937"],"sourcesContent":["/**\n * @typedef {import('trough').Pipeline} Pipeline\n *\n * @typedef {import('unist').Node} Node\n *\n * @typedef {import('vfile').Compatible} Compatible\n * @typedef {import('vfile').Value} Value\n *\n * @typedef {import('../index.js').CompileResultMap} CompileResultMap\n * @typedef {import('../index.js').Data} Data\n * @typedef {import('../index.js').Settings} Settings\n */\n\n/**\n * @typedef {CompileResultMap[keyof CompileResultMap]} CompileResults\n *   Acceptable results from compilers.\n *\n *   To register custom results, add them to\n *   {@link CompileResultMap `CompileResultMap`}.\n */\n\n/**\n * @template {Node} [Tree=Node]\n *   The node that the compiler receives (default: `Node`).\n * @template {CompileResults} [Result=CompileResults]\n *   The thing that the compiler yields (default: `CompileResults`).\n * @callback Compiler\n *   A **compiler** handles the compiling of a syntax tree to something else\n *   (in most cases, text) (TypeScript type).\n *\n *   It is used in the stringify phase and called with a {@link Node `Node`}\n *   and {@link VFile `VFile`} representation of the document to compile.\n *   It should return the textual representation of the given tree (typically\n *   `string`).\n *\n *   > 👉 **Note**: unified typically compiles by serializing: most compilers\n *   > return `string` (or `Uint8Array`).\n *   > Some compilers, such as the one configured with\n *   > [`rehype-react`][rehype-react], return other values (in this case, a\n *   > React tree).\n *   > If you’re using a compiler that doesn’t serialize, expect different\n *   > result values.\n *   >\n *   > To register custom results in TypeScript, add them to\n *   > {@link CompileResultMap `CompileResultMap`}.\n *\n *   [rehype-react]: https://github.com/rehypejs/rehype-react\n * @param {Tree} tree\n *   Tree to compile.\n * @param {VFile} file\n *   File associated with `tree`.\n * @returns {Result}\n *   New content: compiled text (`string` or `Uint8Array`, for `file.value`) or\n *   something else (for `file.result`).\n */\n\n/**\n * @template {Node} [Tree=Node]\n *   The node that the parser yields (default: `Node`)\n * @callback Parser\n *   A **parser** handles the parsing of text to a syntax tree.\n *\n *   It is used in the parse phase and is called with a `string` and\n *   {@link VFile `VFile`} of the document to parse.\n *   It must return the syntax tree representation of the given file\n *   ({@link Node `Node`}).\n * @param {string} document\n *   Document to parse.\n * @param {VFile} file\n *   File associated with `document`.\n * @returns {Tree}\n *   Node representing the given file.\n */\n\n/**\n * @typedef {(\n *   Plugin<Array<any>, any, any> |\n *   PluginTuple<Array<any>, any, any> |\n *   Preset\n * )} Pluggable\n *   Union of the different ways to add plugins and settings.\n */\n\n/**\n * @typedef {Array<Pluggable>} PluggableList\n *   List of plugins and presets.\n */\n\n// Note: we can’t use `callback` yet as it messes up `this`:\n//  <https://github.com/microsoft/TypeScript/issues/55197>.\n/**\n * @template {Array<unknown>} [PluginParameters=[]]\n *   Arguments passed to the plugin (default: `[]`, the empty tuple).\n * @template {Node | string | undefined} [Input=Node]\n *   Value that is expected as input (default: `Node`).\n *\n *   *   If the plugin returns a {@link Transformer `Transformer`}, this\n *       should be the node it expects.\n *   *   If the plugin sets a {@link Parser `Parser`}, this should be\n *       `string`.\n *   *   If the plugin sets a {@link Compiler `Compiler`}, this should be the\n *       node it expects.\n * @template [Output=Input]\n *   Value that is yielded as output (default: `Input`).\n *\n *   *   If the plugin returns a {@link Transformer `Transformer`}, this\n *       should be the node that that yields.\n *   *   If the plugin sets a {@link Parser `Parser`}, this should be the\n *       node that it yields.\n *   *   If the plugin sets a {@link Compiler `Compiler`}, this should be\n *       result it yields.\n * @typedef {(\n *   (this: Processor, ...parameters: PluginParameters) =>\n *     Input extends string ? // Parser.\n *        Output extends Node | undefined ? undefined | void : never :\n *     Output extends CompileResults ? // Compiler.\n *        Input extends Node | undefined ? undefined | void : never :\n *     Transformer<\n *       Input extends Node ? Input : Node,\n *       Output extends Node ? Output : Node\n *     > | undefined | void\n * )} Plugin\n *   Single plugin.\n *\n *   Plugins configure the processors they are applied on in the following\n *   ways:\n *\n *   *   they change the processor, such as the parser, the compiler, or by\n *       configuring data\n *   *   they specify how to handle trees and files\n *\n *   In practice, they are functions that can receive options and configure the\n *   processor (`this`).\n *\n *   > 👉 **Note**: plugins are called when the processor is *frozen*, not when\n *   > they are applied.\n */\n\n/**\n * Tuple of a plugin and its configuration.\n *\n * The first item is a plugin, the rest are its parameters.\n *\n * @template {Array<unknown>} [TupleParameters=[]]\n *   Arguments passed to the plugin (default: `[]`, the empty tuple).\n * @template {Node | string | undefined} [Input=undefined]\n *   Value that is expected as input (optional).\n *\n *   *   If the plugin returns a {@link Transformer `Transformer`}, this\n *       should be the node it expects.\n *   *   If the plugin sets a {@link Parser `Parser`}, this should be\n *       `string`.\n *   *   If the plugin sets a {@link Compiler `Compiler`}, this should be the\n *       node it expects.\n * @template [Output=undefined] (optional).\n *   Value that is yielded as output.\n *\n *   *   If the plugin returns a {@link Transformer `Transformer`}, this\n *       should be the node that that yields.\n *   *   If the plugin sets a {@link Parser `Parser`}, this should be the\n *       node that it yields.\n *   *   If the plugin sets a {@link Compiler `Compiler`}, this should be\n *       result it yields.\n * @typedef {(\n *   [\n *     plugin: Plugin<TupleParameters, Input, Output>,\n *     ...parameters: TupleParameters\n *   ]\n * )} PluginTuple\n */\n\n/**\n * @typedef Preset\n *   Sharable configuration.\n *\n *   They can contain plugins and settings.\n * @property {PluggableList | undefined} [plugins]\n *   List of plugins and presets (optional).\n * @property {Settings | undefined} [settings]\n *   Shared settings for parsers and compilers (optional).\n */\n\n/**\n * @template {VFile} [File=VFile]\n *   The file that the callback receives (default: `VFile`).\n * @callback ProcessCallback\n *   Callback called when the process is done.\n *\n *   Called with either an error or a result.\n * @param {Error | undefined} [error]\n *   Fatal error (optional).\n * @param {File | undefined} [file]\n *   Processed file (optional).\n * @returns {undefined}\n *   Nothing.\n */\n\n/**\n * @template {Node} [Tree=Node]\n *   The tree that the callback receives (default: `Node`).\n * @callback RunCallback\n *   Callback called when transformers are done.\n *\n *   Called with either an error or results.\n * @param {Error | undefined} [error]\n *   Fatal error (optional).\n * @param {Tree | undefined} [tree]\n *   Transformed tree (optional).\n * @param {VFile | undefined} [file]\n *   File (optional).\n * @returns {undefined}\n *   Nothing.\n */\n\n/**\n * @template {Node} [Output=Node]\n *   Node type that the transformer yields (default: `Node`).\n * @callback TransformCallback\n *   Callback passed to transforms.\n *\n *   If the signature of a `transformer` accepts a third argument, the\n *   transformer may perform asynchronous operations, and must call it.\n * @param {Error | undefined} [error]\n *   Fatal error to stop the process (optional).\n * @param {Output | undefined} [tree]\n *   New, changed, tree (optional).\n * @param {VFile | undefined} [file]\n *   New, changed, file (optional).\n * @returns {undefined}\n *   Nothing.\n */\n\n/**\n * @template {Node} [Input=Node]\n *   Node type that the transformer expects (default: `Node`).\n * @template {Node} [Output=Input]\n *   Node type that the transformer yields (default: `Input`).\n * @callback Transformer\n *   Transformers handle syntax trees and files.\n *\n *   They are functions that are called each time a syntax tree and file are\n *   passed through the run phase.\n *   When an error occurs in them (either because it’s thrown, returned,\n *   rejected, or passed to `next`), the process stops.\n *\n *   The run phase is handled by [`trough`][trough], see its documentation for\n *   the exact semantics of these functions.\n *\n *   > 👉 **Note**: you should likely ignore `next`: don’t accept it.\n *   > it supports callback-style async work.\n *   > But promises are likely easier to reason about.\n *\n *   [trough]: https://github.com/wooorm/trough#function-fninput-next\n * @param {Input} tree\n *   Tree to handle.\n * @param {VFile} file\n *   File to handle.\n * @param {TransformCallback<Output>} next\n *   Callback.\n * @returns {(\n *   Promise<Output | undefined | void> |\n *   Promise<never> | // For some reason this is needed separately.\n *   Output |\n *   Error |\n *   undefined |\n *   void\n * )}\n *   If you accept `next`, nothing.\n *   Otherwise:\n *\n *   *   `Error` — fatal error to stop the process\n *   *   `Promise<undefined>` or `undefined` — the next transformer keeps using\n *       same tree\n *   *   `Promise<Node>` or `Node` — new, changed, tree\n */\n\n/**\n * @template {Node | undefined} ParseTree\n *   Output of `parse`.\n * @template {Node | undefined} HeadTree\n *   Input for `run`.\n * @template {Node | undefined} TailTree\n *   Output for `run`.\n * @template {Node | undefined} CompileTree\n *   Input of `stringify`.\n * @template {CompileResults | undefined} CompileResult\n *   Output of `stringify`.\n * @template {Node | string | undefined} Input\n *   Input of plugin.\n * @template Output\n *   Output of plugin (optional).\n * @typedef {(\n *   Input extends string\n *     ? Output extends Node | undefined\n *       ? // Parser.\n *         Processor<\n *           Output extends undefined ? ParseTree : Output,\n *           HeadTree,\n *           TailTree,\n *           CompileTree,\n *           CompileResult\n *         >\n *       : // Unknown.\n *         Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>\n *     : Output extends CompileResults\n *     ? Input extends Node | undefined\n *       ? // Compiler.\n *         Processor<\n *           ParseTree,\n *           HeadTree,\n *           TailTree,\n *           Input extends undefined ? CompileTree : Input,\n *           Output extends undefined ? CompileResult : Output\n *         >\n *       : // Unknown.\n *         Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>\n *     : Input extends Node | undefined\n *     ? Output extends Node | undefined\n *       ? // Transform.\n *         Processor<\n *           ParseTree,\n *           HeadTree extends undefined ? Input : HeadTree,\n *           Output extends undefined ? TailTree : Output,\n *           CompileTree,\n *           CompileResult\n *         >\n *       : // Unknown.\n *         Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>\n *     : // Unknown.\n *       Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>\n * )} UsePlugin\n *   Create a processor based on the input/output of a {@link Plugin plugin}.\n */\n\n/**\n * @template {CompileResults | undefined} Result\n *   Node type that the transformer yields.\n * @typedef {(\n *   Result extends Value | undefined ?\n *     VFile :\n *     VFile & {result: Result}\n *   )} VFileWithOutput\n *   Type to generate a {@link VFile `VFile`} corresponding to a compiler result.\n *\n *   If a result that is not acceptable on a `VFile` is used, that will\n *   be stored on the `result` field of {@link VFile `VFile`}.\n */\n\nimport {bail} from 'bail'\nimport extend from 'extend'\nimport {ok as assert} from 'devlop'\nimport isPlainObj from 'is-plain-obj'\nimport {trough} from 'trough'\nimport {VFile} from 'vfile'\nimport {CallableInstance} from './callable-instance.js'\n\n// To do: next major: drop `Compiler`, `Parser`: prefer lowercase.\n\n// To do: we could start yielding `never` in TS when a parser is missing and\n// `parse` is called.\n// Currently, we allow directly setting `processor.parser`, which is untyped.\n\nconst own = {}.hasOwnProperty\n\n/**\n * @template {Node | undefined} [ParseTree=undefined]\n *   Output of `parse` (optional).\n * @template {Node | undefined} [HeadTree=undefined]\n *   Input for `run` (optional).\n * @template {Node | undefined} [TailTree=undefined]\n *   Output for `run` (optional).\n * @template {Node | undefined} [CompileTree=undefined]\n *   Input of `stringify` (optional).\n * @template {CompileResults | undefined} [CompileResult=undefined]\n *   Output of `stringify` (optional).\n * @extends {CallableInstance<[], Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>>}\n */\nexport class Processor extends CallableInstance {\n  /**\n   * Create a processor.\n   */\n  constructor() {\n    // If `Processor()` is called (w/o new), `copy` is called instead.\n    super('copy')\n\n    /**\n     * Compiler to use (deprecated).\n     *\n     * @deprecated\n     *   Use `compiler` instead.\n     * @type {(\n     *   Compiler<\n     *     CompileTree extends undefined ? Node : CompileTree,\n     *     CompileResult extends undefined ? CompileResults : CompileResult\n     *   > |\n     *   undefined\n     * )}\n     */\n    this.Compiler = undefined\n\n    /**\n     * Parser to use (deprecated).\n     *\n     * @deprecated\n     *   Use `parser` instead.\n     * @type {(\n     *   Parser<ParseTree extends undefined ? Node : ParseTree> |\n     *   undefined\n     * )}\n     */\n    this.Parser = undefined\n\n    // Note: the following fields are considered private.\n    // However, they are needed for tests, and TSC generates an untyped\n    // `private freezeIndex` field for, which trips `type-coverage` up.\n    // Instead, we use `@deprecated` to visualize that they shouldn’t be used.\n    /**\n     * Internal list of configured plugins.\n     *\n     * @deprecated\n     *   This is a private internal property and should not be used.\n     * @type {Array<PluginTuple<Array<unknown>>>}\n     */\n    this.attachers = []\n\n    /**\n     * Compiler to use.\n     *\n     * @type {(\n     *   Compiler<\n     *     CompileTree extends undefined ? Node : CompileTree,\n     *     CompileResult extends undefined ? CompileResults : CompileResult\n     *   > |\n     *   undefined\n     * )}\n     */\n    this.compiler = undefined\n\n    /**\n     * Internal state to track where we are while freezing.\n     *\n     * @deprecated\n     *   This is a private internal property and should not be used.\n     * @type {number}\n     */\n    this.freezeIndex = -1\n\n    /**\n     * Internal state to track whether we’re frozen.\n     *\n     * @deprecated\n     *   This is a private internal property and should not be used.\n     * @type {boolean | undefined}\n     */\n    this.frozen = undefined\n\n    /**\n     * Internal state.\n     *\n     * @deprecated\n     *   This is a private internal property and should not be used.\n     * @type {Data}\n     */\n    this.namespace = {}\n\n    /**\n     * Parser to use.\n     *\n     * @type {(\n     *   Parser<ParseTree extends undefined ? Node : ParseTree> |\n     *   undefined\n     * )}\n     */\n    this.parser = undefined\n\n    /**\n     * Internal list of configured transformers.\n     *\n     * @deprecated\n     *   This is a private internal property and should not be used.\n     * @type {Pipeline}\n     */\n    this.transformers = trough()\n  }\n\n  /**\n   * Copy a processor.\n   *\n   * @deprecated\n   *   This is a private internal method and should not be used.\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *   New *unfrozen* processor ({@link Processor `Processor`}) that is\n   *   configured to work the same as its ancestor.\n   *   When the descendant processor is configured in the future it does not\n   *   affect the ancestral processor.\n   */\n  copy() {\n    // Cast as the type parameters will be the same after attaching.\n    const destination =\n      /** @type {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>} */ (\n        new Processor()\n      )\n    let index = -1\n\n    while (++index < this.attachers.length) {\n      const attacher = this.attachers[index]\n      destination.use(...attacher)\n    }\n\n    destination.data(extend(true, {}, this.namespace))\n\n    return destination\n  }\n\n  /**\n   * Configure the processor with info available to all plugins.\n   * Information is stored in an object.\n   *\n   * Typically, options can be given to a specific plugin, but sometimes it\n   * makes sense to have information shared with several plugins.\n   * For example, a list of HTML elements that are self-closing, which is\n   * needed during all phases.\n   *\n   * > 👉 **Note**: setting information cannot occur on *frozen* processors.\n   * > Call the processor first to create a new unfrozen processor.\n   *\n   * > 👉 **Note**: to register custom data in TypeScript, augment the\n   * > {@link Data `Data`} interface.\n   *\n   * @example\n   *   This example show how to get and set info:\n   *\n   *   ```js\n   *   import {unified} from 'unified'\n   *\n   *   const processor = unified().data('alpha', 'bravo')\n   *\n   *   processor.data('alpha') // => 'bravo'\n   *\n   *   processor.data() // => {alpha: 'bravo'}\n   *\n   *   processor.data({charlie: 'delta'})\n   *\n   *   processor.data() // => {charlie: 'delta'}\n   *   ```\n   *\n   * @template {keyof Data} Key\n   *\n   * @overload\n   * @returns {Data}\n   *\n   * @overload\n   * @param {Data} dataset\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *\n   * @overload\n   * @param {Key} key\n   * @returns {Data[Key]}\n   *\n   * @overload\n   * @param {Key} key\n   * @param {Data[Key]} value\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *\n   * @param {Data | Key} [key]\n   *   Key to get or set, or entire dataset to set, or nothing to get the\n   *   entire dataset (optional).\n   * @param {Data[Key]} [value]\n   *   Value to set (optional).\n   * @returns {unknown}\n   *   The current processor when setting, the value at `key` when getting, or\n   *   the entire dataset when getting without key.\n   */\n  data(key, value) {\n    if (typeof key === 'string') {\n      // Set `key`.\n      if (arguments.length === 2) {\n        assertUnfrozen('data', this.frozen)\n        this.namespace[key] = value\n        return this\n      }\n\n      // Get `key`.\n      return (own.call(this.namespace, key) && this.namespace[key]) || undefined\n    }\n\n    // Set space.\n    if (key) {\n      assertUnfrozen('data', this.frozen)\n      this.namespace = key\n      return this\n    }\n\n    // Get space.\n    return this.namespace\n  }\n\n  /**\n   * Freeze a processor.\n   *\n   * Frozen processors are meant to be extended and not to be configured\n   * directly.\n   *\n   * When a processor is frozen it cannot be unfrozen.\n   * New processors working the same way can be created by calling the\n   * processor.\n   *\n   * It’s possible to freeze processors explicitly by calling `.freeze()`.\n   * Processors freeze automatically when `.parse()`, `.run()`, `.runSync()`,\n   * `.stringify()`, `.process()`, or `.processSync()` are called.\n   *\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *   The current processor.\n   */\n  freeze() {\n    if (this.frozen) {\n      return this\n    }\n\n    // Cast so that we can type plugins easier.\n    // Plugins are supposed to be usable on different processors, not just on\n    // this exact processor.\n    const self = /** @type {Processor} */ (/** @type {unknown} */ (this))\n\n    while (++this.freezeIndex < this.attachers.length) {\n      const [attacher, ...options] = this.attachers[this.freezeIndex]\n\n      if (options[0] === false) {\n        continue\n      }\n\n      if (options[0] === true) {\n        options[0] = undefined\n      }\n\n      const transformer = attacher.call(self, ...options)\n\n      if (typeof transformer === 'function') {\n        this.transformers.use(transformer)\n      }\n    }\n\n    this.frozen = true\n    this.freezeIndex = Number.POSITIVE_INFINITY\n\n    return this\n  }\n\n  /**\n   * Parse text to a syntax tree.\n   *\n   * > 👉 **Note**: `parse` freezes the processor if not already *frozen*.\n   *\n   * > 👉 **Note**: `parse` performs the parse phase, not the run phase or other\n   * > phases.\n   *\n   * @param {Compatible | undefined} [file]\n   *   file to parse (optional); typically `string` or `VFile`; any value\n   *   accepted as `x` in `new VFile(x)`.\n   * @returns {ParseTree extends undefined ? Node : ParseTree}\n   *   Syntax tree representing `file`.\n   */\n  parse(file) {\n    this.freeze()\n    const realFile = vfile(file)\n    const parser = this.parser || this.Parser\n    assertParser('parse', parser)\n    return parser(String(realFile), realFile)\n  }\n\n  /**\n   * Process the given file as configured on the processor.\n   *\n   * > 👉 **Note**: `process` freezes the processor if not already *frozen*.\n   *\n   * > 👉 **Note**: `process` performs the parse, run, and stringify phases.\n   *\n   * @overload\n   * @param {Compatible | undefined} file\n   * @param {ProcessCallback<VFileWithOutput<CompileResult>>} done\n   * @returns {undefined}\n   *\n   * @overload\n   * @param {Compatible | undefined} [file]\n   * @returns {Promise<VFileWithOutput<CompileResult>>}\n   *\n   * @param {Compatible | undefined} [file]\n   *   File (optional); typically `string` or `VFile`]; any value accepted as\n   *   `x` in `new VFile(x)`.\n   * @param {ProcessCallback<VFileWithOutput<CompileResult>> | undefined} [done]\n   *   Callback (optional).\n   * @returns {Promise<VFile> | undefined}\n   *   Nothing if `done` is given.\n   *   Otherwise a promise, rejected with a fatal error or resolved with the\n   *   processed file.\n   *\n   *   The parsed, transformed, and compiled value is available at\n   *   `file.value` (see note).\n   *\n   *   > 👉 **Note**: unified typically compiles by serializing: most\n   *   > compilers return `string` (or `Uint8Array`).\n   *   > Some compilers, such as the one configured with\n   *   > [`rehype-react`][rehype-react], return other values (in this case, a\n   *   > React tree).\n   *   > If you’re using a compiler that doesn’t serialize, expect different\n   *   > result values.\n   *   >\n   *   > To register custom results in TypeScript, add them to\n   *   > {@link CompileResultMap `CompileResultMap`}.\n   *\n   *   [rehype-react]: https://github.com/rehypejs/rehype-react\n   */\n  process(file, done) {\n    const self = this\n\n    this.freeze()\n    assertParser('process', this.parser || this.Parser)\n    assertCompiler('process', this.compiler || this.Compiler)\n\n    return done ? executor(undefined, done) : new Promise(executor)\n\n    // Note: `void`s needed for TS.\n    /**\n     * @param {((file: VFileWithOutput<CompileResult>) => undefined | void) | undefined} resolve\n     * @param {(error: Error | undefined) => undefined | void} reject\n     * @returns {undefined}\n     */\n    function executor(resolve, reject) {\n      const realFile = vfile(file)\n      // Assume `ParseTree` (the result of the parser) matches `HeadTree` (the\n      // input of the first transform).\n      const parseTree =\n        /** @type {HeadTree extends undefined ? Node : HeadTree} */ (\n          /** @type {unknown} */ (self.parse(realFile))\n        )\n\n      self.run(parseTree, realFile, function (error, tree, file) {\n        if (error || !tree || !file) {\n          return realDone(error)\n        }\n\n        // Assume `TailTree` (the output of the last transform) matches\n        // `CompileTree` (the input of the compiler).\n        const compileTree =\n          /** @type {CompileTree extends undefined ? Node : CompileTree} */ (\n            /** @type {unknown} */ (tree)\n          )\n\n        const compileResult = self.stringify(compileTree, file)\n\n        if (looksLikeAValue(compileResult)) {\n          file.value = compileResult\n        } else {\n          file.result = compileResult\n        }\n\n        realDone(error, /** @type {VFileWithOutput<CompileResult>} */ (file))\n      })\n\n      /**\n       * @param {Error | undefined} error\n       * @param {VFileWithOutput<CompileResult> | undefined} [file]\n       * @returns {undefined}\n       */\n      function realDone(error, file) {\n        if (error || !file) {\n          reject(error)\n        } else if (resolve) {\n          resolve(file)\n        } else {\n          assert(done, '`done` is defined if `resolve` is not')\n          done(undefined, file)\n        }\n      }\n    }\n  }\n\n  /**\n   * Process the given file as configured on the processor.\n   *\n   * An error is thrown if asynchronous transforms are configured.\n   *\n   * > 👉 **Note**: `processSync` freezes the processor if not already *frozen*.\n   *\n   * > 👉 **Note**: `processSync` performs the parse, run, and stringify phases.\n   *\n   * @param {Compatible | undefined} [file]\n   *   File (optional); typically `string` or `VFile`; any value accepted as\n   *   `x` in `new VFile(x)`.\n   * @returns {VFileWithOutput<CompileResult>}\n   *   The processed file.\n   *\n   *   The parsed, transformed, and compiled value is available at\n   *   `file.value` (see note).\n   *\n   *   > 👉 **Note**: unified typically compiles by serializing: most\n   *   > compilers return `string` (or `Uint8Array`).\n   *   > Some compilers, such as the one configured with\n   *   > [`rehype-react`][rehype-react], return other values (in this case, a\n   *   > React tree).\n   *   > If you’re using a compiler that doesn’t serialize, expect different\n   *   > result values.\n   *   >\n   *   > To register custom results in TypeScript, add them to\n   *   > {@link CompileResultMap `CompileResultMap`}.\n   *\n   *   [rehype-react]: https://github.com/rehypejs/rehype-react\n   */\n  processSync(file) {\n    /** @type {boolean} */\n    let complete = false\n    /** @type {VFileWithOutput<CompileResult> | undefined} */\n    let result\n\n    this.freeze()\n    assertParser('processSync', this.parser || this.Parser)\n    assertCompiler('processSync', this.compiler || this.Compiler)\n\n    this.process(file, realDone)\n    assertDone('processSync', 'process', complete)\n    assert(result, 'we either bailed on an error or have a tree')\n\n    return result\n\n    /**\n     * @type {ProcessCallback<VFileWithOutput<CompileResult>>}\n     */\n    function realDone(error, file) {\n      complete = true\n      bail(error)\n      result = file\n    }\n  }\n\n  /**\n   * Run *transformers* on a syntax tree.\n   *\n   * > 👉 **Note**: `run` freezes the processor if not already *frozen*.\n   *\n   * > 👉 **Note**: `run` performs the run phase, not other phases.\n   *\n   * @overload\n   * @param {HeadTree extends undefined ? Node : HeadTree} tree\n   * @param {RunCallback<TailTree extends undefined ? Node : TailTree>} done\n   * @returns {undefined}\n   *\n   * @overload\n   * @param {HeadTree extends undefined ? Node : HeadTree} tree\n   * @param {Compatible | undefined} file\n   * @param {RunCallback<TailTree extends undefined ? Node : TailTree>} done\n   * @returns {undefined}\n   *\n   * @overload\n   * @param {HeadTree extends undefined ? Node : HeadTree} tree\n   * @param {Compatible | undefined} [file]\n   * @returns {Promise<TailTree extends undefined ? Node : TailTree>}\n   *\n   * @param {HeadTree extends undefined ? Node : HeadTree} tree\n   *   Tree to transform and inspect.\n   * @param {(\n   *   RunCallback<TailTree extends undefined ? Node : TailTree> |\n   *   Compatible\n   * )} [file]\n   *   File associated with `node` (optional); any value accepted as `x` in\n   *   `new VFile(x)`.\n   * @param {RunCallback<TailTree extends undefined ? Node : TailTree>} [done]\n   *   Callback (optional).\n   * @returns {Promise<TailTree extends undefined ? Node : TailTree> | undefined}\n   *   Nothing if `done` is given.\n   *   Otherwise, a promise rejected with a fatal error or resolved with the\n   *   transformed tree.\n   */\n  run(tree, file, done) {\n    assertNode(tree)\n    this.freeze()\n\n    const transformers = this.transformers\n\n    if (!done && typeof file === 'function') {\n      done = file\n      file = undefined\n    }\n\n    return done ? executor(undefined, done) : new Promise(executor)\n\n    // Note: `void`s needed for TS.\n    /**\n     * @param {(\n     *   ((tree: TailTree extends undefined ? Node : TailTree) => undefined | void) |\n     *   undefined\n     * )} resolve\n     * @param {(error: Error) => undefined | void} reject\n     * @returns {undefined}\n     */\n    function executor(resolve, reject) {\n      assert(\n        typeof file !== 'function',\n        '`file` can’t be a `done` anymore, we checked'\n      )\n      const realFile = vfile(file)\n      transformers.run(tree, realFile, realDone)\n\n      /**\n       * @param {Error | undefined} error\n       * @param {Node} outputTree\n       * @param {VFile} file\n       * @returns {undefined}\n       */\n      function realDone(error, outputTree, file) {\n        const resultingTree =\n          /** @type {TailTree extends undefined ? Node : TailTree} */ (\n            outputTree || tree\n          )\n\n        if (error) {\n          reject(error)\n        } else if (resolve) {\n          resolve(resultingTree)\n        } else {\n          assert(done, '`done` is defined if `resolve` is not')\n          done(undefined, resultingTree, file)\n        }\n      }\n    }\n  }\n\n  /**\n   * Run *transformers* on a syntax tree.\n   *\n   * An error is thrown if asynchronous transforms are configured.\n   *\n   * > 👉 **Note**: `runSync` freezes the processor if not already *frozen*.\n   *\n   * > 👉 **Note**: `runSync` performs the run phase, not other phases.\n   *\n   * @param {HeadTree extends undefined ? Node : HeadTree} tree\n   *   Tree to transform and inspect.\n   * @param {Compatible | undefined} [file]\n   *   File associated with `node` (optional); any value accepted as `x` in\n   *   `new VFile(x)`.\n   * @returns {TailTree extends undefined ? Node : TailTree}\n   *   Transformed tree.\n   */\n  runSync(tree, file) {\n    /** @type {boolean} */\n    let complete = false\n    /** @type {(TailTree extends undefined ? Node : TailTree) | undefined} */\n    let result\n\n    this.run(tree, file, realDone)\n\n    assertDone('runSync', 'run', complete)\n    assert(result, 'we either bailed on an error or have a tree')\n    return result\n\n    /**\n     * @type {RunCallback<TailTree extends undefined ? Node : TailTree>}\n     */\n    function realDone(error, tree) {\n      bail(error)\n      result = tree\n      complete = true\n    }\n  }\n\n  /**\n   * Compile a syntax tree.\n   *\n   * > 👉 **Note**: `stringify` freezes the processor if not already *frozen*.\n   *\n   * > 👉 **Note**: `stringify` performs the stringify phase, not the run phase\n   * > or other phases.\n   *\n   * @param {CompileTree extends undefined ? Node : CompileTree} tree\n   *   Tree to compile.\n   * @param {Compatible | undefined} [file]\n   *   File associated with `node` (optional); any value accepted as `x` in\n   *   `new VFile(x)`.\n   * @returns {CompileResult extends undefined ? Value : CompileResult}\n   *   Textual representation of the tree (see note).\n   *\n   *   > 👉 **Note**: unified typically compiles by serializing: most compilers\n   *   > return `string` (or `Uint8Array`).\n   *   > Some compilers, such as the one configured with\n   *   > [`rehype-react`][rehype-react], return other values (in this case, a\n   *   > React tree).\n   *   > If you’re using a compiler that doesn’t serialize, expect different\n   *   > result values.\n   *   >\n   *   > To register custom results in TypeScript, add them to\n   *   > {@link CompileResultMap `CompileResultMap`}.\n   *\n   *   [rehype-react]: https://github.com/rehypejs/rehype-react\n   */\n  stringify(tree, file) {\n    this.freeze()\n    const realFile = vfile(file)\n    const compiler = this.compiler || this.Compiler\n    assertCompiler('stringify', compiler)\n    assertNode(tree)\n\n    return compiler(tree, realFile)\n  }\n\n  /**\n   * Configure the processor to use a plugin, a list of usable values, or a\n   * preset.\n   *\n   * If the processor is already using a plugin, the previous plugin\n   * configuration is changed based on the options that are passed in.\n   * In other words, the plugin is not added a second time.\n   *\n   * > 👉 **Note**: `use` cannot be called on *frozen* processors.\n   * > Call the processor first to create a new unfrozen processor.\n   *\n   * @example\n   *   There are many ways to pass plugins to `.use()`.\n   *   This example gives an overview:\n   *\n   *   ```js\n   *   import {unified} from 'unified'\n   *\n   *   unified()\n   *     // Plugin with options:\n   *     .use(pluginA, {x: true, y: true})\n   *     // Passing the same plugin again merges configuration (to `{x: true, y: false, z: true}`):\n   *     .use(pluginA, {y: false, z: true})\n   *     // Plugins:\n   *     .use([pluginB, pluginC])\n   *     // Two plugins, the second with options:\n   *     .use([pluginD, [pluginE, {}]])\n   *     // Preset with plugins and settings:\n   *     .use({plugins: [pluginF, [pluginG, {}]], settings: {position: false}})\n   *     // Settings only:\n   *     .use({settings: {position: false}})\n   *   ```\n   *\n   * @template {Array<unknown>} [Parameters=[]]\n   * @template {Node | string | undefined} [Input=undefined]\n   * @template [Output=Input]\n   *\n   * @overload\n   * @param {Preset | null | undefined} [preset]\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *\n   * @overload\n   * @param {PluggableList} list\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *\n   * @overload\n   * @param {Plugin<Parameters, Input, Output>} plugin\n   * @param {...(Parameters | [boolean])} parameters\n   * @returns {UsePlugin<ParseTree, HeadTree, TailTree, CompileTree, CompileResult, Input, Output>}\n   *\n   * @param {PluggableList | Plugin | Preset | null | undefined} value\n   *   Usable value.\n   * @param {...unknown} parameters\n   *   Parameters, when a plugin is given as a usable value.\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *   Current processor.\n   */\n  use(value, ...parameters) {\n    const attachers = this.attachers\n    const namespace = this.namespace\n\n    assertUnfrozen('use', this.frozen)\n\n    if (value === null || value === undefined) {\n      // Empty.\n    } else if (typeof value === 'function') {\n      addPlugin(value, parameters)\n    } else if (typeof value === 'object') {\n      if (Array.isArray(value)) {\n        addList(value)\n      } else {\n        addPreset(value)\n      }\n    } else {\n      throw new TypeError('Expected usable value, not `' + value + '`')\n    }\n\n    return this\n\n    /**\n     * @param {Pluggable} value\n     * @returns {undefined}\n     */\n    function add(value) {\n      if (typeof value === 'function') {\n        addPlugin(value, [])\n      } else if (typeof value === 'object') {\n        if (Array.isArray(value)) {\n          const [plugin, ...parameters] =\n            /** @type {PluginTuple<Array<unknown>>} */ (value)\n          addPlugin(plugin, parameters)\n        } else {\n          addPreset(value)\n        }\n      } else {\n        throw new TypeError('Expected usable value, not `' + value + '`')\n      }\n    }\n\n    /**\n     * @param {Preset} result\n     * @returns {undefined}\n     */\n    function addPreset(result) {\n      if (!('plugins' in result) && !('settings' in result)) {\n        throw new Error(\n          'Expected usable value but received an empty preset, which is probably a mistake: presets typically come with `plugins` and sometimes with `settings`, but this has neither'\n        )\n      }\n\n      addList(result.plugins)\n\n      if (result.settings) {\n        namespace.settings = extend(true, namespace.settings, result.settings)\n      }\n    }\n\n    /**\n     * @param {PluggableList | null | undefined} plugins\n     * @returns {undefined}\n     */\n    function addList(plugins) {\n      let index = -1\n\n      if (plugins === null || plugins === undefined) {\n        // Empty.\n      } else if (Array.isArray(plugins)) {\n        while (++index < plugins.length) {\n          const thing = plugins[index]\n          add(thing)\n        }\n      } else {\n        throw new TypeError('Expected a list of plugins, not `' + plugins + '`')\n      }\n    }\n\n    /**\n     * @param {Plugin} plugin\n     * @param {Array<unknown>} parameters\n     * @returns {undefined}\n     */\n    function addPlugin(plugin, parameters) {\n      let index = -1\n      let entryIndex = -1\n\n      while (++index < attachers.length) {\n        if (attachers[index][0] === plugin) {\n          entryIndex = index\n          break\n        }\n      }\n\n      if (entryIndex === -1) {\n        attachers.push([plugin, ...parameters])\n      }\n      // Only set if there was at least a `primary` value, otherwise we’d change\n      // `arguments.length`.\n      else if (parameters.length > 0) {\n        let [primary, ...rest] = parameters\n        const currentPrimary = attachers[entryIndex][1]\n        if (isPlainObj(currentPrimary) && isPlainObj(primary)) {\n          primary = extend(true, currentPrimary, primary)\n        }\n\n        attachers[entryIndex] = [plugin, primary, ...rest]\n      }\n    }\n  }\n}\n\n// Note: this returns a *callable* instance.\n// That’s why it’s documented as a function.\n/**\n * Create a new processor.\n *\n * @example\n *   This example shows how a new processor can be created (from `remark`) and linked\n *   to **stdin**(4) and **stdout**(4).\n *\n *   ```js\n *   import process from 'node:process'\n *   import concatStream from 'concat-stream'\n *   import {remark} from 'remark'\n *\n *   process.stdin.pipe(\n *     concatStream(function (buf) {\n *       process.stdout.write(String(remark().processSync(buf)))\n *     })\n *   )\n *   ```\n *\n * @returns\n *   New *unfrozen* processor (`processor`).\n *\n *   This processor is configured to work the same as its ancestor.\n *   When the descendant processor is configured in the future it does not\n *   affect the ancestral processor.\n */\nexport const unified = new Processor().freeze()\n\n/**\n * Assert a parser is available.\n *\n * @param {string} name\n * @param {unknown} value\n * @returns {asserts value is Parser}\n */\nfunction assertParser(name, value) {\n  if (typeof value !== 'function') {\n    throw new TypeError('Cannot `' + name + '` without `parser`')\n  }\n}\n\n/**\n * Assert a compiler is available.\n *\n * @param {string} name\n * @param {unknown} value\n * @returns {asserts value is Compiler}\n */\nfunction assertCompiler(name, value) {\n  if (typeof value !== 'function') {\n    throw new TypeError('Cannot `' + name + '` without `compiler`')\n  }\n}\n\n/**\n * Assert the processor is not frozen.\n *\n * @param {string} name\n * @param {unknown} frozen\n * @returns {asserts frozen is false}\n */\nfunction assertUnfrozen(name, frozen) {\n  if (frozen) {\n    throw new Error(\n      'Cannot call `' +\n        name +\n        '` on a frozen processor.\\nCreate a new processor first, by calling it: use `processor()` instead of `processor`.'\n    )\n  }\n}\n\n/**\n * Assert `node` is a unist node.\n *\n * @param {unknown} node\n * @returns {asserts node is Node}\n */\nfunction assertNode(node) {\n  // `isPlainObj` unfortunately uses `any` instead of `unknown`.\n  // type-coverage:ignore-next-line\n  if (!isPlainObj(node) || typeof node.type !== 'string') {\n    throw new TypeError('Expected node, got `' + node + '`')\n    // Fine.\n  }\n}\n\n/**\n * Assert that `complete` is `true`.\n *\n * @param {string} name\n * @param {string} asyncName\n * @param {unknown} complete\n * @returns {asserts complete is true}\n */\nfunction assertDone(name, asyncName, complete) {\n  if (!complete) {\n    throw new Error(\n      '`' + name + '` finished async. Use `' + asyncName + '` instead'\n    )\n  }\n}\n\n/**\n * @param {Compatible | undefined} [value]\n * @returns {VFile}\n */\nfunction vfile(value) {\n  return looksLikeAVFile(value) ? value : new VFile(value)\n}\n\n/**\n * @param {Compatible | undefined} [value]\n * @returns {value is VFile}\n */\nfunction looksLikeAVFile(value) {\n  return Boolean(\n    value &&\n      typeof value === 'object' &&\n      'message' in value &&\n      'messages' in value\n  )\n}\n\n/**\n * @param {unknown} [value]\n * @returns {value is Value}\n */\nfunction looksLikeAValue(value) {\n  return typeof value === 'string' || isUint8Array(value)\n}\n\n/**\n * Assert `value` is an `Uint8Array`.\n *\n * @param {unknown} value\n *   thing.\n * @returns {value is Uint8Array}\n *   Whether `value` is an `Uint8Array`.\n */\nfunction isUint8Array(value) {\n  return Boolean(\n    value &&\n      typeof value === 'object' &&\n      'byteLength' in value &&\n      'byteOffset' in value\n  )\n}\n"],"names":["bail","extend","ok","assert","isPlainObj","trough","VFile","CallableInstance","own","hasOwnProperty","Processor","constructor","Compiler","undefined","Parser","attachers","compiler","freezeIndex","frozen","namespace","parser","transformers","copy","destination","index","length","attacher","use","data","key","value","arguments","assertUnfrozen","call","freeze","self","options","transformer","Number","POSITIVE_INFINITY","parse","file","realFile","vfile","assertParser","String","process","done","assertCompiler","executor","Promise","resolve","reject","parseTree","run","error","tree","realDone","compileTree","compileResult","stringify","looksLikeAValue","result","processSync","complete","assertDone","assertNode","outputTree","resultingTree","runSync","parameters","addPlugin","Array","isArray","addList","addPreset","TypeError","add","plugin","Error","plugins","settings","thing","entryIndex","push","primary","rest","currentPrimary","unified","name","node","type","asyncName","looksLikeAVFile","Boolean","isUint8Array"],"sourceRoot":""}\n//# sourceURL=webpack-internal:///(ssr)/./node_modules/unified/lib/index.js\n");

/***/ }),

/***/ "(ssr)/./node_modules/unified/node_modules/is-plain-obj/index.js":
/*!*****************************************************************!*\
  !*** ./node_modules/unified/node_modules/is-plain-obj/index.js ***!
  \*****************************************************************/
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {

eval("__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\n/* harmony export */   \"default\": () => (/* binding */ isPlainObject)\n/* harmony export */ });\nfunction isPlainObject(value) {\n    if (typeof value !== \"object\" || value === null) {\n        return false;\n    }\n    const prototype = Object.getPrototypeOf(value);\n    return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);\n}\n//# sourceURL=[module]\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiKHNzcikvLi9ub2RlX21vZHVsZXMvdW5pZmllZC9ub2RlX21vZHVsZXMvaXMtcGxhaW4tb2JqL2luZGV4LmpzIiwibWFwcGluZ3MiOiI7Ozs7QUFBZSxTQUFTQSxjQUFjQyxLQUFLO0lBQzFDLElBQUksT0FBT0EsVUFBVSxZQUFZQSxVQUFVLE1BQU07UUFDaEQsT0FBTztJQUNSO0lBRUEsTUFBTUMsWUFBWUMsT0FBT0MsY0FBYyxDQUFDSDtJQUN4QyxPQUFPLENBQUNDLGNBQWMsUUFBUUEsY0FBY0MsT0FBT0QsU0FBUyxJQUFJQyxPQUFPQyxjQUFjLENBQUNGLGVBQWUsSUFBRyxLQUFNLENBQUVHLENBQUFBLE9BQU9DLFdBQVcsSUFBSUwsS0FBSSxLQUFNLENBQUVJLENBQUFBLE9BQU9FLFFBQVEsSUFBSU4sS0FBSTtBQUMxSyIsInNvdXJjZXMiOlsid2VicGFjazovL2ZsdXNoLW5vdGVzLy4vbm9kZV9tb2R1bGVzL3VuaWZpZWQvbm9kZV9tb2R1bGVzL2lzLXBsYWluLW9iai9pbmRleC5qcz8zZTc2Il0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBkZWZhdWx0IGZ1bmN0aW9uIGlzUGxhaW5PYmplY3QodmFsdWUpIHtcblx0aWYgKHR5cGVvZiB2YWx1ZSAhPT0gJ29iamVjdCcgfHwgdmFsdWUgPT09IG51bGwpIHtcblx0XHRyZXR1cm4gZmFsc2U7XG5cdH1cblxuXHRjb25zdCBwcm90b3R5cGUgPSBPYmplY3QuZ2V0UHJvdG90eXBlT2YodmFsdWUpO1xuXHRyZXR1cm4gKHByb3RvdHlwZSA9PT0gbnVsbCB8fCBwcm90b3R5cGUgPT09IE9iamVjdC5wcm90b3R5cGUgfHwgT2JqZWN0LmdldFByb3RvdHlwZU9mKHByb3RvdHlwZSkgPT09IG51bGwpICYmICEoU3ltYm9sLnRvU3RyaW5nVGFnIGluIHZhbHVlKSAmJiAhKFN5bWJvbC5pdGVyYXRvciBpbiB2YWx1ZSk7XG59XG4iXSwibmFtZXMiOlsiaXNQbGFpbk9iamVjdCIsInZhbHVlIiwicHJvdG90eXBlIiwiT2JqZWN0IiwiZ2V0UHJvdG90eXBlT2YiLCJTeW1ib2wiLCJ0b1N0cmluZ1RhZyIsIml0ZXJhdG9yIl0sInNvdXJjZVJvb3QiOiIifQ==\n//# sourceURL=webpack-internal:///(ssr)/./node_modules/unified/node_modules/is-plain-obj/index.js\n");

/***/ })

};
;