@mralfarrakhan/svork 0.5.0

package/dist/index.mjs

@@ -0,0 +1,2494 @@
+import { parse } from "svelte/compiler";
+import minpath from "node:path";
+import minproc from "node:process";
+import { fileURLToPath as urlToPath } from "node:url";
+import remarkParse from "remark-parse";
+import remarkRehype from "remark-rehype";
+import rehypeRaw from "rehype-raw";
+import rehypeStringify from "rehype-stringify";
+import yaml from "js-yaml";
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+//#region node_modules/bail/index.js
+/**
+* Throw a given error.
+*
+* @param {Error|null|undefined} [error]
+*   Maybe error.
+* @returns {asserts error is null|undefined}
+*/
+function bail(error) {
+	if (error) throw error;
+}
+//#endregion
+//#region node_modules/extend/index.js
+var require_extend = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var hasOwn = Object.prototype.hasOwnProperty;
+	var toStr = Object.prototype.toString;
+	var defineProperty = Object.defineProperty;
+	var gOPD = Object.getOwnPropertyDescriptor;
+	var isArray = function isArray(arr) {
+		if (typeof Array.isArray === "function") return Array.isArray(arr);
+		return toStr.call(arr) === "[object Array]";
+	};
+	var isPlainObject = function isPlainObject(obj) {
+		if (!obj || toStr.call(obj) !== "[object Object]") return false;
+		var hasOwnConstructor = hasOwn.call(obj, "constructor");
+		var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, "isPrototypeOf");
+		if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) return false;
+		var key;
+		for (key in obj);
+		return typeof key === "undefined" || hasOwn.call(obj, key);
+	};
+	var setProperty = function setProperty(target, options) {
+		if (defineProperty && options.name === "__proto__") defineProperty(target, options.name, {
+			enumerable: true,
+			configurable: true,
+			value: options.newValue,
+			writable: true
+		});
+		else target[options.name] = options.newValue;
+	};
+	var getProperty = function getProperty(obj, name) {
+		if (name === "__proto__") {
+			if (!hasOwn.call(obj, name)) return;
+			else if (gOPD) return gOPD(obj, name).value;
+		}
+		return obj[name];
+	};
+	module.exports = function extend() {
+		var options, name, src, copy, copyIsArray, clone;
+		var target = arguments[0];
+		var i = 1;
+		var length = arguments.length;
+		var deep = false;
+		if (typeof target === "boolean") {
+			deep = target;
+			target = arguments[1] || {};
+			i = 2;
+		}
+		if (target == null || typeof target !== "object" && typeof target !== "function") target = {};
+		for (; i < length; ++i) {
+			options = arguments[i];
+			if (options != null) for (name in options) {
+				src = getProperty(target, name);
+				copy = getProperty(options, name);
+				if (target !== copy) {
+					if (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {
+						if (copyIsArray) {
+							copyIsArray = false;
+							clone = src && isArray(src) ? src : [];
+						} else clone = src && isPlainObject(src) ? src : {};
+						setProperty(target, {
+							name,
+							newValue: extend(deep, clone, copy)
+						});
+					} else if (typeof copy !== "undefined") setProperty(target, {
+						name,
+						newValue: copy
+					});
+				}
+			}
+		}
+		return target;
+	};
+}));
+//#endregion
+//#region node_modules/is-plain-obj/index.js
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
+}
+//#endregion
+//#region 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/unist-util-stringify-position/lib/index.js
+/**
+* @typedef {import('unist').Node} Node
+* @typedef {import('unist').Point} Point
+* @typedef {import('unist').Position} Position
+*/
+/**
+* @typedef NodeLike
+* @property {string} type
+* @property {PositionLike | null | undefined} [position]
+*
+* @typedef PointLike
+* @property {number | null | undefined} [line]
+* @property {number | null | undefined} [column]
+* @property {number | null | undefined} [offset]
+*
+* @typedef PositionLike
+* @property {PointLike | null | undefined} [start]
+* @property {PointLike | null | undefined} [end]
+*/
+/**
+* Serialize the positional info of a point, position (start and end points),
+* or node.
+*
+* @param {Node | NodeLike | Point | PointLike | Position | PositionLike | null | undefined} [value]
+*   Node, position, or point.
+* @returns {string}
+*   Pretty printed positional info of a node (`string`).
+*
+*   In the format of a range `ls:cs-le:ce` (when given `node` or `position`)
+*   or a point `l:c` (when given `point`), where `l` stands for line, `c` for
+*   column, `s` for `start`, and `e` for end.
+*   An empty string (`''`) is returned if the given value is neither `node`,
+*   `position`, nor `point`.
+*/
+function stringifyPosition(value) {
+	if (!value || typeof value !== "object") return "";
+	if ("position" in value || "type" in value) return position(value.position);
+	if ("start" in value || "end" in value) return position(value);
+	if ("line" in value || "column" in value) return point(value);
+	return "";
+}
+/**
+* @param {Point | PointLike | null | undefined} point
+* @returns {string}
+*/
+function point(point) {
+	return index(point && point.line) + ":" + index(point && point.column);
+}
+/**
+* @param {Position | PositionLike | null | undefined} pos
+* @returns {string}
+*/
+function position(pos) {
+	return point(pos && pos.start) + "-" + point(pos && pos.end);
+}
+/**
+* @param {number | null | undefined} value
+* @returns {number}
+*/
+function index(value) {
+	return value && typeof value === "number" ? value : 1;
+}
+//#endregion
+//#region node_modules/vfile-message/lib/index.js
+/**
+* @import {Node, Point, Position} from 'unist'
+*/
+/**
+* @typedef {object & {type: string, position?: Position | undefined}} NodeLike
+*
+* @typedef Options
+*   Configuration.
+* @property {Array<Node> | null | undefined} [ancestors]
+*   Stack of (inclusive) ancestor nodes surrounding the message (optional).
+* @property {Error | null | undefined} [cause]
+*   Original error cause of the message (optional).
+* @property {Point | Position | null | undefined} [place]
+*   Place of message (optional).
+* @property {string | null | undefined} [ruleId]
+*   Category of message (optional, example: `'my-rule'`).
+* @property {string | null | undefined} [source]
+*   Namespace of who sent the message (optional, example: `'my-package'`).
+*/
+/**
+* Message.
+*/
+var VFileMessage = class extends Error {
+	/**
+	* Create a message for `reason`.
+	*
+	* > 🪦 **Note**: also has obsolete signatures.
+	*
+	* @overload
+	* @param {string} reason
+	* @param {Options | null | undefined} [options]
+	* @returns
+	*
+	* @overload
+	* @param {string} reason
+	* @param {Node | NodeLike | null | undefined} parent
+	* @param {string | null | undefined} [origin]
+	* @returns
+	*
+	* @overload
+	* @param {string} reason
+	* @param {Point | Position | null | undefined} place
+	* @param {string | null | undefined} [origin]
+	* @returns
+	*
+	* @overload
+	* @param {string} reason
+	* @param {string | null | undefined} [origin]
+	* @returns
+	*
+	* @overload
+	* @param {Error | VFileMessage} cause
+	* @param {Node | NodeLike | null | undefined} parent
+	* @param {string | null | undefined} [origin]
+	* @returns
+	*
+	* @overload
+	* @param {Error | VFileMessage} cause
+	* @param {Point | Position | null | undefined} place
+	* @param {string | null | undefined} [origin]
+	* @returns
+	*
+	* @overload
+	* @param {Error | VFileMessage} cause
+	* @param {string | null | undefined} [origin]
+	* @returns
+	*
+	* @param {Error | VFileMessage | string} causeOrReason
+	*   Reason for message, should use markdown.
+	* @param {Node | NodeLike | Options | 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
+	*   Instance of `VFileMessage`.
+	*/
+	constructor(causeOrReason, optionsOrParentOrPlace, origin) {
+		super();
+		if (typeof optionsOrParentOrPlace === "string") {
+			origin = optionsOrParentOrPlace;
+			optionsOrParentOrPlace = void 0;
+		}
+		/** @type {string} */
+		let reason = "";
+		/** @type {Options} */
+		let options = {};
+		let legacyCause = false;
+		if (optionsOrParentOrPlace) if ("line" in optionsOrParentOrPlace && "column" in optionsOrParentOrPlace) options = { place: optionsOrParentOrPlace };
+		else if ("start" in optionsOrParentOrPlace && "end" in optionsOrParentOrPlace) options = { place: optionsOrParentOrPlace };
+		else if ("type" in optionsOrParentOrPlace) options = {
+			ancestors: [optionsOrParentOrPlace],
+			place: optionsOrParentOrPlace.position
+		};
+		else options = { ...optionsOrParentOrPlace };
+		if (typeof causeOrReason === "string") reason = causeOrReason;
+		else if (!options.cause && causeOrReason) {
+			legacyCause = true;
+			reason = causeOrReason.message;
+			options.cause = causeOrReason;
+		}
+		if (!options.ruleId && !options.source && typeof origin === "string") {
+			const index = origin.indexOf(":");
+			if (index === -1) options.ruleId = origin;
+			else {
+				options.source = origin.slice(0, index);
+				options.ruleId = origin.slice(index + 1);
+			}
+		}
+		if (!options.place && options.ancestors && options.ancestors) {
+			const parent = options.ancestors[options.ancestors.length - 1];
+			if (parent) options.place = parent.position;
+		}
+		const start = options.place && "start" in options.place ? options.place.start : options.place;
+		/**
+		* Stack of ancestor nodes surrounding the message.
+		*
+		* @type {Array<Node> | undefined}
+		*/
+		this.ancestors = options.ancestors || void 0;
+		/**
+		* Original error cause of the message.
+		*
+		* @type {Error | undefined}
+		*/
+		this.cause = options.cause || void 0;
+		/**
+		* Starting column of message.
+		*
+		* @type {number | undefined}
+		*/
+		this.column = start ? start.column : void 0;
+		/**
+		* State of problem.
+		*
+		* * `true` — error, file not usable
+		* * `false` — warning, change may be needed
+		* * `undefined` — change likely not needed
+		*
+		* @type {boolean | null | undefined}
+		*/
+		this.fatal = void 0;
+		/**
+		* Path of a file (used throughout the `VFile` ecosystem).
+		*
+		* @type {string | undefined}
+		*/
+		this.file = "";
+		/**
+		* Reason for message.
+		*
+		* @type {string}
+		*/
+		this.message = reason;
+		/**
+		* Starting line of error.
+		*
+		* @type {number | undefined}
+		*/
+		this.line = start ? start.line : void 0;
+		/**
+		* Serialized positional info of message.
+		*
+		* On normal errors, this would be something like `ParseError`, buit in
+		* `VFile` messages we use this space to show where an error happened.
+		*/
+		this.name = stringifyPosition(options.place) || "1:1";
+		/**
+		* Place of message.
+		*
+		* @type {Point | Position | undefined}
+		*/
+		this.place = options.place || void 0;
+		/**
+		* Reason for message, should use markdown.
+		*
+		* @type {string}
+		*/
+		this.reason = this.message;
+		/**
+		* Category of message (example: `'my-rule'`).
+		*
+		* @type {string | undefined}
+		*/
+		this.ruleId = options.ruleId || void 0;
+		/**
+		* Namespace of message (example: `'my-package'`).
+		*
+		* @type {string | undefined}
+		*/
+		this.source = options.source || void 0;
+		/**
+		* Stack of message.
+		*
+		* This is used by normal errors to show where something happened in
+		* programming code, irrelevant for `VFile` messages,
+		*
+		* @type {string}
+		*/
+		this.stack = legacyCause && options.cause && typeof options.cause.stack === "string" ? options.cause.stack : "";
+		/**
+		* Specify the source value that’s being reported, which is deemed
+		* incorrect.
+		*
+		* @type {string | undefined}
+		*/
+		this.actual = void 0;
+		/**
+		* Suggest acceptable values that can be used instead of `actual`.
+		*
+		* @type {Array<string> | undefined}
+		*/
+		this.expected = void 0;
+		/**
+		* Long form description of the message (you should use markdown).
+		*
+		* @type {string | undefined}
+		*/
+		this.note = void 0;
+		/**
+		* Link to docs for the message.
+		*
+		* > 👉 **Note**: this must be an absolute URL that can be passed as `x`
+		* > to `new URL(x)`.
+		*
+		* @type {string | undefined}
+		*/
+		this.url = void 0;
+	}
+};
+VFileMessage.prototype.file = "";
+VFileMessage.prototype.name = "";
+VFileMessage.prototype.reason = "";
+VFileMessage.prototype.message = "";
+VFileMessage.prototype.stack = "";
+VFileMessage.prototype.column = void 0;
+VFileMessage.prototype.line = void 0;
+VFileMessage.prototype.ancestors = void 0;
+VFileMessage.prototype.cause = void 0;
+VFileMessage.prototype.fatal = void 0;
+VFileMessage.prototype.place = void 0;
+VFileMessage.prototype.ruleId = void 0;
+VFileMessage.prototype.source = void 0;
+//#endregion
+//#region 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/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.
+*/
+const 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/unified/lib/callable-instance.js
+const 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/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 import_extend = /* @__PURE__ */ __toESM(require_extend(), 1);
+const 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.
+*/
+const 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 src/markdown.ts
+const genId = () => `SVELTE_${Math.random().toString(36).slice(2, 10)}_${Date.now().toString(36)}`;
+const escapeSvelteText = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\{/g, "&#123;").replace(/\}/g, "&#125;");
+const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const escapeHtmlAttribute = (value) => value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+const escapeHtmlText = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+const getExpressionSurrogate = (source) => {
+	const expression = source.slice(1, -1).trim();
+	if (/^[A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*)*$/.test(expression)) return expression.replace(/\./g, " ");
+	const stringMatch = expression.match(/^(['"`])(.+)\1$/);
+	if (stringMatch) return stringMatch[2];
+	return "";
+};
+const getComponentSurrogate = (source) => {
+	if (source.startsWith("</")) return "";
+	const match = source.match(/^<([A-Z][\w.$]*)\b/);
+	if (!match) return "";
+	return match[1].split(".").filter(Boolean).join(" ");
+};
+const getPlaceholderReplacement = (token, type, original) => {
+	if (type !== "Expression" && type !== "ComponentBoundary") return token;
+	const surrogate = type === "Expression" ? getExpressionSurrogate(original) : getComponentSurrogate(original);
+	return `<svork-placeholder data-svork-id="${escapeHtmlAttribute(token)}">${escapeHtmlText(surrogate)}</svork-placeholder>`;
+};
+const isSvelteAttribute = (attr) => {
+	if (!attr || attr.type !== "Attribute") return true;
+	if (Array.isArray(attr.value)) return attr.value.some((valueNode) => valueNode?.type !== "Text");
+	return attr.value?.type === "ExpressionTag";
+};
+const maskRange = (chars, start, end) => {
+	for (let i = start; i < end; i++) if (chars[i] !== "\n" && chars[i] !== "\r") chars[i] = " ";
+};
+const overlapsRange = (ranges, start, end) => ranges.some((range) => start < range.end && end > range.start);
+const getScriptRanges = (source) => {
+	const ranges = [];
+	const scriptRegex = /<script\b[\s\S]*?<\/script>/gi;
+	let match;
+	while (match = scriptRegex.exec(source)) ranges.push({
+		start: match.index,
+		end: match.index + match[0].length
+	});
+	return ranges;
+};
+const maskMarkdownCodeForSvelteParse = (source) => {
+	const chars = source.split("");
+	const maskedRanges = [];
+	const lines = source.matchAll(/[^\n]*(?:\n|$)/g);
+	let fence = null;
+	for (const lineMatch of lines) {
+		const line = lineMatch[0];
+		const lineStart = lineMatch.index ?? 0;
+		if (line === "" && lineStart === source.length) continue;
+		if (fence) {
+			const closeMarker = line.match(/^( {0,3})(`{3,}|~{3,})\s*(?:\n|$)/)?.[2];
+			if (closeMarker && closeMarker[0] === fence.marker && closeMarker.length >= fence.length) {
+				const end = lineStart + line.length;
+				maskedRanges.push({
+					start: fence.start,
+					end
+				});
+				maskRange(chars, fence.start, end);
+				fence = null;
+			}
+			continue;
+		}
+		const openMarker = line.match(/^( {0,3})(`{3,}|~{3,})/)?.[2];
+		if (openMarker) fence = {
+			marker: openMarker[0],
+			length: openMarker.length,
+			start: lineStart
+		};
+	}
+	if (fence) {
+		maskedRanges.push({
+			start: fence.start,
+			end: source.length
+		});
+		maskRange(chars, fence.start, source.length);
+	}
+	const ignoredInlineRanges = maskedRanges.concat(getScriptRanges(source));
+	const inlineCodeRegex = /(`+)([^\n]*?)\1/g;
+	let inlineMatch;
+	while (inlineMatch = inlineCodeRegex.exec(source)) {
+		const start = inlineMatch.index;
+		const end = start + inlineMatch[0].length;
+		if (overlapsRange(ignoredInlineRanges, start, end)) continue;
+		maskRange(chars, start, end);
+	}
+	return chars.join("");
+};
+const escapeSvelteTextBraces = (value) => value.replace(/\{/g, "&#123;").replace(/\}/g, "&#125;");
+function escapeBracesPlugin() {
+	return (tree) => {
+		const SKIP = new Set(["script", "style"]);
+		const escapeProperties = (properties) => {
+			if (!properties) return;
+			for (const [key, value] of Object.entries(properties)) if (typeof value === "string") properties[key] = escapeSvelteTextBraces(value);
+			else if (Array.isArray(value)) properties[key] = value.map((item) => typeof item === "string" ? escapeSvelteTextBraces(item) : item);
+		};
+		const visit = (node, ancestors) => {
+			if (!node) return;
+			if (node.type === "element") escapeProperties(node.properties);
+			if (node.type === "text") {
+				if (!ancestors.some((a) => a?.type === "element" && typeof a.tagName === "string" && SKIP.has(a.tagName)) && typeof node.value === "string" && (node.value.includes("{") || node.value.includes("}"))) node.value = escapeSvelteTextBraces(node.value);
+			}
+			for (const key of Object.keys(node)) {
+				const child = node[key];
+				if (Array.isArray(child)) for (const c of child) visit(c, ancestors.concat(node));
+				else if (child && typeof child === "object" && child.type) visit(child, ancestors.concat(node));
+			}
+		};
+		visit(tree, []);
+	};
+}
+const svelteMarkdown = (options) => {
+	const hasWantedExt = (s) => (options?.extensions ?? [".md"]).some((e) => s.endsWith(e.trim()));
+	const FRONTMATTER_REGEX = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/;
+	const mdCompiler = unified().use(remarkParse).use(options?.remarkPlugins ?? []).use(remarkRehype, { allowDangerousHtml: true }).use(rehypeRaw).use(options?.rehypePlugins ?? []).use(escapeBracesPlugin).use(rehypeStringify, { allowDangerousHtml: true });
+	return {
+		name: "svelteMarkdown",
+		markup: async ({ content, filename }) => {
+			if (!filename || !hasWantedExt(filename)) return;
+			let metadata = {};
+			let workingString = content;
+			const fmMatch = workingString.match(FRONTMATTER_REGEX);
+			if (fmMatch) {
+				try {
+					metadata = yaml.load(fmMatch[1]) ?? {};
+				} catch (e) {
+					console.error(`[svelteMarkdown] Frontmatter YAML parsing error in ${filename}:`, e);
+				}
+				workingString = workingString.slice(fmMatch[0].length);
+			}
+			const finalize = async (markdownSource, placeholderMap = /* @__PURE__ */ new Map()) => {
+				let compiled = String(await mdCompiler.process(markdownSource));
+				compiled = compiled.replace(/(&amp;#123;|&#x26;#123;)/g, "&#123;").replace(/(&amp;#125;|&#x26;#125;)/g, "&#125;");
+				let restored = compiled;
+				const metadataString = `\nexport const metadata = ${JSON.stringify(metadata)};\n`;
+				for (const [placeholder, info] of placeholderMap.entries()) {
+					const escPlaceholder = escapeRegExp(placeholder);
+					const markerPattern = `<svork-placeholder\\s+data-svork-id=(["'])${escPlaceholder}\\1[^>]*>[\\s\\S]*?<\\/svork-placeholder>`;
+					const markerRegex = new RegExp(markerPattern, "g");
+					if (info.type === "ComponentBoundary" || info.type === "InstanceScript" || info.type === "ModuleScript" || info.type === "EscapedText") {
+						const pMarkerRegex = new RegExp(`<p>\\s*${markerPattern}\\s*</p>`, "g");
+						if (pMarkerRegex.test(restored)) {
+							restored = restored.replace(pMarkerRegex, () => info.original);
+							continue;
+						}
+					}
+					if (markerRegex.test(restored)) {
+						restored = restored.replace(markerRegex, () => info.original);
+						continue;
+					}
+					if (info.type === "InstanceScript" || info.type === "ModuleScript" || info.type === "ComponentBoundary" || info.type === "EscapedText") {
+						const escapedReplacement = escapeRegExp(info.replacement);
+						const pRegex = new RegExp(`<p>\\s*${escapedReplacement}\\s*</p>`, "g");
+						if (pRegex.test(restored)) {
+							restored = restored.replace(pRegex, () => info.original);
+							continue;
+						}
+					}
+					if (info.type === "Expression") {
+						const quotedRegex = new RegExp(`(["'])${escPlaceholder}\\1`, "g");
+						if (quotedRegex.test(restored)) {
+							restored = restored.replace(quotedRegex, () => info.original);
+							continue;
+						}
+						const braceWrappedRegex = new RegExp(`\\{\\s*${escPlaceholder}\\s*\\}`, "g");
+						if (braceWrappedRegex.test(restored)) {
+							restored = restored.replace(braceWrappedRegex, () => info.original);
+							continue;
+						}
+					}
+					restored = restored.replace(new RegExp(placeholder, "g"), () => info.original);
+				}
+				restored = `<script module lang="ts">${metadataString}<\/script>\n` + restored;
+				return restored;
+			};
+			let root;
+			try {
+				root = parse(maskMarkdownCodeForSvelteParse(workingString), { modern: true });
+			} catch (err) {
+				console.warn(`[svelteMarkdown] Svelte AST parsing failed for ${filename}, executing full-text fallback compilation.`);
+				return { code: await finalize(workingString) };
+			}
+			const targets = [];
+			if (root.instance) targets.push({
+				type: "InstanceScript",
+				start: root.instance.start,
+				end: root.instance.end
+			});
+			if (root.module) targets.push({
+				type: "ModuleScript",
+				start: root.module.start,
+				end: root.module.end
+			});
+			const getFragmentBounds = (frag) => {
+				if (frag && Array.isArray(frag.nodes) && frag.nodes.length > 0) return {
+					start: frag.nodes[0].start,
+					end: frag.nodes[frag.nodes.length - 1].end
+				};
+				return null;
+			};
+			const walk = (node) => {
+				if (!node) return;
+				if (node.type === "ExpressionTag") {
+					targets.push({
+						type: "Expression",
+						start: node.start,
+						end: node.end
+					});
+					return;
+				}
+				if (node.type === "RegularElement") {
+					if (node.attributes?.some((attr) => isSvelteAttribute(attr))) {
+						targets.push({
+							type: "EscapedText",
+							start: node.start,
+							end: node.end
+						});
+						return;
+					}
+				}
+				if (node.type === "Component") {
+					const bounds = getFragmentBounds(node.fragment);
+					if (bounds) {
+						targets.push({
+							type: "ComponentBoundary",
+							start: node.start,
+							end: bounds.start
+						});
+						targets.push({
+							type: "ComponentBoundary",
+							start: bounds.end,
+							end: node.end
+						});
+						walk(node.fragment);
+					} else targets.push({
+						type: "ComponentBoundary",
+						start: node.start,
+						end: node.end
+					});
+					return;
+				}
+				if (node.fragment) walk(node.fragment);
+				if (Array.isArray(node.nodes)) for (const child of node.nodes) walk(child);
+			};
+			walk(root.fragment);
+			const validTargets = targets.filter((t) => t.start < t.end);
+			validTargets.sort((a, b) => b.start - a.start);
+			const placeholderMap = /* @__PURE__ */ new Map();
+			let substitutedString = workingString;
+			for (let i = 0; i < validTargets.length; i++) {
+				const target = validTargets[i];
+				const originalSource = substitutedString.slice(target.start, target.end);
+				const original = target.type === "EscapedText" ? escapeSvelteText(originalSource) : originalSource;
+				const id = genId();
+				const placeholder = `SVELTE_${target.type.toUpperCase()}_${id}_${i}_SVELTE`;
+				const replacement = getPlaceholderReplacement(placeholder, target.type, original);
+				placeholderMap.set(placeholder, {
+					original,
+					replacement,
+					type: target.type
+				});
+				substitutedString = substitutedString.slice(0, target.start) + replacement + substitutedString.slice(target.end);
+			}
+			return { code: await finalize(substitutedString, placeholderMap) };
+		}
+	};
+};
+//#endregion
+export { svelteMarkdown };