@alivault/pico 0.14.0 → 0.16.1

package/.output/server/_libs/react-markdown+[...].mjs

@@ -1,2316 +0,0 @@
-import { i as __toESM } from "../_runtime.mjs";
-import { $ as require_react, Q as require_jsx_runtime } from "./@base-ui/react+[...].mjs";
-import "./devlop.mjs";
-import { n as VFileMessage, t as toJsxRuntime } from "./hast-util-to-jsx-runtime+[...].mjs";
-import { n as visit } from "./hast-util-raw+[...].mjs";
-import { t as urlAttributes } from "./html-url-attributes.mjs";
-import { t as fromMarkdown } from "./mdast-util-from-markdown+[...].mjs";
-import { t as toHast } from "./mdast-util-to-hast+[...].mjs";
-import { t as bail } from "./bail.mjs";
-import { t as require_extend } from "./extend.mjs";
-import { t as isPlainObject } from "./is-plain-obj.mjs";
-import { fileURLToPath as urlToPath } from "node:url";
-import minpath from "node:path";
-import minproc from "node:process";
-//#region node_modules/.pnpm/remark-parse@11.0.0/node_modules/remark-parse/lib/index.js
-/**
-* @typedef {import('mdast').Root} Root
-* @typedef {import('mdast-util-from-markdown').Options} FromMarkdownOptions
-* @typedef {import('unified').Parser<Root>} Parser
-* @typedef {import('unified').Processor<Root>} Processor
-*/
-/**
-* @typedef {Omit<FromMarkdownOptions, 'extensions' | 'mdastExtensions'>} Options
-*/
-/**
-* Aadd support for parsing from markdown.
-*
-* @param {Readonly<Options> | null | undefined} [options]
-*   Configuration (optional).
-* @returns {undefined}
-*   Nothing.
-*/
-function remarkParse(options) {
-	/** @type {Processor} */
-	const self = this;
-	self.parser = parser;
-	/**
-	* @type {Parser}
-	*/
-	function parser(doc) {
-		return fromMarkdown(doc, {
-			...self.data("settings"),
-			...options,
-			extensions: self.data("micromarkExtensions") || [],
-			mdastExtensions: self.data("fromMarkdownExtensions") || []
-		});
-	}
-}
-//#endregion
-//#region node_modules/.pnpm/remark-rehype@11.1.2/node_modules/remark-rehype/lib/index.js
-/**
-* @import {Root as HastRoot} from 'hast'
-* @import {Root as MdastRoot} from 'mdast'
-* @import {Options as ToHastOptions} from 'mdast-util-to-hast'
-* @import {Processor} from 'unified'
-* @import {VFile} from 'vfile'
-*/
-/**
-* @typedef {Omit<ToHastOptions, 'file'>} Options
-*
-* @callback TransformBridge
-*   Bridge-mode.
-*
-*   Runs the destination with the new hast tree.
-*   Discards result.
-* @param {MdastRoot} tree
-*   Tree.
-* @param {VFile} file
-*   File.
-* @returns {Promise<undefined>}
-*   Nothing.
-*
-* @callback TransformMutate
-*  Mutate-mode.
-*
-*  Further transformers run on the hast tree.
-* @param {MdastRoot} tree
-*   Tree.
-* @param {VFile} file
-*   File.
-* @returns {HastRoot}
-*   Tree (hast).
-*/
-/**
-* Turn markdown into HTML.
-*
-* ##### Notes
-*
-* ###### Signature
-*
-* * if a processor is given,
-*   runs the (rehype) plugins used on it with a hast tree,
-*   then discards the result (*bridge mode*)
-* * otherwise,
-*   returns a hast tree,
-*   the plugins used after `remarkRehype` are rehype plugins (*mutate mode*)
-*
-* > 👉 **Note**:
-* > It’s highly unlikely that you want to pass a `processor`.
-*
-* ###### HTML
-*
-* Raw HTML is available in mdast as `html` nodes and can be embedded in hast
-* as semistandard `raw` nodes.
-* Most plugins ignore `raw` nodes but two notable ones don’t:
-*
-* * `rehype-stringify` also has an option `allowDangerousHtml` which will
-*   output the raw HTML.
-*   This is typically discouraged as noted by the option name but is useful if
-*   you completely trust authors
-* * `rehype-raw` can handle the raw embedded HTML strings by parsing them
-*   into standard hast nodes (`element`, `text`, etc);
-*   this is a heavy task as it needs a full HTML parser,
-*   but it is the only way to support untrusted content
-*
-* ###### Footnotes
-*
-* Many options supported here relate to footnotes.
-* Footnotes are not specified by CommonMark,
-* which we follow by default.
-* They are supported by GitHub,
-* so footnotes can be enabled in markdown with `remark-gfm`.
-*
-* The options `footnoteBackLabel` and `footnoteLabel` define natural language
-* that explains footnotes,
-* which is hidden for sighted users but shown to assistive technology.
-* When your page is not in English,
-* you must define translated values.
-*
-* Back references use ARIA attributes,
-* but the section label itself uses a heading that is hidden with an
-* `sr-only` class.
-* To show it to sighted users,
-* define different attributes in `footnoteLabelProperties`.
-*
-* ###### Clobbering
-*
-* Footnotes introduces a problem,
-* as it links footnote calls to footnote definitions on the page through `id`
-* attributes generated from user content,
-* which results in DOM clobbering.
-*
-* DOM clobbering is this:
-*
-* ```html
-* <p id=x></p>
-* <script>alert(x) // `x` now refers to the DOM `p#x` element<\/script>
-* ```
-*
-* Elements by their ID are made available by browsers on the `window` object,
-* which is a security risk.
-* Using a prefix solves this problem.
-*
-* More information on how to handle clobbering and the prefix is explained in
-* *Example: headings (DOM clobbering)* in `rehype-sanitize`.
-*
-* ###### Unknown nodes
-*
-* Unknown nodes are nodes with a type that isn’t in `handlers` or `passThrough`.
-* The default behavior for unknown nodes is:
-*
-* * when the node has a `value`
-*   (and doesn’t have `data.hName`, `data.hProperties`, or `data.hChildren`,
-*   see later),
-*   create a hast `text` node
-* * otherwise,
-*   create a `<div>` element (which could be changed with `data.hName`),
-*   with its children mapped from mdast to hast as well
-*
-* This behavior can be changed by passing an `unknownHandler`.
-*
-* @overload
-* @param {Processor} processor
-* @param {Readonly<Options> | null | undefined} [options]
-* @returns {TransformBridge}
-*
-* @overload
-* @param {Readonly<Options> | null | undefined} [options]
-* @returns {TransformMutate}
-*
-* @overload
-* @param {Readonly<Options> | Processor | null | undefined} [destination]
-* @param {Readonly<Options> | null | undefined} [options]
-* @returns {TransformBridge | TransformMutate}
-*
-* @param {Readonly<Options> | Processor | null | undefined} [destination]
-*   Processor or configuration (optional).
-* @param {Readonly<Options> | null | undefined} [options]
-*   When a processor was given,
-*   configuration (optional).
-* @returns {TransformBridge | TransformMutate}
-*   Transform.
-*/
-function remarkRehype(destination, options) {
-	if (destination && "run" in destination)
- /**
-	* @type {TransformBridge}
-	*/
-	return async function(tree, file) {
-		const hastTree = toHast(tree, {
-			file,
-			...options
-		});
-		await destination.run(hastTree, file);
-	};
-	/**
-	* @type {TransformMutate}
-	*/
-	return function(tree, file) {
-		return toHast(tree, {
-			file,
-			...destination || options
-		});
-	};
-}
-//#endregion
-//#region node_modules/.pnpm/trough@2.2.0/node_modules/trough/lib/index.js
-/**
-* @typedef {(error?: Error | null | undefined, ...output: Array<any>) => void} Callback
-*   Callback.
-*
-* @typedef {(...input: Array<any>) => any} Middleware
-*   Ware.
-*
-* @typedef Pipeline
-*   Pipeline.
-* @property {Run} run
-*   Run the pipeline.
-* @property {Use} use
-*   Add middleware.
-*
-* @typedef {(...input: Array<any>) => void} Run
-*   Call all middleware.
-*
-*   Calls `done` on completion with either an error or the output of the
-*   last middleware.
-*
-*   > 👉 **Note**: as the length of input defines whether async functions get a
-*   > `next` function,
-*   > it’s recommended to keep `input` at one value normally.
-
-*
-* @typedef {(fn: Middleware) => Pipeline} Use
-*   Add middleware.
-*/
-/**
-* Create new middleware.
-*
-* @returns {Pipeline}
-*   Pipeline.
-*/
-function trough() {
-	/** @type {Array<Middleware>} */
-	const fns = [];
-	/** @type {Pipeline} */
-	const pipeline = {
-		run,
-		use
-	};
-	return pipeline;
-	/** @type {Run} */
-	function run(...values) {
-		let middlewareIndex = -1;
-		/** @type {Callback} */
-		const callback = values.pop();
-		if (typeof callback !== "function") throw new TypeError("Expected function as last argument, not " + callback);
-		next(null, ...values);
-		/**
-		* Run the next `fn`, or we’re done.
-		*
-		* @param {Error | null | undefined} error
-		* @param {Array<any>} output
-		*/
-		function next(error, ...output) {
-			const fn = fns[++middlewareIndex];
-			let index = -1;
-			if (error) {
-				callback(error);
-				return;
-			}
-			while (++index < values.length) if (output[index] === null || output[index] === void 0) output[index] = values[index];
-			values = output;
-			if (fn) wrap(fn, next)(...output);
-			else callback(null, ...output);
-		}
-	}
-	/** @type {Use} */
-	function use(middelware) {
-		if (typeof middelware !== "function") throw new TypeError("Expected `middelware` to be a function, not " + middelware);
-		fns.push(middelware);
-		return pipeline;
-	}
-}
-/**
-* Wrap `middleware` into a uniform interface.
-*
-* You can pass all input to the resulting function.
-* `callback` is then called with the output of `middleware`.
-*
-* If `middleware` accepts more arguments than the later given in input,
-* an extra `done` function is passed to it after that input,
-* which must be called by `middleware`.
-*
-* The first value in `input` is the main input value.
-* All other input values are the rest input values.
-* The values given to `callback` are the input values,
-* merged with every non-nullish output value.
-*
-* * if `middleware` throws an error,
-*   returns a promise that is rejected,
-*   or calls the given `done` function with an error,
-*   `callback` is called with that error
-* * if `middleware` returns a value or returns a promise that is resolved,
-*   that value is the main output value
-* * if `middleware` calls `done`,
-*   all non-nullish values except for the first one (the error) overwrite the
-*   output values
-*
-* @param {Middleware} middleware
-*   Function to wrap.
-* @param {Callback} callback
-*   Callback called with the output of `middleware`.
-* @returns {Run}
-*   Wrapped middleware.
-*/
-function wrap(middleware, callback) {
-	/** @type {boolean} */
-	let called;
-	return wrapped;
-	/**
-	* Call `middleware`.
-	* @this {any}
-	* @param {Array<any>} parameters
-	* @returns {void}
-	*/
-	function wrapped(...parameters) {
-		const fnExpectsCallback = middleware.length > parameters.length;
-		/** @type {any} */
-		let result;
-		if (fnExpectsCallback) parameters.push(done);
-		try {
-			result = middleware.apply(this, parameters);
-		} catch (error) {
-			const exception = error;
-			if (fnExpectsCallback && called) throw exception;
-			return done(exception);
-		}
-		if (!fnExpectsCallback) if (result && result.then && typeof result.then === "function") result.then(then, done);
-		else if (result instanceof Error) done(result);
-		else then(result);
-	}
-	/**
-	* Call `callback`, only once.
-	*
-	* @type {Callback}
-	*/
-	function done(error, ...output) {
-		if (!called) {
-			called = true;
-			callback(error, ...output);
-		}
-	}
-	/**
-	* Call `done` with one value.
-	*
-	* @param {any} [value]
-	*/
-	function then(value) {
-		done(null, value);
-	}
-}
-//#endregion
-//#region node_modules/.pnpm/vfile@6.0.3/node_modules/vfile/lib/minurl.shared.js
-/**
-* Checks if a value has the shape of a WHATWG URL object.
-*
-* Using a symbol or instanceof would not be able to recognize URL objects
-* coming from other implementations (e.g. in Electron), so instead we are
-* checking some well known properties for a lack of a better test.
-*
-* We use `href` and `protocol` as they are the only properties that are
-* easy to retrieve and calculate due to the lazy nature of the getters.
-*
-* We check for auth attribute to distinguish legacy url instance with
-* WHATWG URL instance.
-*
-* @param {unknown} fileUrlOrPath
-*   File path or URL.
-* @returns {fileUrlOrPath is URL}
-*   Whether it’s a URL.
-*/
-function isUrl(fileUrlOrPath) {
-	return Boolean(fileUrlOrPath !== null && typeof fileUrlOrPath === "object" && "href" in fileUrlOrPath && fileUrlOrPath.href && "protocol" in fileUrlOrPath && fileUrlOrPath.protocol && fileUrlOrPath.auth === void 0);
-}
-//#endregion
-//#region node_modules/.pnpm/vfile@6.0.3/node_modules/vfile/lib/index.js
-/**
-* @import {Node, Point, Position} from 'unist'
-* @import {Options as MessageOptions} from 'vfile-message'
-* @import {Compatible, Data, Map, Options, Value} from 'vfile'
-*/
-/**
-* @typedef {object & {type: string, position?: Position | undefined}} NodeLike
-*/
-/**
-* Order of setting (least specific to most), we need this because otherwise
-* `{stem: 'a', path: '~/b.js'}` would throw, as a path is needed before a
-* stem can be set.
-*/
-var order = [
-	"history",
-	"path",
-	"basename",
-	"stem",
-	"extname",
-	"dirname"
-];
-var VFile = class {
-	/**
-	* Create a new virtual file.
-	*
-	* `options` is treated as:
-	*
-	* *   `string` or `Uint8Array` — `{value: options}`
-	* *   `URL` — `{path: options}`
-	* *   `VFile` — shallow copies its data over to the new file
-	* *   `object` — all fields are shallow copied over to the new file
-	*
-	* Path related fields are set in the following order (least specific to
-	* most specific): `history`, `path`, `basename`, `stem`, `extname`,
-	* `dirname`.
-	*
-	* You cannot set `dirname` or `extname` without setting either `history`,
-	* `path`, `basename`, or `stem` too.
-	*
-	* @param {Compatible | null | undefined} [value]
-	*   File value.
-	* @returns
-	*   New instance.
-	*/
-	constructor(value) {
-		/** @type {Options | VFile} */
-		let options;
-		if (!value) options = {};
-		else if (isUrl(value)) options = { path: value };
-		else if (typeof value === "string" || isUint8Array$1(value)) options = { value };
-		else options = value;
-		/**
-		* Base of `path` (default: `process.cwd()` or `'/'` in browsers).
-		*
-		* @type {string}
-		*/
-		this.cwd = "cwd" in options ? "" : minproc.cwd();
-		/**
-		* Place to store custom info (default: `{}`).
-		*
-		* It’s OK to store custom data directly on the file but moving it to
-		* `data` is recommended.
-		*
-		* @type {Data}
-		*/
-		this.data = {};
-		/**
-		* List of file paths the file moved between.
-		*
-		* The first is the original path and the last is the current path.
-		*
-		* @type {Array<string>}
-		*/
-		this.history = [];
-		/**
-		* List of messages associated with the file.
-		*
-		* @type {Array<VFileMessage>}
-		*/
-		this.messages = [];
-		/**
-		* Raw value.
-		*
-		* @type {Value}
-		*/
-		this.value;
-		/**
-		* Source map.
-		*
-		* This type is equivalent to the `RawSourceMap` type from the `source-map`
-		* module.
-		*
-		* @type {Map | null | undefined}
-		*/
-		this.map;
-		/**
-		* Custom, non-string, compiled, representation.
-		*
-		* This is used by unified to store non-string results.
-		* One example is when turning markdown into React nodes.
-		*
-		* @type {unknown}
-		*/
-		this.result;
-		/**
-		* Whether a file was saved to disk.
-		*
-		* This is used by vfile reporters.
-		*
-		* @type {boolean}
-		*/
-		this.stored;
-		let index = -1;
-		while (++index < order.length) {
-			const field = order[index];
-			if (field in options && options[field] !== void 0 && options[field] !== null) this[field] = field === "history" ? [...options[field]] : options[field];
-		}
-		/** @type {string} */
-		let field;
-		for (field in options) if (!order.includes(field)) this[field] = options[field];
-	}
-	/**
-	* Get the basename (including extname) (example: `'index.min.js'`).
-	*
-	* @returns {string | undefined}
-	*   Basename.
-	*/
-	get basename() {
-		return typeof this.path === "string" ? minpath.basename(this.path) : void 0;
-	}
-	/**
-	* Set basename (including extname) (`'index.min.js'`).
-	*
-	* Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'`
-	* on windows).
-	* Cannot be nullified (use `file.path = file.dirname` instead).
-	*
-	* @param {string} basename
-	*   Basename.
-	* @returns {undefined}
-	*   Nothing.
-	*/
-	set basename(basename) {
-		assertNonEmpty(basename, "basename");
-		assertPart(basename, "basename");
-		this.path = minpath.join(this.dirname || "", basename);
-	}
-	/**
-	* Get the parent path (example: `'~'`).
-	*
-	* @returns {string | undefined}
-	*   Dirname.
-	*/
-	get dirname() {
-		return typeof this.path === "string" ? minpath.dirname(this.path) : void 0;
-	}
-	/**
-	* Set the parent path (example: `'~'`).
-	*
-	* Cannot be set if there’s no `path` yet.
-	*
-	* @param {string | undefined} dirname
-	*   Dirname.
-	* @returns {undefined}
-	*   Nothing.
-	*/
-	set dirname(dirname) {
-		assertPath(this.basename, "dirname");
-		this.path = minpath.join(dirname || "", this.basename);
-	}
-	/**
-	* Get the extname (including dot) (example: `'.js'`).
-	*
-	* @returns {string | undefined}
-	*   Extname.
-	*/
-	get extname() {
-		return typeof this.path === "string" ? minpath.extname(this.path) : void 0;
-	}
-	/**
-	* Set the extname (including dot) (example: `'.js'`).
-	*
-	* Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'`
-	* on windows).
-	* Cannot be set if there’s no `path` yet.
-	*
-	* @param {string | undefined} extname
-	*   Extname.
-	* @returns {undefined}
-	*   Nothing.
-	*/
-	set extname(extname) {
-		assertPart(extname, "extname");
-		assertPath(this.dirname, "extname");
-		if (extname) {
-			if (extname.codePointAt(0) !== 46) throw new Error("`extname` must start with `.`");
-			if (extname.includes(".", 1)) throw new Error("`extname` cannot contain multiple dots");
-		}
-		this.path = minpath.join(this.dirname, this.stem + (extname || ""));
-	}
-	/**
-	* Get the full path (example: `'~/index.min.js'`).
-	*
-	* @returns {string}
-	*   Path.
-	*/
-	get path() {
-		return this.history[this.history.length - 1];
-	}
-	/**
-	* Set the full path (example: `'~/index.min.js'`).
-	*
-	* Cannot be nullified.
-	* You can set a file URL (a `URL` object with a `file:` protocol) which will
-	* be turned into a path with `url.fileURLToPath`.
-	*
-	* @param {URL | string} path
-	*   Path.
-	* @returns {undefined}
-	*   Nothing.
-	*/
-	set path(path) {
-		if (isUrl(path)) path = urlToPath(path);
-		assertNonEmpty(path, "path");
-		if (this.path !== path) this.history.push(path);
-	}
-	/**
-	* Get the stem (basename w/o extname) (example: `'index.min'`).
-	*
-	* @returns {string | undefined}
-	*   Stem.
-	*/
-	get stem() {
-		return typeof this.path === "string" ? minpath.basename(this.path, this.extname) : void 0;
-	}
-	/**
-	* Set the stem (basename w/o extname) (example: `'index.min'`).
-	*
-	* Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'`
-	* on windows).
-	* Cannot be nullified (use `file.path = file.dirname` instead).
-	*
-	* @param {string} stem
-	*   Stem.
-	* @returns {undefined}
-	*   Nothing.
-	*/
-	set stem(stem) {
-		assertNonEmpty(stem, "stem");
-		assertPart(stem, "stem");
-		this.path = minpath.join(this.dirname || "", stem + (this.extname || ""));
-	}
-	/**
-	* Create a fatal message for `reason` associated with the file.
-	*
-	* The `fatal` field of the message is set to `true` (error; file not usable)
-	* and the `file` field is set to the current file path.
-	* The message is added to the `messages` field on `file`.
-	*
-	* > 🪦 **Note**: also has obsolete signatures.
-	*
-	* @overload
-	* @param {string} reason
-	* @param {MessageOptions | null | undefined} [options]
-	* @returns {never}
-	*
-	* @overload
-	* @param {string} reason
-	* @param {Node | NodeLike | null | undefined} parent
-	* @param {string | null | undefined} [origin]
-	* @returns {never}
-	*
-	* @overload
-	* @param {string} reason
-	* @param {Point | Position | null | undefined} place
-	* @param {string | null | undefined} [origin]
-	* @returns {never}
-	*
-	* @overload
-	* @param {string} reason
-	* @param {string | null | undefined} [origin]
-	* @returns {never}
-	*
-	* @overload
-	* @param {Error | VFileMessage} cause
-	* @param {Node | NodeLike | null | undefined} parent
-	* @param {string | null | undefined} [origin]
-	* @returns {never}
-	*
-	* @overload
-	* @param {Error | VFileMessage} cause
-	* @param {Point | Position | null | undefined} place
-	* @param {string | null | undefined} [origin]
-	* @returns {never}
-	*
-	* @overload
-	* @param {Error | VFileMessage} cause
-	* @param {string | null | undefined} [origin]
-	* @returns {never}
-	*
-	* @param {Error | VFileMessage | string} causeOrReason
-	*   Reason for message, should use markdown.
-	* @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
-	*   Configuration (optional).
-	* @param {string | null | undefined} [origin]
-	*   Place in code where the message originates (example:
-	*   `'my-package:my-rule'` or `'my-rule'`).
-	* @returns {never}
-	*   Never.
-	* @throws {VFileMessage}
-	*   Message.
-	*/
-	fail(causeOrReason, optionsOrParentOrPlace, origin) {
-		const message = this.message(causeOrReason, optionsOrParentOrPlace, origin);
-		message.fatal = true;
-		throw message;
-	}
-	/**
-	* Create an info message for `reason` associated with the file.
-	*
-	* The `fatal` field of the message is set to `undefined` (info; change
-	* likely not needed) and the `file` field is set to the current file path.
-	* The message is added to the `messages` field on `file`.
-	*
-	* > 🪦 **Note**: also has obsolete signatures.
-	*
-	* @overload
-	* @param {string} reason
-	* @param {MessageOptions | null | undefined} [options]
-	* @returns {VFileMessage}
-	*
-	* @overload
-	* @param {string} reason
-	* @param {Node | NodeLike | null | undefined} parent
-	* @param {string | null | undefined} [origin]
-	* @returns {VFileMessage}
-	*
-	* @overload
-	* @param {string} reason
-	* @param {Point | Position | null | undefined} place
-	* @param {string | null | undefined} [origin]
-	* @returns {VFileMessage}
-	*
-	* @overload
-	* @param {string} reason
-	* @param {string | null | undefined} [origin]
-	* @returns {VFileMessage}
-	*
-	* @overload
-	* @param {Error | VFileMessage} cause
-	* @param {Node | NodeLike | null | undefined} parent
-	* @param {string | null | undefined} [origin]
-	* @returns {VFileMessage}
-	*
-	* @overload
-	* @param {Error | VFileMessage} cause
-	* @param {Point | Position | null | undefined} place
-	* @param {string | null | undefined} [origin]
-	* @returns {VFileMessage}
-	*
-	* @overload
-	* @param {Error | VFileMessage} cause
-	* @param {string | null | undefined} [origin]
-	* @returns {VFileMessage}
-	*
-	* @param {Error | VFileMessage | string} causeOrReason
-	*   Reason for message, should use markdown.
-	* @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
-	*   Configuration (optional).
-	* @param {string | null | undefined} [origin]
-	*   Place in code where the message originates (example:
-	*   `'my-package:my-rule'` or `'my-rule'`).
-	* @returns {VFileMessage}
-	*   Message.
-	*/
-	info(causeOrReason, optionsOrParentOrPlace, origin) {
-		const message = this.message(causeOrReason, optionsOrParentOrPlace, origin);
-		message.fatal = void 0;
-		return message;
-	}
-	/**
-	* Create a message for `reason` associated with the file.
-	*
-	* The `fatal` field of the message is set to `false` (warning; change may be
-	* needed) and the `file` field is set to the current file path.
-	* The message is added to the `messages` field on `file`.
-	*
-	* > 🪦 **Note**: also has obsolete signatures.
-	*
-	* @overload
-	* @param {string} reason
-	* @param {MessageOptions | null | undefined} [options]
-	* @returns {VFileMessage}
-	*
-	* @overload
-	* @param {string} reason
-	* @param {Node | NodeLike | null | undefined} parent
-	* @param {string | null | undefined} [origin]
-	* @returns {VFileMessage}
-	*
-	* @overload
-	* @param {string} reason
-	* @param {Point | Position | null | undefined} place
-	* @param {string | null | undefined} [origin]
-	* @returns {VFileMessage}
-	*
-	* @overload
-	* @param {string} reason
-	* @param {string | null | undefined} [origin]
-	* @returns {VFileMessage}
-	*
-	* @overload
-	* @param {Error | VFileMessage} cause
-	* @param {Node | NodeLike | null | undefined} parent
-	* @param {string | null | undefined} [origin]
-	* @returns {VFileMessage}
-	*
-	* @overload
-	* @param {Error | VFileMessage} cause
-	* @param {Point | Position | null | undefined} place
-	* @param {string | null | undefined} [origin]
-	* @returns {VFileMessage}
-	*
-	* @overload
-	* @param {Error | VFileMessage} cause
-	* @param {string | null | undefined} [origin]
-	* @returns {VFileMessage}
-	*
-	* @param {Error | VFileMessage | string} causeOrReason
-	*   Reason for message, should use markdown.
-	* @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
-	*   Configuration (optional).
-	* @param {string | null | undefined} [origin]
-	*   Place in code where the message originates (example:
-	*   `'my-package:my-rule'` or `'my-rule'`).
-	* @returns {VFileMessage}
-	*   Message.
-	*/
-	message(causeOrReason, optionsOrParentOrPlace, origin) {
-		const message = new VFileMessage(causeOrReason, optionsOrParentOrPlace, origin);
-		if (this.path) {
-			message.name = this.path + ":" + message.name;
-			message.file = this.path;
-		}
-		message.fatal = false;
-		this.messages.push(message);
-		return message;
-	}
-	/**
-	* Serialize the file.
-	*
-	* > **Note**: which encodings are supported depends on the engine.
-	* > For info on Node.js, see:
-	* > <https://nodejs.org/api/util.html#whatwg-supported-encodings>.
-	*
-	* @param {string | null | undefined} [encoding='utf8']
-	*   Character encoding to understand `value` as when it’s a `Uint8Array`
-	*   (default: `'utf-8'`).
-	* @returns {string}
-	*   Serialized file.
-	*/
-	toString(encoding) {
-		if (this.value === void 0) return "";
-		if (typeof this.value === "string") return this.value;
-		return new TextDecoder(encoding || void 0).decode(this.value);
-	}
-};
-/**
-* Assert that `part` is not a path (as in, does not contain `path.sep`).
-*
-* @param {string | null | undefined} part
-*   File path part.
-* @param {string} name
-*   Part name.
-* @returns {undefined}
-*   Nothing.
-*/
-function assertPart(part, name) {
-	if (part && part.includes(minpath.sep)) throw new Error("`" + name + "` cannot be a path: did not expect `" + minpath.sep + "`");
-}
-/**
-* Assert that `part` is not empty.
-*
-* @param {string | undefined} part
-*   Thing.
-* @param {string} name
-*   Part name.
-* @returns {asserts part is string}
-*   Nothing.
-*/
-function assertNonEmpty(part, name) {
-	if (!part) throw new Error("`" + name + "` cannot be empty");
-}
-/**
-* Assert `path` exists.
-*
-* @param {string | undefined} path
-*   Path.
-* @param {string} name
-*   Dependency name.
-* @returns {asserts path is string}
-*   Nothing.
-*/
-function assertPath(path, name) {
-	if (!path) throw new Error("Setting `" + name + "` requires `path` to be set too");
-}
-/**
-* Assert `value` is an `Uint8Array`.
-*
-* @param {unknown} value
-*   thing.
-* @returns {value is Uint8Array}
-*   Whether `value` is an `Uint8Array`.
-*/
-function isUint8Array$1(value) {
-	return Boolean(value && typeof value === "object" && "byteLength" in value && "byteOffset" in value);
-}
-//#endregion
-//#region node_modules/.pnpm/unified@11.0.5/node_modules/unified/lib/callable-instance.js
-var import_extend = /* @__PURE__ */ __toESM(require_extend(), 1);
-var CallableInstance = (function(property) {
-	const proto = this.constructor.prototype;
-	const value = proto[property];
-	/** @type {(...parameters: Array<unknown>) => unknown} */
-	const apply = function() {
-		return value.apply(apply, arguments);
-	};
-	Object.setPrototypeOf(apply, proto);
-	return apply;
-});
-//#endregion
-//#region node_modules/.pnpm/unified@11.0.5/node_modules/unified/lib/index.js
-/**
-* @typedef {import('trough').Pipeline} Pipeline
-*
-* @typedef {import('unist').Node} Node
-*
-* @typedef {import('vfile').Compatible} Compatible
-* @typedef {import('vfile').Value} Value
-*
-* @typedef {import('../index.js').CompileResultMap} CompileResultMap
-* @typedef {import('../index.js').Data} Data
-* @typedef {import('../index.js').Settings} Settings
-*/
-/**
-* @typedef {CompileResultMap[keyof CompileResultMap]} CompileResults
-*   Acceptable results from compilers.
-*
-*   To register custom results, add them to
-*   {@linkcode CompileResultMap}.
-*/
-/**
-* @template {Node} [Tree=Node]
-*   The node that the compiler receives (default: `Node`).
-* @template {CompileResults} [Result=CompileResults]
-*   The thing that the compiler yields (default: `CompileResults`).
-* @callback Compiler
-*   A **compiler** handles the compiling of a syntax tree to something else
-*   (in most cases, text) (TypeScript type).
-*
-*   It is used in the stringify phase and called with a {@linkcode Node}
-*   and {@linkcode VFile} representation of the document to compile.
-*   It should return the textual representation of the given tree (typically
-*   `string`).
-*
-*   > **Note**: unified typically compiles by serializing: most compilers
-*   > return `string` (or `Uint8Array`).
-*   > Some compilers, such as the one configured with
-*   > [`rehype-react`][rehype-react], return other values (in this case, a
-*   > React tree).
-*   > If you’re using a compiler that doesn’t serialize, expect different
-*   > result values.
-*   >
-*   > To register custom results in TypeScript, add them to
-*   > {@linkcode CompileResultMap}.
-*
-*   [rehype-react]: https://github.com/rehypejs/rehype-react
-* @param {Tree} tree
-*   Tree to compile.
-* @param {VFile} file
-*   File associated with `tree`.
-* @returns {Result}
-*   New content: compiled text (`string` or `Uint8Array`, for `file.value`) or
-*   something else (for `file.result`).
-*/
-/**
-* @template {Node} [Tree=Node]
-*   The node that the parser yields (default: `Node`)
-* @callback Parser
-*   A **parser** handles the parsing of text to a syntax tree.
-*
-*   It is used in the parse phase and is called with a `string` and
-*   {@linkcode VFile} of the document to parse.
-*   It must return the syntax tree representation of the given file
-*   ({@linkcode Node}).
-* @param {string} document
-*   Document to parse.
-* @param {VFile} file
-*   File associated with `document`.
-* @returns {Tree}
-*   Node representing the given file.
-*/
-/**
-* @typedef {(
-*   Plugin<Array<any>, any, any> |
-*   PluginTuple<Array<any>, any, any> |
-*   Preset
-* )} Pluggable
-*   Union of the different ways to add plugins and settings.
-*/
-/**
-* @typedef {Array<Pluggable>} PluggableList
-*   List of plugins and presets.
-*/
-/**
-* @template {Array<unknown>} [PluginParameters=[]]
-*   Arguments passed to the plugin (default: `[]`, the empty tuple).
-* @template {Node | string | undefined} [Input=Node]
-*   Value that is expected as input (default: `Node`).
-*
-*   *   If the plugin returns a {@linkcode Transformer}, this
-*       should be the node it expects.
-*   *   If the plugin sets a {@linkcode Parser}, this should be
-*       `string`.
-*   *   If the plugin sets a {@linkcode Compiler}, this should be the
-*       node it expects.
-* @template [Output=Input]
-*   Value that is yielded as output (default: `Input`).
-*
-*   *   If the plugin returns a {@linkcode Transformer}, this
-*       should be the node that that yields.
-*   *   If the plugin sets a {@linkcode Parser}, this should be the
-*       node that it yields.
-*   *   If the plugin sets a {@linkcode Compiler}, this should be
-*       result it yields.
-* @typedef {(
-*   (this: Processor, ...parameters: PluginParameters) =>
-*     Input extends string ? // Parser.
-*        Output extends Node | undefined ? undefined | void : never :
-*     Output extends CompileResults ? // Compiler.
-*        Input extends Node | undefined ? undefined | void : never :
-*     Transformer<
-*       Input extends Node ? Input : Node,
-*       Output extends Node ? Output : Node
-*     > | undefined | void
-* )} Plugin
-*   Single plugin.
-*
-*   Plugins configure the processors they are applied on in the following
-*   ways:
-*
-*   *   they change the processor, such as the parser, the compiler, or by
-*       configuring data
-*   *   they specify how to handle trees and files
-*
-*   In practice, they are functions that can receive options and configure the
-*   processor (`this`).
-*
-*   > **Note**: plugins are called when the processor is *frozen*, not when
-*   > they are applied.
-*/
-/**
-* Tuple of a plugin and its configuration.
-*
-* The first item is a plugin, the rest are its parameters.
-*
-* @template {Array<unknown>} [TupleParameters=[]]
-*   Arguments passed to the plugin (default: `[]`, the empty tuple).
-* @template {Node | string | undefined} [Input=undefined]
-*   Value that is expected as input (optional).
-*
-*   *   If the plugin returns a {@linkcode Transformer}, this
-*       should be the node it expects.
-*   *   If the plugin sets a {@linkcode Parser}, this should be
-*       `string`.
-*   *   If the plugin sets a {@linkcode Compiler}, this should be the
-*       node it expects.
-* @template [Output=undefined] (optional).
-*   Value that is yielded as output.
-*
-*   *   If the plugin returns a {@linkcode Transformer}, this
-*       should be the node that that yields.
-*   *   If the plugin sets a {@linkcode Parser}, this should be the
-*       node that it yields.
-*   *   If the plugin sets a {@linkcode Compiler}, this should be
-*       result it yields.
-* @typedef {(
-*   [
-*     plugin: Plugin<TupleParameters, Input, Output>,
-*     ...parameters: TupleParameters
-*   ]
-* )} PluginTuple
-*/
-/**
-* @typedef Preset
-*   Sharable configuration.
-*
-*   They can contain plugins and settings.
-* @property {PluggableList | undefined} [plugins]
-*   List of plugins and presets (optional).
-* @property {Settings | undefined} [settings]
-*   Shared settings for parsers and compilers (optional).
-*/
-/**
-* @template {VFile} [File=VFile]
-*   The file that the callback receives (default: `VFile`).
-* @callback ProcessCallback
-*   Callback called when the process is done.
-*
-*   Called with either an error or a result.
-* @param {Error | undefined} [error]
-*   Fatal error (optional).
-* @param {File | undefined} [file]
-*   Processed file (optional).
-* @returns {undefined}
-*   Nothing.
-*/
-/**
-* @template {Node} [Tree=Node]
-*   The tree that the callback receives (default: `Node`).
-* @callback RunCallback
-*   Callback called when transformers are done.
-*
-*   Called with either an error or results.
-* @param {Error | undefined} [error]
-*   Fatal error (optional).
-* @param {Tree | undefined} [tree]
-*   Transformed tree (optional).
-* @param {VFile | undefined} [file]
-*   File (optional).
-* @returns {undefined}
-*   Nothing.
-*/
-/**
-* @template {Node} [Output=Node]
-*   Node type that the transformer yields (default: `Node`).
-* @callback TransformCallback
-*   Callback passed to transforms.
-*
-*   If the signature of a `transformer` accepts a third argument, the
-*   transformer may perform asynchronous operations, and must call it.
-* @param {Error | undefined} [error]
-*   Fatal error to stop the process (optional).
-* @param {Output | undefined} [tree]
-*   New, changed, tree (optional).
-* @param {VFile | undefined} [file]
-*   New, changed, file (optional).
-* @returns {undefined}
-*   Nothing.
-*/
-/**
-* @template {Node} [Input=Node]
-*   Node type that the transformer expects (default: `Node`).
-* @template {Node} [Output=Input]
-*   Node type that the transformer yields (default: `Input`).
-* @callback Transformer
-*   Transformers handle syntax trees and files.
-*
-*   They are functions that are called each time a syntax tree and file are
-*   passed through the run phase.
-*   When an error occurs in them (either because it’s thrown, returned,
-*   rejected, or passed to `next`), the process stops.
-*
-*   The run phase is handled by [`trough`][trough], see its documentation for
-*   the exact semantics of these functions.
-*
-*   > **Note**: you should likely ignore `next`: don’t accept it.
-*   > it supports callback-style async work.
-*   > But promises are likely easier to reason about.
-*
-*   [trough]: https://github.com/wooorm/trough#function-fninput-next
-* @param {Input} tree
-*   Tree to handle.
-* @param {VFile} file
-*   File to handle.
-* @param {TransformCallback<Output>} next
-*   Callback.
-* @returns {(
-*   Promise<Output | undefined | void> |
-*   Promise<never> | // For some reason this is needed separately.
-*   Output |
-*   Error |
-*   undefined |
-*   void
-* )}
-*   If you accept `next`, nothing.
-*   Otherwise:
-*
-*   *   `Error` — fatal error to stop the process
-*   *   `Promise<undefined>` or `undefined` — the next transformer keeps using
-*       same tree
-*   *   `Promise<Node>` or `Node` — new, changed, tree
-*/
-/**
-* @template {Node | undefined} ParseTree
-*   Output of `parse`.
-* @template {Node | undefined} HeadTree
-*   Input for `run`.
-* @template {Node | undefined} TailTree
-*   Output for `run`.
-* @template {Node | undefined} CompileTree
-*   Input of `stringify`.
-* @template {CompileResults | undefined} CompileResult
-*   Output of `stringify`.
-* @template {Node | string | undefined} Input
-*   Input of plugin.
-* @template Output
-*   Output of plugin (optional).
-* @typedef {(
-*   Input extends string
-*     ? Output extends Node | undefined
-*       ? // Parser.
-*         Processor<
-*           Output extends undefined ? ParseTree : Output,
-*           HeadTree,
-*           TailTree,
-*           CompileTree,
-*           CompileResult
-*         >
-*       : // Unknown.
-*         Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>
-*     : Output extends CompileResults
-*     ? Input extends Node | undefined
-*       ? // Compiler.
-*         Processor<
-*           ParseTree,
-*           HeadTree,
-*           TailTree,
-*           Input extends undefined ? CompileTree : Input,
-*           Output extends undefined ? CompileResult : Output
-*         >
-*       : // Unknown.
-*         Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>
-*     : Input extends Node | undefined
-*     ? Output extends Node | undefined
-*       ? // Transform.
-*         Processor<
-*           ParseTree,
-*           HeadTree extends undefined ? Input : HeadTree,
-*           Output extends undefined ? TailTree : Output,
-*           CompileTree,
-*           CompileResult
-*         >
-*       : // Unknown.
-*         Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>
-*     : // Unknown.
-*       Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>
-* )} UsePlugin
-*   Create a processor based on the input/output of a {@link Plugin plugin}.
-*/
-/**
-* @template {CompileResults | undefined} Result
-*   Node type that the transformer yields.
-* @typedef {(
-*   Result extends Value | undefined ?
-*     VFile :
-*     VFile & {result: Result}
-*   )} VFileWithOutput
-*   Type to generate a {@linkcode VFile} corresponding to a compiler result.
-*
-*   If a result that is not acceptable on a `VFile` is used, that will
-*   be stored on the `result` field of {@linkcode VFile}.
-*/
-var own = {}.hasOwnProperty;
-/**
-* Create a new processor.
-*
-* @example
-*   This example shows how a new processor can be created (from `remark`) and linked
-*   to **stdin**(4) and **stdout**(4).
-*
-*   ```js
-*   import process from 'node:process'
-*   import concatStream from 'concat-stream'
-*   import {remark} from 'remark'
-*
-*   process.stdin.pipe(
-*     concatStream(function (buf) {
-*       process.stdout.write(String(remark().processSync(buf)))
-*     })
-*   )
-*   ```
-*
-* @returns
-*   New *unfrozen* processor (`processor`).
-*
-*   This processor is configured to work the same as its ancestor.
-*   When the descendant processor is configured in the future it does not
-*   affect the ancestral processor.
-*/
-var unified = new class Processor extends CallableInstance {
-	/**
-	* Create a processor.
-	*/
-	constructor() {
-		super("copy");
-		/**
-		* Compiler to use (deprecated).
-		*
-		* @deprecated
-		*   Use `compiler` instead.
-		* @type {(
-		*   Compiler<
-		*     CompileTree extends undefined ? Node : CompileTree,
-		*     CompileResult extends undefined ? CompileResults : CompileResult
-		*   > |
-		*   undefined
-		* )}
-		*/
-		this.Compiler = void 0;
-		/**
-		* Parser to use (deprecated).
-		*
-		* @deprecated
-		*   Use `parser` instead.
-		* @type {(
-		*   Parser<ParseTree extends undefined ? Node : ParseTree> |
-		*   undefined
-		* )}
-		*/
-		this.Parser = void 0;
-		/**
-		* Internal list of configured plugins.
-		*
-		* @deprecated
-		*   This is a private internal property and should not be used.
-		* @type {Array<PluginTuple<Array<unknown>>>}
-		*/
-		this.attachers = [];
-		/**
-		* Compiler to use.
-		*
-		* @type {(
-		*   Compiler<
-		*     CompileTree extends undefined ? Node : CompileTree,
-		*     CompileResult extends undefined ? CompileResults : CompileResult
-		*   > |
-		*   undefined
-		* )}
-		*/
-		this.compiler = void 0;
-		/**
-		* Internal state to track where we are while freezing.
-		*
-		* @deprecated
-		*   This is a private internal property and should not be used.
-		* @type {number}
-		*/
-		this.freezeIndex = -1;
-		/**
-		* Internal state to track whether we’re frozen.
-		*
-		* @deprecated
-		*   This is a private internal property and should not be used.
-		* @type {boolean | undefined}
-		*/
-		this.frozen = void 0;
-		/**
-		* Internal state.
-		*
-		* @deprecated
-		*   This is a private internal property and should not be used.
-		* @type {Data}
-		*/
-		this.namespace = {};
-		/**
-		* Parser to use.
-		*
-		* @type {(
-		*   Parser<ParseTree extends undefined ? Node : ParseTree> |
-		*   undefined
-		* )}
-		*/
-		this.parser = void 0;
-		/**
-		* Internal list of configured transformers.
-		*
-		* @deprecated
-		*   This is a private internal property and should not be used.
-		* @type {Pipeline}
-		*/
-		this.transformers = trough();
-	}
-	/**
-	* Copy a processor.
-	*
-	* @deprecated
-	*   This is a private internal method and should not be used.
-	* @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
-	*   New *unfrozen* processor ({@linkcode Processor}) that is
-	*   configured to work the same as its ancestor.
-	*   When the descendant processor is configured in the future it does not
-	*   affect the ancestral processor.
-	*/
-	copy() {
-		const destination = new Processor();
-		let index = -1;
-		while (++index < this.attachers.length) {
-			const attacher = this.attachers[index];
-			destination.use(...attacher);
-		}
-		destination.data((0, import_extend.default)(true, {}, this.namespace));
-		return destination;
-	}
-	/**
-	* Configure the processor with info available to all plugins.
-	* Information is stored in an object.
-	*
-	* Typically, options can be given to a specific plugin, but sometimes it
-	* makes sense to have information shared with several plugins.
-	* For example, a list of HTML elements that are self-closing, which is
-	* needed during all phases.
-	*
-	* > **Note**: setting information cannot occur on *frozen* processors.
-	* > Call the processor first to create a new unfrozen processor.
-	*
-	* > **Note**: to register custom data in TypeScript, augment the
-	* > {@linkcode Data} interface.
-	*
-	* @example
-	*   This example show how to get and set info:
-	*
-	*   ```js
-	*   import {unified} from 'unified'
-	*
-	*   const processor = unified().data('alpha', 'bravo')
-	*
-	*   processor.data('alpha') // => 'bravo'
-	*
-	*   processor.data() // => {alpha: 'bravo'}
-	*
-	*   processor.data({charlie: 'delta'})
-	*
-	*   processor.data() // => {charlie: 'delta'}
-	*   ```
-	*
-	* @template {keyof Data} Key
-	*
-	* @overload
-	* @returns {Data}
-	*
-	* @overload
-	* @param {Data} dataset
-	* @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
-	*
-	* @overload
-	* @param {Key} key
-	* @returns {Data[Key]}
-	*
-	* @overload
-	* @param {Key} key
-	* @param {Data[Key]} value
-	* @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
-	*
-	* @param {Data | Key} [key]
-	*   Key to get or set, or entire dataset to set, or nothing to get the
-	*   entire dataset (optional).
-	* @param {Data[Key]} [value]
-	*   Value to set (optional).
-	* @returns {unknown}
-	*   The current processor when setting, the value at `key` when getting, or
-	*   the entire dataset when getting without key.
-	*/
-	data(key, value) {
-		if (typeof key === "string") {
-			if (arguments.length === 2) {
-				assertUnfrozen("data", this.frozen);
-				this.namespace[key] = value;
-				return this;
-			}
-			return own.call(this.namespace, key) && this.namespace[key] || void 0;
-		}
-		if (key) {
-			assertUnfrozen("data", this.frozen);
-			this.namespace = key;
-			return this;
-		}
-		return this.namespace;
-	}
-	/**
-	* Freeze a processor.
-	*
-	* Frozen processors are meant to be extended and not to be configured
-	* directly.
-	*
-	* When a processor is frozen it cannot be unfrozen.
-	* New processors working the same way can be created by calling the
-	* processor.
-	*
-	* It’s possible to freeze processors explicitly by calling `.freeze()`.
-	* Processors freeze automatically when `.parse()`, `.run()`, `.runSync()`,
-	* `.stringify()`, `.process()`, or `.processSync()` are called.
-	*
-	* @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
-	*   The current processor.
-	*/
-	freeze() {
-		if (this.frozen) return this;
-		const self = this;
-		while (++this.freezeIndex < this.attachers.length) {
-			const [attacher, ...options] = this.attachers[this.freezeIndex];
-			if (options[0] === false) continue;
-			if (options[0] === true) options[0] = void 0;
-			const transformer = attacher.call(self, ...options);
-			if (typeof transformer === "function") this.transformers.use(transformer);
-		}
-		this.frozen = true;
-		this.freezeIndex = Number.POSITIVE_INFINITY;
-		return this;
-	}
-	/**
-	* Parse text to a syntax tree.
-	*
-	* > **Note**: `parse` freezes the processor if not already *frozen*.
-	*
-	* > **Note**: `parse` performs the parse phase, not the run phase or other
-	* > phases.
-	*
-	* @param {Compatible | undefined} [file]
-	*   file to parse (optional); typically `string` or `VFile`; any value
-	*   accepted as `x` in `new VFile(x)`.
-	* @returns {ParseTree extends undefined ? Node : ParseTree}
-	*   Syntax tree representing `file`.
-	*/
-	parse(file) {
-		this.freeze();
-		const realFile = vfile(file);
-		const parser = this.parser || this.Parser;
-		assertParser("parse", parser);
-		return parser(String(realFile), realFile);
-	}
-	/**
-	* Process the given file as configured on the processor.
-	*
-	* > **Note**: `process` freezes the processor if not already *frozen*.
-	*
-	* > **Note**: `process` performs the parse, run, and stringify phases.
-	*
-	* @overload
-	* @param {Compatible | undefined} file
-	* @param {ProcessCallback<VFileWithOutput<CompileResult>>} done
-	* @returns {undefined}
-	*
-	* @overload
-	* @param {Compatible | undefined} [file]
-	* @returns {Promise<VFileWithOutput<CompileResult>>}
-	*
-	* @param {Compatible | undefined} [file]
-	*   File (optional); typically `string` or `VFile`]; any value accepted as
-	*   `x` in `new VFile(x)`.
-	* @param {ProcessCallback<VFileWithOutput<CompileResult>> | undefined} [done]
-	*   Callback (optional).
-	* @returns {Promise<VFile> | undefined}
-	*   Nothing if `done` is given.
-	*   Otherwise a promise, rejected with a fatal error or resolved with the
-	*   processed file.
-	*
-	*   The parsed, transformed, and compiled value is available at
-	*   `file.value` (see note).
-	*
-	*   > **Note**: unified typically compiles by serializing: most
-	*   > compilers return `string` (or `Uint8Array`).
-	*   > Some compilers, such as the one configured with
-	*   > [`rehype-react`][rehype-react], return other values (in this case, a
-	*   > React tree).
-	*   > If you’re using a compiler that doesn’t serialize, expect different
-	*   > result values.
-	*   >
-	*   > To register custom results in TypeScript, add them to
-	*   > {@linkcode CompileResultMap}.
-	*
-	*   [rehype-react]: https://github.com/rehypejs/rehype-react
-	*/
-	process(file, done) {
-		const self = this;
-		this.freeze();
-		assertParser("process", this.parser || this.Parser);
-		assertCompiler("process", this.compiler || this.Compiler);
-		return done ? executor(void 0, done) : new Promise(executor);
-		/**
-		* @param {((file: VFileWithOutput<CompileResult>) => undefined | void) | undefined} resolve
-		* @param {(error: Error | undefined) => undefined | void} reject
-		* @returns {undefined}
-		*/
-		function executor(resolve, reject) {
-			const realFile = vfile(file);
-			const parseTree = self.parse(realFile);
-			self.run(parseTree, realFile, function(error, tree, file) {
-				if (error || !tree || !file) return realDone(error);
-				const compileTree = tree;
-				const compileResult = self.stringify(compileTree, file);
-				if (looksLikeAValue(compileResult)) file.value = compileResult;
-				else file.result = compileResult;
-				realDone(error, file);
-			});
-			/**
-			* @param {Error | undefined} error
-			* @param {VFileWithOutput<CompileResult> | undefined} [file]
-			* @returns {undefined}
-			*/
-			function realDone(error, file) {
-				if (error || !file) reject(error);
-				else if (resolve) resolve(file);
-				else done(void 0, file);
-			}
-		}
-	}
-	/**
-	* Process the given file as configured on the processor.
-	*
-	* An error is thrown if asynchronous transforms are configured.
-	*
-	* > **Note**: `processSync` freezes the processor if not already *frozen*.
-	*
-	* > **Note**: `processSync` performs the parse, run, and stringify phases.
-	*
-	* @param {Compatible | undefined} [file]
-	*   File (optional); typically `string` or `VFile`; any value accepted as
-	*   `x` in `new VFile(x)`.
-	* @returns {VFileWithOutput<CompileResult>}
-	*   The processed file.
-	*
-	*   The parsed, transformed, and compiled value is available at
-	*   `file.value` (see note).
-	*
-	*   > **Note**: unified typically compiles by serializing: most
-	*   > compilers return `string` (or `Uint8Array`).
-	*   > Some compilers, such as the one configured with
-	*   > [`rehype-react`][rehype-react], return other values (in this case, a
-	*   > React tree).
-	*   > If you’re using a compiler that doesn’t serialize, expect different
-	*   > result values.
-	*   >
-	*   > To register custom results in TypeScript, add them to
-	*   > {@linkcode CompileResultMap}.
-	*
-	*   [rehype-react]: https://github.com/rehypejs/rehype-react
-	*/
-	processSync(file) {
-		/** @type {boolean} */
-		let complete = false;
-		/** @type {VFileWithOutput<CompileResult> | undefined} */
-		let result;
-		this.freeze();
-		assertParser("processSync", this.parser || this.Parser);
-		assertCompiler("processSync", this.compiler || this.Compiler);
-		this.process(file, realDone);
-		assertDone("processSync", "process", complete);
-		return result;
-		/**
-		* @type {ProcessCallback<VFileWithOutput<CompileResult>>}
-		*/
-		function realDone(error, file) {
-			complete = true;
-			bail(error);
-			result = file;
-		}
-	}
-	/**
-	* Run *transformers* on a syntax tree.
-	*
-	* > **Note**: `run` freezes the processor if not already *frozen*.
-	*
-	* > **Note**: `run` performs the run phase, not other phases.
-	*
-	* @overload
-	* @param {HeadTree extends undefined ? Node : HeadTree} tree
-	* @param {RunCallback<TailTree extends undefined ? Node : TailTree>} done
-	* @returns {undefined}
-	*
-	* @overload
-	* @param {HeadTree extends undefined ? Node : HeadTree} tree
-	* @param {Compatible | undefined} file
-	* @param {RunCallback<TailTree extends undefined ? Node : TailTree>} done
-	* @returns {undefined}
-	*
-	* @overload
-	* @param {HeadTree extends undefined ? Node : HeadTree} tree
-	* @param {Compatible | undefined} [file]
-	* @returns {Promise<TailTree extends undefined ? Node : TailTree>}
-	*
-	* @param {HeadTree extends undefined ? Node : HeadTree} tree
-	*   Tree to transform and inspect.
-	* @param {(
-	*   RunCallback<TailTree extends undefined ? Node : TailTree> |
-	*   Compatible
-	* )} [file]
-	*   File associated with `node` (optional); any value accepted as `x` in
-	*   `new VFile(x)`.
-	* @param {RunCallback<TailTree extends undefined ? Node : TailTree>} [done]
-	*   Callback (optional).
-	* @returns {Promise<TailTree extends undefined ? Node : TailTree> | undefined}
-	*   Nothing if `done` is given.
-	*   Otherwise, a promise rejected with a fatal error or resolved with the
-	*   transformed tree.
-	*/
-	run(tree, file, done) {
-		assertNode(tree);
-		this.freeze();
-		const transformers = this.transformers;
-		if (!done && typeof file === "function") {
-			done = file;
-			file = void 0;
-		}
-		return done ? executor(void 0, done) : new Promise(executor);
-		/**
-		* @param {(
-		*   ((tree: TailTree extends undefined ? Node : TailTree) => undefined | void) |
-		*   undefined
-		* )} resolve
-		* @param {(error: Error) => undefined | void} reject
-		* @returns {undefined}
-		*/
-		function executor(resolve, reject) {
-			const realFile = vfile(file);
-			transformers.run(tree, realFile, realDone);
-			/**
-			* @param {Error | undefined} error
-			* @param {Node} outputTree
-			* @param {VFile} file
-			* @returns {undefined}
-			*/
-			function realDone(error, outputTree, file) {
-				const resultingTree = outputTree || tree;
-				if (error) reject(error);
-				else if (resolve) resolve(resultingTree);
-				else done(void 0, resultingTree, file);
-			}
-		}
-	}
-	/**
-	* Run *transformers* on a syntax tree.
-	*
-	* An error is thrown if asynchronous transforms are configured.
-	*
-	* > **Note**: `runSync` freezes the processor if not already *frozen*.
-	*
-	* > **Note**: `runSync` performs the run phase, not other phases.
-	*
-	* @param {HeadTree extends undefined ? Node : HeadTree} tree
-	*   Tree to transform and inspect.
-	* @param {Compatible | undefined} [file]
-	*   File associated with `node` (optional); any value accepted as `x` in
-	*   `new VFile(x)`.
-	* @returns {TailTree extends undefined ? Node : TailTree}
-	*   Transformed tree.
-	*/
-	runSync(tree, file) {
-		/** @type {boolean} */
-		let complete = false;
-		/** @type {(TailTree extends undefined ? Node : TailTree) | undefined} */
-		let result;
-		this.run(tree, file, realDone);
-		assertDone("runSync", "run", complete);
-		return result;
-		/**
-		* @type {RunCallback<TailTree extends undefined ? Node : TailTree>}
-		*/
-		function realDone(error, tree) {
-			bail(error);
-			result = tree;
-			complete = true;
-		}
-	}
-	/**
-	* Compile a syntax tree.
-	*
-	* > **Note**: `stringify` freezes the processor if not already *frozen*.
-	*
-	* > **Note**: `stringify` performs the stringify phase, not the run phase
-	* > or other phases.
-	*
-	* @param {CompileTree extends undefined ? Node : CompileTree} tree
-	*   Tree to compile.
-	* @param {Compatible | undefined} [file]
-	*   File associated with `node` (optional); any value accepted as `x` in
-	*   `new VFile(x)`.
-	* @returns {CompileResult extends undefined ? Value : CompileResult}
-	*   Textual representation of the tree (see note).
-	*
-	*   > **Note**: unified typically compiles by serializing: most compilers
-	*   > return `string` (or `Uint8Array`).
-	*   > Some compilers, such as the one configured with
-	*   > [`rehype-react`][rehype-react], return other values (in this case, a
-	*   > React tree).
-	*   > If you’re using a compiler that doesn’t serialize, expect different
-	*   > result values.
-	*   >
-	*   > To register custom results in TypeScript, add them to
-	*   > {@linkcode CompileResultMap}.
-	*
-	*   [rehype-react]: https://github.com/rehypejs/rehype-react
-	*/
-	stringify(tree, file) {
-		this.freeze();
-		const realFile = vfile(file);
-		const compiler = this.compiler || this.Compiler;
-		assertCompiler("stringify", compiler);
-		assertNode(tree);
-		return compiler(tree, realFile);
-	}
-	/**
-	* Configure the processor to use a plugin, a list of usable values, or a
-	* preset.
-	*
-	* If the processor is already using a plugin, the previous plugin
-	* configuration is changed based on the options that are passed in.
-	* In other words, the plugin is not added a second time.
-	*
-	* > **Note**: `use` cannot be called on *frozen* processors.
-	* > Call the processor first to create a new unfrozen processor.
-	*
-	* @example
-	*   There are many ways to pass plugins to `.use()`.
-	*   This example gives an overview:
-	*
-	*   ```js
-	*   import {unified} from 'unified'
-	*
-	*   unified()
-	*     // Plugin with options:
-	*     .use(pluginA, {x: true, y: true})
-	*     // Passing the same plugin again merges configuration (to `{x: true, y: false, z: true}`):
-	*     .use(pluginA, {y: false, z: true})
-	*     // Plugins:
-	*     .use([pluginB, pluginC])
-	*     // Two plugins, the second with options:
-	*     .use([pluginD, [pluginE, {}]])
-	*     // Preset with plugins and settings:
-	*     .use({plugins: [pluginF, [pluginG, {}]], settings: {position: false}})
-	*     // Settings only:
-	*     .use({settings: {position: false}})
-	*   ```
-	*
-	* @template {Array<unknown>} [Parameters=[]]
-	* @template {Node | string | undefined} [Input=undefined]
-	* @template [Output=Input]
-	*
-	* @overload
-	* @param {Preset | null | undefined} [preset]
-	* @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
-	*
-	* @overload
-	* @param {PluggableList} list
-	* @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
-	*
-	* @overload
-	* @param {Plugin<Parameters, Input, Output>} plugin
-	* @param {...(Parameters | [boolean])} parameters
-	* @returns {UsePlugin<ParseTree, HeadTree, TailTree, CompileTree, CompileResult, Input, Output>}
-	*
-	* @param {PluggableList | Plugin | Preset | null | undefined} value
-	*   Usable value.
-	* @param {...unknown} parameters
-	*   Parameters, when a plugin is given as a usable value.
-	* @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
-	*   Current processor.
-	*/
-	use(value, ...parameters) {
-		const attachers = this.attachers;
-		const namespace = this.namespace;
-		assertUnfrozen("use", this.frozen);
-		if (value === null || value === void 0) {} else if (typeof value === "function") addPlugin(value, parameters);
-		else if (typeof value === "object") if (Array.isArray(value)) addList(value);
-		else addPreset(value);
-		else throw new TypeError("Expected usable value, not `" + value + "`");
-		return this;
-		/**
-		* @param {Pluggable} value
-		* @returns {undefined}
-		*/
-		function add(value) {
-			if (typeof value === "function") addPlugin(value, []);
-			else if (typeof value === "object") if (Array.isArray(value)) {
-				const [plugin, ...parameters] = value;
-				addPlugin(plugin, parameters);
-			} else addPreset(value);
-			else throw new TypeError("Expected usable value, not `" + value + "`");
-		}
-		/**
-		* @param {Preset} result
-		* @returns {undefined}
-		*/
-		function addPreset(result) {
-			if (!("plugins" in result) && !("settings" in result)) 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");
-			addList(result.plugins);
-			if (result.settings) namespace.settings = (0, import_extend.default)(true, namespace.settings, result.settings);
-		}
-		/**
-		* @param {PluggableList | null | undefined} plugins
-		* @returns {undefined}
-		*/
-		function addList(plugins) {
-			let index = -1;
-			if (plugins === null || plugins === void 0) {} else if (Array.isArray(plugins)) while (++index < plugins.length) {
-				const thing = plugins[index];
-				add(thing);
-			}
-			else throw new TypeError("Expected a list of plugins, not `" + plugins + "`");
-		}
-		/**
-		* @param {Plugin} plugin
-		* @param {Array<unknown>} parameters
-		* @returns {undefined}
-		*/
-		function addPlugin(plugin, parameters) {
-			let index = -1;
-			let entryIndex = -1;
-			while (++index < attachers.length) if (attachers[index][0] === plugin) {
-				entryIndex = index;
-				break;
-			}
-			if (entryIndex === -1) attachers.push([plugin, ...parameters]);
-			else if (parameters.length > 0) {
-				let [primary, ...rest] = parameters;
-				const currentPrimary = attachers[entryIndex][1];
-				if (isPlainObject(currentPrimary) && isPlainObject(primary)) primary = (0, import_extend.default)(true, currentPrimary, primary);
-				attachers[entryIndex] = [
-					plugin,
-					primary,
-					...rest
-				];
-			}
-		}
-	}
-}().freeze();
-/**
-* Assert a parser is available.
-*
-* @param {string} name
-* @param {unknown} value
-* @returns {asserts value is Parser}
-*/
-function assertParser(name, value) {
-	if (typeof value !== "function") throw new TypeError("Cannot `" + name + "` without `parser`");
-}
-/**
-* Assert a compiler is available.
-*
-* @param {string} name
-* @param {unknown} value
-* @returns {asserts value is Compiler}
-*/
-function assertCompiler(name, value) {
-	if (typeof value !== "function") throw new TypeError("Cannot `" + name + "` without `compiler`");
-}
-/**
-* Assert the processor is not frozen.
-*
-* @param {string} name
-* @param {unknown} frozen
-* @returns {asserts frozen is false}
-*/
-function assertUnfrozen(name, frozen) {
-	if (frozen) throw new Error("Cannot call `" + name + "` on a frozen processor.\nCreate a new processor first, by calling it: use `processor()` instead of `processor`.");
-}
-/**
-* Assert `node` is a unist node.
-*
-* @param {unknown} node
-* @returns {asserts node is Node}
-*/
-function assertNode(node) {
-	if (!isPlainObject(node) || typeof node.type !== "string") throw new TypeError("Expected node, got `" + node + "`");
-}
-/**
-* Assert that `complete` is `true`.
-*
-* @param {string} name
-* @param {string} asyncName
-* @param {unknown} complete
-* @returns {asserts complete is true}
-*/
-function assertDone(name, asyncName, complete) {
-	if (!complete) throw new Error("`" + name + "` finished async. Use `" + asyncName + "` instead");
-}
-/**
-* @param {Compatible | undefined} [value]
-* @returns {VFile}
-*/
-function vfile(value) {
-	return looksLikeAVFile(value) ? value : new VFile(value);
-}
-/**
-* @param {Compatible | undefined} [value]
-* @returns {value is VFile}
-*/
-function looksLikeAVFile(value) {
-	return Boolean(value && typeof value === "object" && "message" in value && "messages" in value);
-}
-/**
-* @param {unknown} [value]
-* @returns {value is Value}
-*/
-function looksLikeAValue(value) {
-	return typeof value === "string" || isUint8Array(value);
-}
-/**
-* Assert `value` is an `Uint8Array`.
-*
-* @param {unknown} value
-*   thing.
-* @returns {value is Uint8Array}
-*   Whether `value` is an `Uint8Array`.
-*/
-function isUint8Array(value) {
-	return Boolean(value && typeof value === "object" && "byteLength" in value && "byteOffset" in value);
-}
-//#endregion
-//#region node_modules/.pnpm/react-markdown@10.1.0_@types+react@19.2.14_react@19.2.5/node_modules/react-markdown/lib/index.js
-/**
-* @import {Element, Nodes, Parents, Root} from 'hast'
-* @import {Root as MdastRoot} from 'mdast'
-* @import {ComponentType, JSX, ReactElement, ReactNode} from 'react'
-* @import {Options as RemarkRehypeOptions} from 'remark-rehype'
-* @import {BuildVisitor} from 'unist-util-visit'
-* @import {PluggableList, Processor} from 'unified'
-*/
-/**
-* @callback AllowElement
-*   Filter elements.
-* @param {Readonly<Element>} element
-*   Element to check.
-* @param {number} index
-*   Index of `element` in `parent`.
-* @param {Readonly<Parents> | undefined} parent
-*   Parent of `element`.
-* @returns {boolean | null | undefined}
-*   Whether to allow `element` (default: `false`).
-*/
-/**
-* @typedef ExtraProps
-*   Extra fields we pass.
-* @property {Element | undefined} [node]
-*   passed when `passNode` is on.
-*/
-/**
-* @typedef {{
-*   [Key in keyof JSX.IntrinsicElements]?: ComponentType<JSX.IntrinsicElements[Key] & ExtraProps> | keyof JSX.IntrinsicElements
-* }} Components
-*   Map tag names to components.
-*/
-/**
-* @typedef Deprecation
-*   Deprecation.
-* @property {string} from
-*   Old field.
-* @property {string} id
-*   ID in readme.
-* @property {keyof Options} [to]
-*   New field.
-*/
-/**
-* @typedef Options
-*   Configuration.
-* @property {AllowElement | null | undefined} [allowElement]
-*   Filter elements (optional);
-*   `allowedElements` / `disallowedElements` is used first.
-* @property {ReadonlyArray<string> | null | undefined} [allowedElements]
-*   Tag names to allow (default: all tag names);
-*   cannot combine w/ `disallowedElements`.
-* @property {string | null | undefined} [children]
-*   Markdown.
-* @property {Components | null | undefined} [components]
-*   Map tag names to components.
-* @property {ReadonlyArray<string> | null | undefined} [disallowedElements]
-*   Tag names to disallow (default: `[]`);
-*   cannot combine w/ `allowedElements`.
-* @property {PluggableList | null | undefined} [rehypePlugins]
-*   List of rehype plugins to use.
-* @property {PluggableList | null | undefined} [remarkPlugins]
-*   List of remark plugins to use.
-* @property {Readonly<RemarkRehypeOptions> | null | undefined} [remarkRehypeOptions]
-*   Options to pass through to `remark-rehype`.
-* @property {boolean | null | undefined} [skipHtml=false]
-*   Ignore HTML in markdown completely (default: `false`).
-* @property {boolean | null | undefined} [unwrapDisallowed=false]
-*   Extract (unwrap) what’s in disallowed elements (default: `false`);
-*   normally when say `strong` is not allowed, it and it’s children are dropped,
-*   with `unwrapDisallowed` the element itself is replaced by its children.
-* @property {UrlTransform | null | undefined} [urlTransform]
-*   Change URLs (default: `defaultUrlTransform`)
-*/
-/**
-* @typedef HooksOptionsOnly
-*   Configuration specifically for {@linkcode MarkdownHooks}.
-* @property {ReactNode | null | undefined} [fallback]
-*   Content to render while the processor processing the markdown (optional).
-*/
-/**
-* @typedef {Options & HooksOptionsOnly} HooksOptions
-*   Configuration for {@linkcode MarkdownHooks};
-*   extends the regular {@linkcode Options} with a `fallback` prop.
-*/
-/**
-* @callback UrlTransform
-*   Transform all URLs.
-* @param {string} url
-*   URL.
-* @param {string} key
-*   Property name (example: `'href'`).
-* @param {Readonly<Element>} node
-*   Node.
-* @returns {string | null | undefined}
-*   Transformed URL (optional).
-*/
-var import_jsx_runtime = require_jsx_runtime();
-require_react();
-/** @type {PluggableList} */
-var emptyPlugins = [];
-/** @type {Readonly<RemarkRehypeOptions>} */
-var emptyRemarkRehypeOptions = { allowDangerousHtml: true };
-var safeProtocol = /^(https?|ircs?|mailto|xmpp)$/i;
-/** @type {ReadonlyArray<Readonly<Deprecation>>} */
-var deprecations = [
-	{
-		from: "astPlugins",
-		id: "remove-buggy-html-in-markdown-parser"
-	},
-	{
-		from: "allowDangerousHtml",
-		id: "remove-buggy-html-in-markdown-parser"
-	},
-	{
-		from: "allowNode",
-		id: "replace-allownode-allowedtypes-and-disallowedtypes",
-		to: "allowElement"
-	},
-	{
-		from: "allowedTypes",
-		id: "replace-allownode-allowedtypes-and-disallowedtypes",
-		to: "allowedElements"
-	},
-	{
-		from: "className",
-		id: "remove-classname"
-	},
-	{
-		from: "disallowedTypes",
-		id: "replace-allownode-allowedtypes-and-disallowedtypes",
-		to: "disallowedElements"
-	},
-	{
-		from: "escapeHtml",
-		id: "remove-buggy-html-in-markdown-parser"
-	},
-	{
-		from: "includeElementIndex",
-		id: "#remove-includeelementindex"
-	},
-	{
-		from: "includeNodeIndex",
-		id: "change-includenodeindex-to-includeelementindex"
-	},
-	{
-		from: "linkTarget",
-		id: "remove-linktarget"
-	},
-	{
-		from: "plugins",
-		id: "change-plugins-to-remarkplugins",
-		to: "remarkPlugins"
-	},
-	{
-		from: "rawSourcePos",
-		id: "#remove-rawsourcepos"
-	},
-	{
-		from: "renderers",
-		id: "change-renderers-to-components",
-		to: "components"
-	},
-	{
-		from: "source",
-		id: "change-source-to-children",
-		to: "children"
-	},
-	{
-		from: "sourcePos",
-		id: "#remove-sourcepos"
-	},
-	{
-		from: "transformImageUri",
-		id: "#add-urltransform",
-		to: "urlTransform"
-	},
-	{
-		from: "transformLinkUri",
-		id: "#add-urltransform",
-		to: "urlTransform"
-	}
-];
-/**
-* Component to render markdown.
-*
-* This is a synchronous component.
-* When using async plugins,
-* see {@linkcode MarkdownAsync} or {@linkcode MarkdownHooks}.
-*
-* @param {Readonly<Options>} options
-*   Props.
-* @returns {ReactElement}
-*   React element.
-*/
-function Markdown(options) {
-	const processor = createProcessor(options);
-	const file = createFile(options);
-	return post(processor.runSync(processor.parse(file), file), options);
-}
-/**
-* Set up the `unified` processor.
-*
-* @param {Readonly<Options>} options
-*   Props.
-* @returns {Processor<MdastRoot, MdastRoot, Root, undefined, undefined>}
-*   Result.
-*/
-function createProcessor(options) {
-	const rehypePlugins = options.rehypePlugins || emptyPlugins;
-	const remarkPlugins = options.remarkPlugins || emptyPlugins;
-	const remarkRehypeOptions = options.remarkRehypeOptions ? {
-		...options.remarkRehypeOptions,
-		...emptyRemarkRehypeOptions
-	} : emptyRemarkRehypeOptions;
-	return unified().use(remarkParse).use(remarkPlugins).use(remarkRehype, remarkRehypeOptions).use(rehypePlugins);
-}
-/**
-* Set up the virtual file.
-*
-* @param {Readonly<Options>} options
-*   Props.
-* @returns {VFile}
-*   Result.
-*/
-function createFile(options) {
-	const children = options.children || "";
-	const file = new VFile();
-	if (typeof children === "string") file.value = children;
-	else "" + children;
-	return file;
-}
-/**
-* Process the result from unified some more.
-*
-* @param {Nodes} tree
-*   Tree.
-* @param {Readonly<Options>} options
-*   Props.
-* @returns {ReactElement}
-*   React element.
-*/
-function post(tree, options) {
-	const allowedElements = options.allowedElements;
-	const allowElement = options.allowElement;
-	const components = options.components;
-	const disallowedElements = options.disallowedElements;
-	const skipHtml = options.skipHtml;
-	const unwrapDisallowed = options.unwrapDisallowed;
-	const urlTransform = options.urlTransform || defaultUrlTransform;
-	for (const deprecation of deprecations) if (Object.hasOwn(options, deprecation.from)) "" + deprecation.from + (deprecation.to ? "use `" + deprecation.to + "` instead" : "remove it") + deprecation.id;
-	if (allowedElements && disallowedElements);
-	visit(tree, transform);
-	return toJsxRuntime(tree, {
-		Fragment: import_jsx_runtime.Fragment,
-		components,
-		ignoreInvalidStyle: true,
-		jsx: import_jsx_runtime.jsx,
-		jsxs: import_jsx_runtime.jsxs,
-		passKeys: true,
-		passNode: true
-	});
-	/** @type {BuildVisitor<Root>} */
-	function transform(node, index, parent) {
-		if (node.type === "raw" && parent && typeof index === "number") {
-			if (skipHtml) parent.children.splice(index, 1);
-			else parent.children[index] = {
-				type: "text",
-				value: node.value
-			};
-			return index;
-		}
-		if (node.type === "element") {
-			/** @type {string} */
-			let key;
-			for (key in urlAttributes) if (Object.hasOwn(urlAttributes, key) && Object.hasOwn(node.properties, key)) {
-				const value = node.properties[key];
-				const test = urlAttributes[key];
-				if (test === null || test.includes(node.tagName)) node.properties[key] = urlTransform(String(value || ""), key, node);
-			}
-		}
-		if (node.type === "element") {
-			let remove = allowedElements ? !allowedElements.includes(node.tagName) : disallowedElements ? disallowedElements.includes(node.tagName) : false;
-			if (!remove && allowElement && typeof index === "number") remove = !allowElement(node, index, parent);
-			if (remove && parent && typeof index === "number") {
-				if (unwrapDisallowed && node.children) parent.children.splice(index, 1, ...node.children);
-				else parent.children.splice(index, 1);
-				return index;
-			}
-		}
-	}
-}
-/**
-* Make a URL safe.
-*
-* @satisfies {UrlTransform}
-* @param {string} value
-*   URL.
-* @returns {string}
-*   Safe URL.
-*/
-function defaultUrlTransform(value) {
-	const colon = value.indexOf(":");
-	const questionMark = value.indexOf("?");
-	const numberSign = value.indexOf("#");
-	const slash = value.indexOf("/");
-	if (colon === -1 || slash !== -1 && colon > slash || questionMark !== -1 && colon > questionMark || numberSign !== -1 && colon > numberSign || safeProtocol.test(value.slice(0, colon))) return value;
-	return "";
-}
-//#endregion
-export { Markdown as t };